SchoolController.go

package controllers

import (
	"WorldEpcho/src/config"
	database "WorldEpcho/src/datasource"
	"WorldEpcho/src/models"
	"WorldEpcho/src/service"
	"WorldEpcho/src/utils"
	"encoding/json"
	"fmt"
	"github.com/gin-gonic/gin"
	"github.com/go-xorm/xorm"
	"log"
	"net/http"
	"time"
)

//录入学校和班级信息接口
func CreateSchoolAndClasses(c *gin.Context) {
	/*
	   判断用户是否登录
	*/
	userID, isLogin := service.IsUserLoggedIn(c)
	if !isLogin {
		log.Println("用户未登录")
		c.JSON(http.StatusOK, gin.H{"code": 0, "message": "用户未登录"})
		return
	}
	level, err1 := models.GetUserLevel(userID)
	if err1 != nil {
		log.Println("查询用户权限出错")
		c.JSON(http.StatusOK, gin.H{"code": 0, "message": "查询用户权限出错"})
		return
	}
	if level > 3 {
		c.JSON(http.StatusOK, gin.H{"code": 0, "message": "用户权限不足"})
		return
	}
	var schoolWithClassNames models.SchoolWithClassNames
	if err := c.BindJSON(&schoolWithClassNames); err != nil {
		c.JSON(http.StatusOK, gin.H{"code": 0, "message": err.Error()})
		return
	}
	school, exist, err1 := models.QuerySchoolByName(schoolWithClassNames.SchoolName)
	if err1 != nil {
		c.JSON(http.StatusOK, gin.H{"code": 0, "message": "根据学校名称查询学校信息"})
		return
	}
	if exist {
		c.JSON(http.StatusOK, gin.H{"code": 0, "message": "学校名称已存在"})
		return
	}
	fmt.Println("school: ", school)

	// 生成学校ID和负责人标识码，这里只是示例，生产环境应相应更安全
	SchoolIdenfier := utils.GenerateSchoolClassCode()
	newSchool := &models.School{
		SchoolNo:      SchoolIdenfier,
		SchoolName:    schoolWithClassNames.SchoolName,
		Address:       schoolWithClassNames.Address,
		Contact:       schoolWithClassNames.Contact,
		ContactNumber: schoolWithClassNames.ContactNumber,
	}

	// 准备班级信息切片
	var classes []*models.Class
	//calssNo := utils.GenerateSchoolClassCode()

	for _, className := range schoolWithClassNames.ClassNames {
		newClass := models.Class{
			SchoolNo:  SchoolIdenfier,
			ClassName: className,
			ClassNo:   utils.GenerateSchoolClassCode(),
		}
		classes = append(classes, &newClass)
	}

	// 使用插入学校和班级的函数
	if err := models.InsertSchoolAndClasses(newSchool, classes); err != nil {
		// 如果发生错误，返回错误信息
		c.JSON(http.StatusOK, gin.H{
			"code":    0,
			"message": "Failed to create school and classes",
			"error":   err.Error(),
		})
		return
	}

	// 如果一切正常，返回成功
	response := gin.H{
		"code":    1,
		"message": "录入学校和班级信息成功",
	}
	// 序列化响应数据为 JSON 字符串
	jsonData, err := json.Marshal(response)
	if err != nil {
		// 处理序列化错误
		fmt.Println("序列化 JSON 数据出错:", err)
		return
	}
	fmt.Println(config.ColorPurple, string(jsonData), config.ColorReset)

	c.JSON(http.StatusOK, response)

}

/*
   传参学校激活码，家长手机号，家长姓名，学生学号，姓名，性别，生日
   根据信息构造两个用户，家长和学生，默认将学生放到家长的观察组，和负责人班级的观察组
   或  填写负责人识别码，手机号，密码 构建负责人注册。
*/
func QuickSchoolRegisterStuAndPatriarch(c *gin.Context) {
	//学校编号
	schoolNo := c.PostForm("schoolNo")
	//家长信息
	phone := c.PostForm("patriarch_phone")
	parent_name := c.PostForm("patriarch_name")
	//学生信息
	//unit := c.PostForm("SchoolName")
	stuNo := c.PostForm("stuNo")
	classNo := c.PostForm("classNo")
	stu_name := c.PostForm("stu_name")
	password := c.PostForm("password")
	sex := c.PostForm("sex")
	birthday := c.PostForm("birthday")
	//验证码
	sms_code := c.PostForm("sms_code")
	smsCode, bol := config.WorldLoginCacheCode.Get(phone)
	codeStr := utils.Strval(smsCode)
	fmt.Println("smsCode: ", codeStr)
	//判断表单中获取的验证码和缓存中的验证码是否相等
	if !bol && codeStr != sms_code {
		c.JSON(http.StatusOK, gin.H{
			"code":    0,
			"message": "验证码不存在或验证码错误!",
		})
		return
	}
	//组群名称
	//groupName := c.PostForm("group_name")
	//开启事务
	session := database.Engine.NewSession()
	defer session.Close() //延迟关闭session
	// 设置事务的隔离级别为 READ COMMITTED，这是允许幻读的一个较为安全的隔离级别。
	if _, err := session.Exec("SET SESSION TRANSACTION ISOLATION LEVEL READ COMMITTED"); err != nil {
		// 处理错误
		c.JSON(http.StatusOK, gin.H{"code": 0, "message": "设置事务隔离级别失败!"})
		fmt.Println("设置事务隔离级别失败")
		return
	}
	err := session.Begin()
	if err != nil {
		c.JSON(http.StatusOK, gin.H{"code": 0, "message": "开启事务失败!"})
		fmt.Println("开启事务失败")
		return
	}

	Schexist, school, err := models.GetSchoolByNo(schoolNo)
	if err != nil {
		c.JSON(http.StatusOK, gin.H{"code": 0, "message": "根据学校编号查询学校信息出错!"})
		fmt.Println("根据学校编号查询学校信息出错")
		return
	}
	class, err := models.GetClassByNo(classNo)
	if err != nil {
		c.JSON(http.StatusOK, gin.H{"code": 0, "message": "根据班级编号查询班级信息出错!"})
		fmt.Println("根据班级编号查询班级信息出错")
		return
	}

	if !Schexist {
		c.JSON(http.StatusOK, gin.H{"code": 0, "message": "学校信息不存在,请先录入你的学校信息!"})
		fmt.Println("学校信息不存在,请先录入你的学校信息")
		return
	}
	unit := school.SchoolName
	/* =====  家长信息录入  ==== */

	var newGroupNo string
	ClassGroupName := school.SchoolName + "_" + classNo + "_" + class.ClassName
	//ClassGroupName := school.SchoolName + "_" + classNo
	ParentGroupName := phone + "_" + stuNo
	//根据手机号查询家长用户是否存在
	Patriarch_user := &models.User{Phone: phone}
	PatriarchUserInfo := &models.UserInfo{Phone: phone}
	existPatriarchUser, exist_Patriarch, err := models.GetUserByPhone(session, Patriarch_user.Phone)
	if err != nil {
		fmt.Println("根据手机号查询用户是否存在, 查询失败")
		c.JSON(http.StatusOK, gin.H{"code": 0, "message": "根据手机号查询用户是否存在，查询失败"})
		return
	}
	//统一设置初始密码
	//initPassWord := "88888888"
	salt := config.Conf.Md5Salt
	passStr, err := utils.MD5BySalf(password, salt)
	if err != nil {
		log.Println("密码加盐失败！")
		c.JSON(http.StatusOK, gin.H{"code": 0, "message": "密码加盐失败"})
		return
	}

	if !exist_Patriarch {
		//用户不存在，需要新创建用户，为用户设置初始密码加密
		Patriarch_user.Username = phone
		Patriarch_user.Password = passStr
		Patriarch_user.Status = 0
		Patriarch_user.Level = 9
		uid, err := models.FindOrCreateOrUpdateUser(session, Patriarch_user)
		if err != nil {
			c.JSON(http.StatusOK, gin.H{"code": 0, "message": "插入用户数据失败"})
			return
		}
		/*
		  将新创建的用户id赋值给用户详情信息对象
		*/
		PatriarchUserInfo.UserId = uid
		PatriarchUserInfo.UserName = parent_name
		//用户详情信息表操作
		err = models.FindOrCreateOrUpdateUserInfoByPhone(session, PatriarchUserInfo)
		if err != nil {
			fmt.Printf("向用户信息表添加用户数据失败")
			c.JSON(http.StatusOK, gin.H{"code": 0, "message": err.Error()})
			return
		} else {
			/*应用组群操作*/
			newGroupNo = utils.GenerateInviteCode(uid)
			//家长组群权限
			PatriarchUserPermission := 0
			err := CreateNewAppGroup(session, newGroupNo, ParentGroupName, uid, PatriarchUserPermission)
			if err != nil {
				fmt.Printf("创建应用组群失败")
				c.JSON(http.StatusOK, gin.H{"code": 0, "message": "创建应用组群失败"})
				return
			}
			exist, _, err := models.GetAppGroupByID(session, newGroupNo)
			if err != nil {
				c.JSON(http.StatusOK, gin.H{"code": 0, "message": "查询应用组群失败"})
				return
			}
			if !exist {
				c.JSON(http.StatusOK, gin.H{"code": 0, "message": "应用组群不存在"})
				return
			}
		}
	} else {

		/*应用组群操作*/
		//家长用户存在，判断家庭应用组群是否存在
		AppGroup, existAppGroup, err := models.FindAppGroupByGroupName(session, ParentGroupName)
		if err != nil {
			fmt.Printf("根据组群名查询组群是否存在出错")
			c.JSON(http.StatusOK, gin.H{"code": 0, "message": "根据组群名查询组群是否存在出错"})
			return
		}
		//组群存在的话赋值
		if existAppGroup {
			newGroupNo = AppGroup.No
		} else {
			newGroupNo = utils.GenerateInviteCode(existPatriarchUser.Id)
		}
		PatriarchUserPermission := 0
		if !existAppGroup {

			err := CreateNewAppGroup(session, newGroupNo, ParentGroupName, existPatriarchUser.Id, PatriarchUserPermission)
			if err != nil {
				fmt.Printf("创建应用组群失败")
				c.JSON(http.StatusOK, gin.H{"code": 0, "message": "创建应用组群失败"})
				return
			}
		} else {
			//判断家长是否在群里
			_, exist_mem, err := models.DoesGroupContainMember(session, newGroupNo, ParentGroupName, existPatriarchUser.Id)
			if err != nil {
				fmt.Printf("查询应用组群中某个成员是否存在出错")
				c.JSON(http.StatusOK, gin.H{"code": 0, "message": "查询应用组群中某个成员是否存在出错"})
				return
			}
			//如果不在群里则添加
			if !exist_mem {
				PatriarchUserPermission := 0
				err := AddStuAndTeacherToAppGroup(session, existPatriarchUser.Id, newGroupNo, PatriarchUserPermission)
				if err != nil {
					fmt.Printf("添加用户到应用组群失败")
					c.JSON(http.StatusOK, gin.H{"code": 0, "message": "添加用户到应用组群失败"})
					return
				}
			}

		}

	}

	/* 学生信息 */
	//构建用户详情信息结构体对象
	Stu_userinfo := &models.UserInfo{
		StudentId: stuNo,
		Unit:      unit,
	}
	//查询用户详情信息
	exist_StuUserInfo, stu_exist, err := models.FindUserByStudentIdAndUnit(session, Stu_userinfo)
	if err != nil {
		c.JSON(http.StatusOK, gin.H{"code": 0, "message": "根据学号和单位名称查询用户信息失败!"})
		return
	}

	if !stu_exist {
		Stu_userinfo.UserName = stu_name
		Stu_userinfo.ClassNo = classNo
		//这里没有手机号，因为手机号在表中为唯一索引，因此用手机号_学校名称的字符串存入
		CreatePhone := stuNo + "_" + unit
		//定义用户注册信息
		stu_user := &models.User{
			Username:   stuNo,
			Createtime: time.Now().Unix(),
			Password:   passStr,
			Phone:      CreatePhone,
			Level:      9,
			Status:     0,
		}
		_, id, err := models.CreateAndUpdateUser(session, stu_user)
		if err != nil {
			c.JSON(http.StatusOK, gin.H{"code": 0, "message": "插入或更新用户数据失败!"})
			return
		}
		//用户详情信息表中不存在该用户的详情信息
		Stu_userinfo.UserId = id
		Stu_userinfo.UserBirthday = birthday
		Stu_userinfo.UserSex = sex
		//创建用户详情信息
		err = models.CreateUserInfo(session, Stu_userinfo)
		if err != nil {
			c.JSON(http.StatusOK, gin.H{"code": 0, "message": "插入用户详情信息失败!"})
			return
		} else {

			/*
				添加学生到家长应用组群中
			*/
			Stu_userPermission := 9
			// 添加学生到家长应用组群中
			err := AddStuAndTeacherToAppGroup(session, Stu_userinfo.UserId, newGroupNo, Stu_userPermission)
			if err != nil {
				fmt.Printf("添加用户到应用组群失败")
				c.JSON(http.StatusOK, gin.H{"code": 0, "message": "添加用户到应用组群失败"})
				return
			}
			/*
			 添加学生到班级应用组群中
			*/

			classGroupExist, group, err := models.DoesAppGroupExist(session, ClassGroupName)
			if err != nil {
				fmt.Printf("查询应用组群出错")
				c.JSON(http.StatusOK, gin.H{"code": 0, "message": "查询应用组群出错"})
				return
			}
			GroupNo := utils.GenerateInviteCode(Stu_userinfo.UserId)
			// 班级组群不存在
			if !classGroupExist {
				Stu_userPermission = 9
				err := CreateNewAppGroup(session, GroupNo, ClassGroupName, Stu_userinfo.UserId, Stu_userPermission)
				if err != nil {
					fmt.Printf("创建应用组群失败")
					c.JSON(http.StatusOK, gin.H{"code": 0, "message": "创建应用组群失败"})
					return
				}
				// 根据用户id和组群号查询用户权限
				/*	_, groupPermission, err := models.GetUserPermission(session, GroupNo, Stu_userinfo.UserId)
					if err != nil {
						fmt.Printf("根据用户id和组群号查询用户权限出错")
						c.JSON(http.StatusOK, gin.H{"code": 0, "message": "根据用户id和组群号查询用户权限出错"})
						return
					}
					groupPermission.Permission = 9
					_, err = models.UpdateAppGroupPermission(session, groupPermission)
					if err != nil {
						fmt.Printf("更新用户权限出错")
						c.JSON(http.StatusOK, gin.H{"code": 0, "message": "更新用户权限出错"})
						return
					}
				*/
			} else {
				//如果班级应用组群存在，直接添加学生入群
				Stu_userPermission = 9
				err := AddStuAndTeacherToAppGroup(session, Stu_userinfo.UserId, group.No, Stu_userPermission)
				if err != nil {
					fmt.Printf("添加用户到应用组群失败")
					c.JSON(http.StatusOK, gin.H{"code": 0, "message": "添加用户到应用组群失败"})
					return
				}
			}

		}

	} else {
		//用户已经存在，添加学生到应用组群中
		//判断学生是否已经在家长的应用组群中，如果存在则不添加，不存在添加入群
		_, exist_mem, err := models.DoesGroupContainMember(session, newGroupNo, ParentGroupName, exist_StuUserInfo.UserId)
		if err != nil {
			fmt.Printf("查询应用组群中某个成员是否存在出错")
			c.JSON(http.StatusOK, gin.H{"code": 0, "message": "查询应用组群中某个成员是否存在出错"})
			return
		}
		if !exist_mem {

			Stu_userPermission := 9
			err := AddStuAndTeacherToAppGroup(session, exist_StuUserInfo.UserId, newGroupNo, Stu_userPermission)
			if err != nil {
				fmt.Printf("添加用户到应用组群失败")
				c.JSON(http.StatusOK, gin.H{"code": 0, "message": "添加用户到应用组群失败"})
				return
			}
		}

		/*
		 添加学生到班级应用组群中
		*/
		//根据组群名称查询班级应用组群是否存在，如果存在则入群，不存在则创建并入群，并修改学生的权限
		classGroupExist, group, err := models.DoesAppGroupExist(session, ClassGroupName)
		if err != nil {
			fmt.Printf("查询应用组群出错")
			c.JSON(http.StatusOK, gin.H{"code": 0, "message": "查询应用组群出错"})
			return
		}
		GroupNo := utils.GenerateInviteCode(Stu_userinfo.UserId)
		Stu_userPermission := 9
		if !classGroupExist {
			err := CreateNewAppGroup(session, GroupNo, ClassGroupName, Stu_userinfo.UserId, Stu_userPermission)
			if err != nil {
				fmt.Printf("创建应用组群失败")
				c.JSON(http.StatusOK, gin.H{"code": 0, "message": "创建应用组群失败"})
				return
			}
			// 根据用户id和组群号查询用户权限出错
			_, groupPermission, err := models.GetUserPermission(session, GroupNo, Stu_userinfo.UserId)
			if err != nil {
				fmt.Printf("根据用户id和组群号查询用户权限出错")
				c.JSON(http.StatusOK, gin.H{"code": 0, "message": "根据用户id和组群号查询用户权限出错"})
				return
			}
			groupPermission.Permission = 9
			_, err = models.UpdateAppGroupPermission(session, groupPermission)
			if err != nil {
				fmt.Printf("更新用户权限出错")
				c.JSON(http.StatusOK, gin.H{"code": 0, "message": "更新用户权限出错"})
				return
			}

		} else {
			//如果班级应用组群存在，直接添加学生入群
			err := AddStuAndTeacherToAppGroup(session, Stu_userinfo.UserId, group.No, Stu_userPermission)
			if err != nil {
				fmt.Printf("添加用户到应用组群失败")
				c.JSON(http.StatusOK, gin.H{"code": 0, "message": "添加用户到应用组群失败"})
				return
			}
		}

	}
	// 提交事务
	err = session.Commit()
	if err != nil {
		c.JSON(http.StatusOK, gin.H{"code": 0, "message": "提交事务失败!"})
		fmt.Println("提交事务失败")
		return
	}

	response := gin.H{
		"code":    1,
		"message": "用户表和用户详情信息表数据录入成功,创建组群成功",
	}
	// 序列化响应数据为 JSON 字符串
	jsonData, err := json.Marshal(response)
	if err != nil {
		// 处理序列化错误
		fmt.Println("序列化 JSON 数据出错:", err)
		return
	}
	fmt.Println("用户表和用户详情信息表数据录入成功,创建组群成功, Response:", string(jsonData))
	fmt.Println(config.ColorGreen, "用户表和用户详情信息表数据录入成功,创建组群成功", config.ColorReset)
	c.JSON(http.StatusOK, response)

}

/*
   家长不需要注册
*/
func QuickSchoolRegisterStudent(c *gin.Context) {
	//学校编号
	schoolNo := c.PostForm("schoolNo")
	stuNo := c.PostForm("stuNo")
	classNo := c.PostForm("classNo")
	stu_name := c.PostForm("stu_name")
	password := c.PostForm("password")
	sex := c.PostForm("sex")
	birthday := c.PostForm("birthday")

	//开启事务
	session := database.Engine.NewSession()
	defer session.Close() //延迟关闭session
	// 设置事务的隔离级别为 READ COMMITTED，这是允许幻读的一个较为安全的隔离级别。
	if _, err := session.Exec("SET SESSION TRANSACTION ISOLATION LEVEL READ COMMITTED"); err != nil {
		// 处理错误
		c.JSON(http.StatusOK, gin.H{"code": 0, "message": "设置事务隔离级别失败!"})
		fmt.Println("设置事务隔离级别失败")
		return
	}
	err := session.Begin()
	if err != nil {
		c.JSON(http.StatusOK, gin.H{"code": 0, "message": "开启事务失败!"})
		fmt.Println("开启事务失败")
		return
	}

	Schexist, school, err := models.GetSchoolByNo(schoolNo)
	if err != nil {
		c.JSON(http.StatusOK, gin.H{"code": 0, "message": "根据学校编号查询学校信息出错!"})
		fmt.Println("根据学校编号查询学校信息出错")
		return
	}
	class, err := models.GetClassByNo(classNo)
	if err != nil {
		c.JSON(http.StatusOK, gin.H{"code": 0, "message": "根据班级编号查询班级信息出错!"})
		fmt.Println("根据班级编号查询班级信息出错")
		return
	}

	if !Schexist {
		c.JSON(http.StatusOK, gin.H{"code": 0, "message": "学校信息不存在,请先录入你的学校信息!"})
		fmt.Println("学校信息不存在,请先录入你的学校信息")
		return
	}
	unit := school.SchoolName

	ClassGroupName := school.SchoolName + "_" + classNo + "_" + class.ClassName

	salt := config.Conf.Md5Salt
	passStr, err := utils.MD5BySalf(password, salt)
	if err != nil {
		log.Println("密码加盐失败！")
		c.JSON(http.StatusOK, gin.H{"code": 0, "message": "密码加盐失败"})
		return
	}

	/* 学生信息 */
	//构建用户详情信息结构体对象
	Stu_userinfo := &models.UserInfo{
		StudentId: stuNo,
		Unit:      unit,
	}
	//查询用户详情信息
	exist_StuUserInfo, stu_exist, err := models.FindUserByStudentIdAndUnit(session, Stu_userinfo)
	if err != nil {
		c.JSON(http.StatusOK, gin.H{"code": 0, "message": "根据学号和单位名称查询用户信息失败!"})
		return
	}

	if !stu_exist {
		Stu_userinfo.UserName = stu_name
		Stu_userinfo.ClassNo = classNo
		//这里没有手机号，因为手机号在表中为唯一索引，因此用手机号_学校名称的字符串存入
		CreatePhone := stuNo + "_" + unit
		//定义用户注册信息
		stu_user := &models.User{
			Username:   stuNo,
			Createtime: time.Now().Unix(),
			Password:   passStr,
			Phone:      CreatePhone,
			Level:      9,
			Status:     0,
		}
		_, id, err := models.CreateAndUpdateUser(session, stu_user)
		if err != nil {
			c.JSON(http.StatusOK, gin.H{"code": 0, "message": "插入或更新用户数据失败!"})
			return
		}
		//用户详情信息表中不存在该用户的详情信息
		Stu_userinfo.UserId = id
		Stu_userinfo.UserBirthday = birthday
		Stu_userinfo.UserSex = sex
		//创建用户详情信息
		err = models.CreateUserInfo(session, Stu_userinfo)
		if err != nil {
			c.JSON(http.StatusOK, gin.H{"code": 0, "message": "插入用户详情信息失败!"})
			return
		} else {

			/*
			 添加学生到班级应用组群中
			*/

			classGroupExist, group, err := models.DoesAppGroupExist(session, ClassGroupName)
			if err != nil {
				fmt.Printf("查询应用组群出错")
				c.JSON(http.StatusOK, gin.H{"code": 0, "message": "查询应用组群出错"})
				return
			}
			GroupNo := utils.GenerateInviteCode(Stu_userinfo.UserId)
			// 班级组群不存在
			if !classGroupExist {
				Stu_userPermission := 9
				err := CreateNewAppGroup(session, GroupNo, ClassGroupName, Stu_userinfo.UserId, Stu_userPermission)
				if err != nil {
					fmt.Printf("创建应用组群失败")
					c.JSON(http.StatusOK, gin.H{"code": 0, "message": "创建应用组群失败"})
					return
				}

			} else {
				//如果班级应用组群存在，直接添加学生入群
				Stu_userPermission := 9
				err := AddStuAndTeacherToAppGroup(session, Stu_userinfo.UserId, group.No, Stu_userPermission)
				if err != nil {
					fmt.Printf("添加用户到应用组群失败")
					c.JSON(http.StatusOK, gin.H{"code": 0, "message": "添加用户到应用组群失败"})
					return
				}
			}

		}

	} else {
		//用户已经存在，添加学生到应用组群中
		//exist_StuUserInfo
		/*
		 添加学生到班级应用组群中
		*/
		//根据组群名称查询班级应用组群是否存在，如果存在则入群，不存在则创建并入群，并修改学生的权限
		classGroupExist, group, err := models.DoesAppGroupExist(session, ClassGroupName)
		if err != nil {
			fmt.Printf("查询应用组群出错")
			c.JSON(http.StatusOK, gin.H{"code": 0, "message": "查询应用组群出错"})
			return
		}
		GroupNo := utils.GenerateInviteCode(exist_StuUserInfo.UserId)

		Stu_userPermission := 9
		if !classGroupExist {
			err := CreateNewAppGroup(session, GroupNo, ClassGroupName, exist_StuUserInfo.UserId, Stu_userPermission)
			if err != nil {
				fmt.Printf("创建应用组群失败")
				c.JSON(http.StatusOK, gin.H{"code": 0, "message": "创建应用组群失败"})
				return
			}

			// 根据用户id和组群号查询用户权限出错
			_, groupPermission, err := models.GetUserPermission(session, GroupNo, exist_StuUserInfo.UserId)
			if err != nil {
				fmt.Printf("根据用户id和组群号查询用户权限出错")
				c.JSON(http.StatusOK, gin.H{"code": 0, "message": "根据用户id和组群号查询用户权限出错"})
				return
			}
			groupPermission.Permission = 9
			_, err = models.UpdateAppGroupPermission(session, groupPermission)
			if err != nil {
				fmt.Printf("更新用户权限出错")
				c.JSON(http.StatusOK, gin.H{"code": 0, "message": "更新用户权限出错"})
				return
			}

		} else {
			//如果班级应用组群存在，直接添加学生入群
			err := AddStuAndTeacherToAppGroup(session, Stu_userinfo.UserId, group.No, Stu_userPermission)
			if err != nil {
				fmt.Printf("添加用户到应用组群失败")
				c.JSON(http.StatusOK, gin.H{"code": 0, "message": "添加用户到应用组群失败"})
				return
			}
		}

	}
	// 提交事务
	err = session.Commit()
	if err != nil {
		c.JSON(http.StatusOK, gin.H{"code": 0, "message": "提交事务失败!"})
		fmt.Println("提交事务失败")
		return
	}

	response := gin.H{
		"code":    1,
		"message": "用户表和用户详情信息表数据录入成功,创建组群成功",
	}
	// 序列化响应数据为 JSON 字符串
	jsonData, err := json.Marshal(response)
	if err != nil {
		// 处理序列化错误
		fmt.Println("序列化 JSON 数据出错:", err)
		return
	}
	fmt.Println("用户表和用户详情信息表数据录入成功,创建组群成功, Response:", string(jsonData))
	fmt.Println(config.ColorGreen, "用户表和用户详情信息表数据录入成功,创建组群成功", config.ColorReset)
	c.JSON(http.StatusOK, response)

}

/*
  填写负责人班级码，手机号，密码 构建负责人注册或负责人班级的观察组
*/
func QuickRegisterClassLeaderAndCreateAppGroup(c *gin.Context) {
	//学校编号
	schoolNo := c.PostForm("schoolNo")
	classNo := c.PostForm("classNo")
	classLeaderName := c.PostForm("classLeaderName")
	password := c.PostForm("password")
	phone := c.PostForm("phone")
	//groupName := c.PostForm("groupName")
	sms_code := c.PostForm("sms_code")
	smsCode, bol := config.WorldLoginCacheCode.Get(phone)
	codeStr := utils.Strval(smsCode)
	fmt.Println("smsCode: ", codeStr)
	//判断表单中获取的验证码和缓存中的验证码是否相等
	if !bol && codeStr != sms_code {
		c.JSON(http.StatusOK, gin.H{
			"code":    0,
			"message": "验证码不存在或验证码错误!",
		})
		return
	}
	var newGroupNo string
	//开启事务
	session := database.Engine.NewSession()
	defer session.Close() //延迟关闭session
	// 设置事务的隔离级别为 READ COMMITTED，这是允许幻读的一个较为安全的隔离级别。
	if _, err := session.Exec("SET TRANSACTION ISOLATION LEVEL READ COMMITTED"); err != nil {
		// 处理错误
		c.JSON(http.StatusOK, gin.H{"code": 0, "message": "设置事务隔离级别失败!"})
		fmt.Println("设置事务隔离级别失败")
		return
	}
	err := session.Begin()
	if err != nil {
		c.JSON(http.StatusOK, gin.H{"code": 0, "message": "开启事务失败!"})
		fmt.Println("开启事务失败")
		return
	}
	Schexist, school, err := models.GetSchoolByNo(schoolNo)
	if err != nil {
		c.JSON(http.StatusOK, gin.H{"code": 0, "message": "根据学校编号查询学校信息出错!"})
		fmt.Println("根据学校编号查询学校信息出错")
		return
	}
	if !Schexist {
		c.JSON(http.StatusOK, gin.H{"code": 0, "message": "学校信息不存在,请先录入你的学校信息!"})
		fmt.Println("学校信息不存在,请先录入你的学校信息")
		return
	}
	//组群名称
	ClassGroupName := school.SchoolName + "_" + classNo

	//统一设置初始密码
	//initPassWord := "88888888"
	salt := config.Conf.Md5Salt
	passStr, err := utils.MD5BySalf(password, salt)
	if err != nil {
		log.Println("密码加盐失败！")
		c.JSON(http.StatusOK, gin.H{"code": 0, "message": "密码加盐失败"})
		return
	}
	Teacher_user := &models.User{Phone: phone}
	TeacherUserInfo := &models.UserInfo{Phone: phone}
	class := &models.Class{SchoolNo: schoolNo, ClassNo: classNo}

	//根据手机号查询教师用户是否存在
	existTeacherUser, exist, err := models.GetUserByPhone(session, phone)
	if err != nil {
		fmt.Println("根据手机号查询用户是否存在, 查询失败")
		c.JSON(http.StatusOK, gin.H{"code": 0, "message": "根据手机号查询用户是否存在，查询失败"})
		return
	}
	if !exist {
		//用户不存在，需要新创建用户，为用户设置初始密码加密
		Teacher_user.Username = phone
		Teacher_user.Password = passStr
		Teacher_user.Status = 0
		Teacher_user.Level = 9
		Teacher_user.Createtime = time.Now().Unix()
		uid, err := models.FindOrCreateOrUpdateUser(session, Teacher_user)
		if err != nil {
			c.JSON(http.StatusOK, gin.H{"code": 0, "message": "插入用户数据失败"})
			return
		}
		// 更新班级表中班级负责人信息
		class.Leader = uid
		class.ContactInfo = phone
		err = models.UpdateClassInfo(session, class)
		if err != nil {
			c.JSON(http.StatusOK, gin.H{"code": 0, "message": "更新班级表中班级负责人信息出错"})
			return
		}
		/*
		  将新创建的用户id赋值给用户详情信息对象
		*/
		TeacherUserInfo.UserId = uid
		TeacherUserInfo.UserName = classLeaderName
		TeacherUserInfo.Phone = phone
		TeacherUserInfo.CreatedAt = time.Now().Unix()
		TeacherUserInfo.UpdatedAt = time.Now().Unix()
		//用户详情信息表操作
		err = models.FindOrCreateOrUpdateUserInfoByPhone(session, TeacherUserInfo)
		if err != nil {
			fmt.Printf("向用户信息表添加用户数据失败")
			c.JSON(http.StatusOK, gin.H{"code": 0, "message": err.Error()})
			return
		} else {
			/*应用组群操作, 组群名称为: 学校名称_班级号*/
			//根据组群名称查询班级应用组群是否存在，如果存在则入群，不存在则创建并入群，并修改教师权限为管理员权限
			classGroupExist, ClassGroup, err := models.DoesAppGroupExist(session, ClassGroupName)
			fmt.Println("查询班级应用组群是否存在: ", classGroupExist)
			if err != nil {
				fmt.Printf("查询应用组群出错")
				c.JSON(http.StatusOK, gin.H{"code": 0, "message": "查询应用组群出错"})
				return
			}
			//班级组群不存在
			if !classGroupExist {
				//生成班级号
				ClassGroupNo := utils.GenerateInviteCode(TeacherUserInfo.UserId)
				TeacherPermission := 0
				err := CreateNewAppGroup(session, ClassGroupNo, ClassGroupName, TeacherUserInfo.UserId, TeacherPermission)
				if err != nil {
					fmt.Printf("创建应用组群失败")
					c.JSON(http.StatusOK, gin.H{"code": 0, "message": "创建应用组群失败"})
					return
				}
				// 根据用户id和组群号查询用户权限出错
				/*
					_, groupPermission, err := models.GetUserPermission(session, ClassGroupNo, TeacherUserInfo.UserId)
					if err != nil {
						fmt.Printf("根据用户id和组群号查询用户权限出错")
						c.JSON(http.StatusOK, gin.H{"code": 0, "message": "根据用户id和组群号查询用户权限出错"})
						return
					}
					//判断老师权限是否为0，不为0则修改为0
					if groupPermission.Permission != 0 {
						groupPermission.Permission = 0
						_, err := models.UpdateAppGroupPermission(session, groupPermission)
						if err != nil {
							fmt.Printf("更新用户权限出错")
							c.JSON(http.StatusOK, gin.H{"code": 0, "message": "更新用户权限出错"})
							return
						}
					}
				*/

			} else {
				//如果班级的应用组群存在，直接添加教师入群
				//添加之前判断教师是否已经在群里
				_, has_merm, err := models.DoesGroupContainMember(session, ClassGroup.No, ClassGroupName, TeacherUserInfo.UserId)
				if err != nil {
					fmt.Printf("查询教师用户是否已经在群里")
					c.JSON(http.StatusOK, gin.H{"code": 0, "message": "查询教师用户是否已经在群里"})
					return
				}
				if !has_merm {
					// 教师不在班级群
					TeacherPermission := 0
					err = AddStuAndTeacherToAppGroup(session, TeacherUserInfo.UserId, ClassGroup.No, TeacherPermission)
					if err != nil {
						fmt.Printf("添加用户到应用组群失败")
						c.JSON(http.StatusOK, gin.H{"code": 0, "message": "添加用户到应用组群失败"})
						return
					}
					// 根据用户id和组群号查询用户权限
					/*_, groupPermission, err := models.GetUserPermission(session, ClassGroup.No, TeacherUserInfo.UserId)
					if err != nil {
						fmt.Printf("根据用户id和组群号查询用户权限出错")
						c.JSON(http.StatusOK, gin.H{"code": 0, "message": "根据用户id和组群号查询用户权限出错"})
						return
					}
					//判断老师权限是否为0，不为0则修改为0
					if groupPermission.Permission != 0 {
						groupPermission.Permission = 0
						_, err := models.UpdateAppGroupPermission(session, groupPermission)
						if err != nil {
							fmt.Printf("更新用户权限出错")
							c.JSON(http.StatusOK, gin.H{"code": 0, "message": "更新用户权限出错"})
							return
						}
					}
					*/

				}

			}

		}

	} else {

		//教师用户存在，判断组群是否存在
		/*应用组群操作, 组群名称为: 学校名称_班级号*/
		// 更新班级表中班级负责人信息
		class.Leader = existTeacherUser.Id
		class.ContactInfo = phone
		err = models.UpdateClassInfo(session, class)
		if err != nil {
			c.JSON(http.StatusOK, gin.H{"code": 0, "message": "更新班级表中班级负责人信息出错"})
			return
		}
		// 根据班级组群名查询应用组群是否存在
		AppGroup, existAppGroup, err := models.FindAppGroupByGroupName(session, ClassGroupName)
		if err != nil {
			fmt.Printf("根据组群名查询组群是否存在出错")
			c.JSON(http.StatusOK, gin.H{"code": 0, "message": "根据组群名查询组群是否存在出错"})
			return
		}
		//组群存在的话
		if existAppGroup {
			newGroupNo = AppGroup.No
		}
		if !existAppGroup {
			TeacherPermission := 0
			newGroupNo = utils.GenerateInviteCode(existTeacherUser.Id)
			err := CreateNewAppGroup(session, newGroupNo, ClassGroupName, existTeacherUser.Id, TeacherPermission)
			if err != nil {
				fmt.Printf("创建应用组群失败")
				c.JSON(http.StatusOK, gin.H{"code": 0, "message": "创建应用组群失败"})
				return
			}
			// 根据用户id和组群号查询用户权限出错
			/*
				_, groupPermission, err := models.GetUserPermission(session, newGroupNo, existTeacherUser.Id)
				if err != nil {
					fmt.Printf("根据用户id和组群号查询用户权限出错")
					c.JSON(http.StatusOK, gin.H{"code": 0, "message": "根据用户id和组群号查询用户权限出错"})
					return
				}
				//判断老师权限是否为0，不为0则修改为0
				if groupPermission.Permission != 0 {
					groupPermission.Permission = 0
					_, err := models.UpdateAppGroupPermission(session, groupPermission)
					if err != nil {
						fmt.Printf("更新用户权限出错")
						c.JSON(http.StatusOK, gin.H{"code": 0, "message": "更新用户权限出错"})
						return
					}
				}
			*/

		} else {

			//如果班级的应用组群存在，直接添加教师入群
			_, exist_mem, err := models.DoesGroupContainMember(session, AppGroup.No, ClassGroupName, existTeacherUser.Id)
			if err != nil {
				fmt.Printf("查询应用组群中某个成员是否存在出错")
				c.JSON(http.StatusOK, gin.H{"code": 0, "message": "查询应用组群中某个成员是否存在出错"})
				return
			}
			TeacherPermission := 0
			if !exist_mem {
				err = AddStuAndTeacherToAppGroup(session, existTeacherUser.Id, AppGroup.No, TeacherPermission)
				if err != nil {
					fmt.Printf("添加用户到应用组群失败")
					c.JSON(http.StatusOK, gin.H{"code": 0, "message": "添加用户到应用组群失败"})
					return
				}
				// 根据用户id和组群号查询用户权限
				/*_, groupPermission, err := models.GetUserPermission(session, AppGroup.No, existTeacherUser.Id)
				if err != nil {
					fmt.Printf("根据用户id和组群号查询用户权限出错")
					c.JSON(http.StatusOK, gin.H{"code": 0, "message": "根据用户id和组群号查询用户权限出错"})
					return
				}
				//判断老师权限是否为0，不为0则修改为0
				if groupPermission.Permission != 0 {
					groupPermission.Permission = 0
					_, err := models.UpdateAppGroupPermission(session, groupPermission)
					if err != nil {
						fmt.Printf("更新用户权限出错")
						c.JSON(http.StatusOK, gin.H{"code": 0, "message": "更新用户权限出错"})
						return
					}
				}*/

			}

		}

	}
	// 提交事务
	err = session.Commit()
	if err != nil {
		c.JSON(http.StatusOK, gin.H{"code": 0, "message": "提交事务失败!"})
		fmt.Println("提交事务失败")
		return
	}
	response := gin.H{
		"code":    1,
		"message": "班级负责人信息录入成功,创建组群成功",
	}

	// 序列化响应数据为 JSON 字符串
	jsonData, err := json.Marshal(response)
	if err != nil {
		// 处理序列化错误
		fmt.Println("序列化 JSON 数据出错:", err)
		return
	}
	fmt.Println("班级负责人信息录入成功,创建组群成功, Response:", string(jsonData))
	fmt.Println(config.ColorGreen, "班级负责人信息录入成功,创建组群成功", config.ColorReset)
	c.JSON(http.StatusOK, response)

}

/*
  输入学校（单位）编码，显示所属班级（部门）
*/
func QueryClassesBySchool(c *gin.Context) {
	//学校编号
	schoolNo := c.PostForm("schoolNo")
	classes, err := models.GetAllClassesBySchoolNo(schoolNo)
	if err != nil {
		c.JSON(http.StatusOK, gin.H{"code": 0, "message": " 根据学校编号查询所有班级信息出错"})
		fmt.Println("根据学校编号查询所有班级信息出错")
		return
	}
	response := gin.H{
		"code":    1,
		"message": "根据学校编号查询班级信息,创建组群成功",
		"classes": classes,
	}
	// 序列化响应数据为 JSON 字符串
	jsonData, err := json.Marshal(response)
	if err != nil {
		// 处理序列化错误
		fmt.Println("序列化 JSON 数据出错:", err)
		return
	}
	fmt.Println("根据学校编号查询班级信息,创建组群成功, Response:", string(jsonData))
	c.JSON(http.StatusOK, response)
}

//创建新的应用组群
func CreateNewAppGroup(session *xorm.Session, newGroupNo, groupName string, userid int64, permission int) error {
	/*应用组群操作*/
	// 生成组群号
	//newGroupNo = utils.GenerateInviteCode(Patriarch_user.Id)

	GroupMemIds := []int64{userid} // 创建一个包含id的数组
	appId := 6
	newGroup := &models.AppGroup{
		No:         newGroupNo,
		AppId:      int64(appId),
		CreatorId:  userid,
		GroupName:  groupName,
		GroupMem:   GroupMemIds,
		Visibility: "private",
	}
	// 在数据库中创建应用
	// 调用创建函数
	err := models.CreateAppGroup_Permission(session, newGroup, permission)
	if err != nil {
		fmt.Printf("Error creating app group: %s\n", err)

		return err
	}
	return nil
}

//添加学生到家长应用组群
func AddStuAndTeacherToAppGroup(session *xorm.Session, userid int64, newGroupNo string, permission int) error {

	bol, _, err := models.GetUserExistByID_Tx(session, userid)
	if err != nil {
		return err
	}
	if bol == false {
		return err
	}
	err = models.AppGroupInviteUser_Permission(session, newGroupNo, userid, permission)
	if err != nil {
		return err

	}

	return nil

}