MHTService.go

package service

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

//用户应用的状态数据
type MHTStatusData struct {
	AnswerArr      []string `json:"AnswerArr"`
	EvaluateResult []string `json:"EvaluateResult"`
}

// 发送 POST 请求的函数
func QuickMHTMentalClinic(c *gin.Context) {
	/*
	   判断用户是否登录
	*/
	_, isLogin := IsUserLoggedIn(c)
	if !isLogin {
		log.Println("用户未登录")
		c.JSON(http.StatusOK, gin.H{"code": 0, "message": "用户未登录"})
		return
	}

	appId := c.PostForm("app_id")
	appName := c.PostForm("app_name")
	app_Id, err := strconv.ParseInt(appId, 10, 64)
	if err != nil {
		c.JSON(http.StatusBadRequest, gin.H{"error": "Invalid app_id format"})
		return
	}
	userName := c.PostForm("userName")
	sex := c.PostForm("sex")
	Birthday := c.PostForm("birthday")
	Height := c.PostForm("height")
	Weight := c.PostForm("weight")
	//手机号和学号+学校名称二选一
	phone := c.PostForm("phone")
	//学号和学校名称是可选性
	SerialNo := c.PostForm("SerialNo")
	unit := c.PostForm("SchoolName")
	// 定义MHT量表单次录入用户请求的uuid
	var MHT_UUID = utils.GenerateUUID()
	IsUpdateSelfData := c.PostForm("IsUpdate")
	//缓存添加应用名称和应用id
	AppCache[MHT_UUID] = &CacheApp{
		AppName:          appName,
		AppID:            app_Id,
		UUID_Val:         MHT_UUID,
		IsUpdateSelfData: IsUpdateSelfData,
	}

	var IsEvaluated bool
	var EvaluatedResult string

	//开启事务
	session := database.Engine.NewSession()
	defer session.Close() //延迟关闭session
	err = session.Begin()
	if err != nil {
		c.JSON(http.StatusOK, gin.H{"code": 0, "message": "开启事务失败!"})
		fmt.Println("开启事务失败")
		return
	}

	/* 手机号不为空的情况 */
	if phone != "" {
		//根据手机号查询用户是否存在
		existUser, exist, err := models.GetUserByPhone(session, phone)
		if err != nil {
			fmt.Println("根据手机号查询用户是否存在，查询失败")
			c.JSON(http.StatusInternalServerError, gin.H{"code": 0, "message": "根据手机号查询用户是否存在，查询失败"})
			return
		}
		//构建用户信息表对象
		user := &models.User{
			Phone:      phone,
			Createtime: time.Now().Unix(),
		}
		fmt.Println(config.ColorYellow, "username: ", userName, "phone: ", phone, config.ColorReset)
		//构建用户详情信息结构体对象
		userinfo := &models.UserInfo{
			UserSex:      sex,
			Phone:        phone,
			UserHeight:   Height,
			UserWeight:   Weight,
			UserBirthday: Birthday,
		}
		//若用户存在是否更新用户注册信息和用户详细信息
		IsUpdateSelfData := AppCache[MHT_UUID].IsUpdateSelfData

		if !exist {
			//用户不存在，需要新创建用户，为用户设置初始密码加密
			//用户不存在，给用户名称赋值
			user.Username = phone
			initPassWord := "88888888"
			salt := config.Conf.Md5Salt
			passStr, err := utils.MD5BySalf(initPassWord, salt)
			if err != nil {
				log.Println("密码加盐失败！")
				c.JSON(http.StatusInternalServerError, gin.H{"code": 0, "message": "密码加盐失败"})
				return
			}
			user.Password = passStr
			user.Status = 0
			user.Level = 9
			uid, err := models.FindOrCreateOrUpdateUser(session, user)
			if err != nil {
				c.JSON(http.StatusInternalServerError, gin.H{"code": 0, "message": "插入用户数据失败"})
				return
			}
			/*
			  将新创建的用户id赋值给用户详情信息对象
			*/
			userinfo.UserId = uid
			userinfo.UserName = userName
			//把用户id存入缓存
			AppCache[MHT_UUID].UserId = uid

			fmt.Println(config.ColorCyan, "MHT_UUID存入缓存UserId:", uid, config.ColorReset)

			//用户详情信息表操作
			err = models.FindOrCreateOrUpdateUserInfoByPhone(session, userinfo)
			if err != nil {
				fmt.Printf("向用户信息表添加用户数据失败")
				c.JSON(http.StatusInternalServerError, gin.H{"code": 0, "message": err.Error()})
				return
			} else {

				/*
				   根据用户id和应用id查询数据库中是否存在用户MHT问卷记录
				*/
				userAppData, err := models.GetUserApplicationData_Tx(session, app_Id, uid)
				if err != nil {
					c.JSON(http.StatusOK, gin.H{"code": 0, "message": "根据用户id和应用id查询用户MHT测量数据失败!"})
					fmt.Println("根据用户id和应用id查询用户MHT测量数据失败")
					return
				}
				if userAppData != nil {
					IsEvaluated = true
					EvaluatedResult = userAppData.StatusData
				} else {
					IsEvaluated = false
					EvaluatedResult = ""
				}
				//将上次的测评结果存入缓存
				AppCache[MHT_UUID].LastEvaluatedResult = EvaluatedResult

				/* 提交事务操作 */
				err = session.Commit()
				if err != nil {
					c.JSON(http.StatusOK, gin.H{"code": 0, "message": "提交事务失败!"})
					fmt.Println("提交事务失败")
					return
				}
				//响应
				/*===========================================================================*/
				response := gin.H{
					"code":        1,
					"message":     "用户表和用户详情信息表数据录入成功",
					"UserId":      uid,
					"MHT_UUID":    MHT_UUID,
					"appId":       app_Id,
					"IsEvaluated": IsEvaluated,
				}
				c.JSON(http.StatusOK, response)

				// 序列化响应数据为 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)
				/*===========================================================================*/

			}

		} else {
			/*
			   根据用户id和应用id查询数据库中是否存在用户MHT问卷记录
			*/
			userAppData, err := models.GetUserApplicationData_Tx(session, app_Id, existUser.Id)
			if err != nil {
				c.JSON(http.StatusOK, gin.H{"code": 0, "message": "根据用户id和应用id查询用户MHT测量数据失败!"})
				fmt.Println("根据用户id和应用id查询用户MHT测量数据失败")
				return
			}
			if userAppData != nil {
				IsEvaluated = true
				EvaluatedResult = userAppData.StatusData
			} else {
				IsEvaluated = false
				EvaluatedResult = ""
			}

			/*是否更新用户数据*/
			if IsUpdateSelfData == "true" {
				//用户已经存在
				user.Id = existUser.Id
				uid, err := models.UpdateUser_Tx(session, user)
				if err != nil {
					fmt.Printf("更新用户数据失败")
					c.JSON(http.StatusInternalServerError, gin.H{"code": 0, "message": err.Error()})
					return
				}
				//将用户id保存到缓存中
				AppCache[MHT_UUID].UserId = uid
				userinfo.UserId = uid
				userinfo.UserName = userName
				//将上次的测评结果存入缓存
				AppCache[MHT_UUID].LastEvaluatedResult = EvaluatedResult
				err = models.UpdateUserInfo(session, userinfo)
				if err != nil {
					fmt.Printf("更新用户详情信息失败!")
					c.JSON(http.StatusInternalServerError, gin.H{"code": 0, "message": err.Error()})
					return
				} else {

					/* 提交事务操作 */

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

					response := gin.H{
						"code":        1,
						"message":     "用户表和用户详情信息表数据录入成功",
						"UserId":      uid,
						"MHT_UUID":    MHT_UUID,
						"appId":       app_Id,
						"IsEvaluated": IsEvaluated,
					}
					c.JSON(http.StatusOK, response)
					// 序列化响应数据为 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)

				}

			} else if IsUpdateSelfData == "false" {
				//用户存在，不更新用户注册信息和用户详情信息
				user.Id = existUser.Id
				//将用户id保存到缓存中
				AppCache[MHT_UUID].UserId = existUser.Id

				/*
				 不更新用户详情信息
				*/
				//把用户id存入缓存
				AppCache[MHT_UUID].UserId = existUser.Id
				//将上次的测评结果存入缓存
				AppCache[MHT_UUID].LastEvaluatedResult = EvaluatedResult
				/* 提交事务操作 */
				err = session.Commit()
				if err != nil {
					c.JSON(http.StatusOK, gin.H{"code": 0, "message": "提交事务失败!"})
					fmt.Println("提交事务失败")
					return
				}

				response := gin.H{
					"code":        1,
					"message":     "用户详情信息表存在该用户,无需更新",
					"UserId":      existUser.Id,
					"MHT_UUID":    MHT_UUID,
					"appId":       app_Id,
					"IsEvaluated": IsEvaluated,
				}
				c.JSON(http.StatusOK, response)
				// 序列化响应数据为 JSON 字符串
				jsonData, err := json.Marshal(response)
				if err != nil {
					// 处理序列化错误
					fmt.Println("序列化 JSON 数据出错:", err)
					return
				}
				fmt.Println(config.ColorGreen, "用户详情信息表存在该用户,不更新用户注册信息和用户详情信息", config.ColorReset)
				fmt.Println("用户详情信息表存在该用户,不更新用户注册信息和用户详情信息, Response:", string(jsonData))

			} else {
				/*
				  如果前端不传flag值，默认修改用户注册信息和用户详情信息
				*/
				//用户已经存在
				user.Id = existUser.Id
				uid, err := models.UpdateUser_Tx(session, user)
				if err != nil {
					fmt.Printf("更新用户数据失败")
					c.JSON(http.StatusInternalServerError, gin.H{"code": 0, "message": err.Error()})
					return
				}
				//将用户id保存到缓存中
				AppCache[MHT_UUID].UserId = uid
				//将上次的测评结果存入缓存
				AppCache[MHT_UUID].LastEvaluatedResult = EvaluatedResult
				userinfo.UserId = uid
				userinfo.UserName = userName
				err = models.UpdateUserInfo(session, userinfo)
				if err != nil {
					fmt.Printf("更新用户详情信息失败!")
					c.JSON(http.StatusInternalServerError, gin.H{"code": 0, "message": err.Error()})
					return
				} else {
					/* 提交事务操作 */

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

					c.JSON(http.StatusOK, gin.H{
						"code":        1,
						"message":     "用户表和用户详情信息表数据录入成功",
						"UserId":      uid,
						"MHT_UUID":    MHT_UUID,
						"appId":       app_Id,
						"IsEvaluated": IsEvaluated,
					})
					fmt.Println(config.ColorGreen, "用户表和用户详情信息表数据录入成功", config.ColorReset)

				}

			}

		}

	}

	//学号和学校单位不为空的情况
	if SerialNo != "" && unit != "" {
		//若用户存在是否更新用户注册信息和用户详细信息
		IsUpdateSelfData := AppCache[MHT_UUID].IsUpdateSelfData
		//构建用户详情信息结构体对象
		userinfo := &models.UserInfo{
			UserSex:      sex,
			Unit:         unit,
			UserHeight:   Height,
			UserWeight:   Weight,
			UserBirthday: Birthday,
		}
		userinfo.StudentId = SerialNo
		//查询用户详情信息
		user_info, exist, err := models.FindUserByStudentIdAndUnit(session, userinfo)
		if err != nil {
			c.JSON(http.StatusInternalServerError, gin.H{"code": 0, "message": "根据学号和单位名称查询用户信息失败!"})
			return
		}

		//如果详情用户信息表不存在该用户
		if !exist {
			userinfo.UserName = userName
			//用户初始密码加密
			initPassWord := "88888888"
			salt := config.Conf.Md5Salt
			passStr, err := utils.MD5BySalf(initPassWord, salt)
			if err != nil {
				log.Println("密码加盐失败！")
				c.JSON(http.StatusInternalServerError, gin.H{"code": 0, "message": "密码加盐失败"})
				return
			}
			//这里没有手机号，因为手机号在表中为唯一索引，因此用手机号_学校名称的字符串存入
			CreatePhone := SerialNo + "_" + unit
			//定义用户注册信息
			user := &models.User{
				Username:   SerialNo,
				Createtime: time.Now().Unix(),
				Password:   passStr,
				Phone:      CreatePhone,
				Level:      9,
				Status:     0,
			}
			_, id, err := models.CreateAndUpdateUser(session, user)
			if err != nil {
				c.JSON(http.StatusInternalServerError, gin.H{"code": 0, "message": "插入或更新用户数据失败!"})
				return
			}
			//用户详情信息表中不存在该用户的详情信息
			userinfo.UserId = id
			//把用户id存入缓存
			AppCache[MHT_UUID].UserId = id
			fmt.Println(config.ColorCyan, "MHT_UUID存入缓存UserId:", id, config.ColorReset)
			//创建用户详情信息
			err = models.CreateUserInfo(session, userinfo)
			if err != nil {
				c.JSON(http.StatusInternalServerError, gin.H{"code": 0, "message": "插入用户详情信息失败!"})
				return
			} else {
				/*
				   根据用户id和应用id查询数据库中是否存在用户MHT问卷记录
				*/
				userAppData, err := models.GetUserApplicationData_Tx(session, app_Id, userinfo.UserId)
				if err != nil {
					c.JSON(http.StatusOK, gin.H{"code": 0, "message": "根据用户id和应用id查询用户MHT测量数据失败!"})
					fmt.Println("根据用户id和应用id查询用户MHT测量数据失败")
					return
				}
				if userAppData != nil {
					IsEvaluated = true
					EvaluatedResult = userAppData.StatusData
				} else {
					IsEvaluated = false
					EvaluatedResult = ""
				}

				//将上次的测评结果存入缓存
				AppCache[MHT_UUID].LastEvaluatedResult = EvaluatedResult
				/* 提交事务操作 */
				err = session.Commit()
				if err != nil {
					c.JSON(http.StatusOK, gin.H{"code": 0, "message": "提交事务失败!"})
					fmt.Println("提交事务失败")
					return
				}

				//响应给前端
				response := gin.H{
					"code":        1,
					"message":     "用户表和用户详情信息表数据录入成功",
					"UserId":      id,
					"MHT_UUID":    MHT_UUID,
					"appId":       app_Id,
					"IsEvaluated": IsEvaluated,
				}
				c.JSON(http.StatusOK, response)

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

			}

		} else {
			/*
			   根据用户id和应用id查询数据库中是否存在用户MHT问卷记录
			*/
			userAppData, err := models.GetUserApplicationData_Tx(session, app_Id, user_info.UserId)
			if err != nil {
				c.JSON(http.StatusOK, gin.H{"code": 0, "message": "根据用户id和应用id查询用户MHT测量数据失败!"})
				fmt.Println("根据用户id和应用id查询用户MHT测量数据失败")
				return
			}

			if userAppData != nil && len(userAppData.StatusData) > 100 {
				IsEvaluated = true
				EvaluatedResult = userAppData.StatusData
			} else {
				IsEvaluated = false
				EvaluatedResult = ""
			}

			/*
			  如果用户详情信息表存在该用户，将用户id保存到缓存中
			*/
			//是否更新已存在的用户信息
			if IsUpdateSelfData == "true" {
				//把用户id存入缓存
				AppCache[MHT_UUID].UserId = user_info.UserId
				//存在则更新
				userinfo.UserName = userName
				//更新用户详情信息
				err = models.UpdateUserInfo(session, user_info)
				if err != nil {
					fmt.Printf("更新用户详情信息失败!")
					c.JSON(http.StatusInternalServerError, gin.H{"code": 0, "message": err.Error()})
					return
				} else {
					/* 提交事务操作 */

					err = session.Commit()
					if err != nil {
						c.JSON(http.StatusOK, gin.H{"code": 0, "message": "提交事务失败!"})
						fmt.Println("提交事务失败")
						return
					}
					//将上次的测评结果存入缓存
					AppCache[MHT_UUID].LastEvaluatedResult = EvaluatedResult
					fmt.Println(config.ColorCyan, "MHT_UUID存入缓存UserId:", user_info.UserId, config.ColorReset)
					response := gin.H{
						"code":        1,
						"message":     "用户表和用户详情信息表数据录入成功",
						"UserId":      user_info.UserId,
						"MHT_UUID":    MHT_UUID,
						"appId":       app_Id,
						"IsEvaluated": IsEvaluated,
					}
					c.JSON(http.StatusOK, response)

					// 序列化响应数据为 JSON 字符串
					jsonData, err := json.Marshal(response)
					if err != nil {
						// 处理序列化错误
						fmt.Println("序列化 JSON 数据出错:", err)
						return
					}
					fmt.Println(config.ColorGreen, "用户表和用户详情信息表数据录入成功", config.ColorReset)
					fmt.Println("用户详情信息表存在该用户,更新用户注册信息和用户详情信息, Response:", string(jsonData))

				}

			} else if IsUpdateSelfData == "false" {
				/*
				 不更新用户详情信息
				*/
				//把用户id存入缓存
				AppCache[MHT_UUID].UserId = user_info.UserId
				//将上次的测评结果存入缓存
				AppCache[MHT_UUID].LastEvaluatedResult = EvaluatedResult
				/* 提交事务操作 */

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

				response := gin.H{
					"code":        1,
					"message":     "用户详情信息表存在该用户,无需更新",
					"UserId":      user_info.UserId,
					"MHT_UUID":    MHT_UUID,
					"appId":       app_Id,
					"IsEvaluated": IsEvaluated,
				}
				c.JSON(http.StatusOK, response)

				// 序列化响应数据为 JSON 字符串
				jsonData, err := json.Marshal(response)
				if err != nil {
					// 处理序列化错误
					fmt.Println("序列化 JSON 数据出错:", err)
					return
				}
				fmt.Println(config.ColorGreen, "用户详情信息表存在该用户,不更新用户注册信息和用户详情信息", config.ColorReset)
				fmt.Println("用户详情信息表存在该用户,不更新用户注册信息和用户详情信息, Response:", string(jsonData))

			} else {
				/*
				  如果前端flag没有传值则默认更新userinfo信息
				*/
				//把用户id存入缓存
				AppCache[MHT_UUID].UserId = user_info.UserId
				//将上次的测评结果存入缓存
				AppCache[MHT_UUID].LastEvaluatedResult = EvaluatedResult
				userinfo.UserName = userName
				//存在则更新
				err = models.UpdateUserInfo(session, user_info)
				if err != nil {
					fmt.Printf("更新用户详情信息失败!")
					c.JSON(http.StatusInternalServerError, gin.H{"code": 0, "message": err.Error()})
					return
				} else {
					fmt.Println(config.ColorCyan, "MHT_UUID存入缓存UserId:", user_info.UserId, config.ColorReset)

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

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

				}
			}

		}

	}

}

//心理诊疗调查问卷结果接口
func EvaluateMHTMentalClinic(ctx *gin.Context) {

	/*
		从数据库根据应用名称和应用id查询应用配置信息
	*/
	MHTUUID := ctx.PostForm("MHT_UUID")
	if AppCache[MHTUUID] == nil {
		ctx.JSON(http.StatusOK, gin.H{"code": 0, "message": "MHT量表用户唯一识别码uuid不相等"})
		return
	}
	app_Id := AppCache[MHTUUID].AppID
	appName := AppCache[MHTUUID].AppName
	configData, err := models.GetConfigDataByAppInfo(app_Id, appName)
	if err != nil {
		fmt.Printf("根据应用id和应用名称查询应用的配置信息失败")
		ctx.JSON(http.StatusOK, gin.H{"code": 0, "message": "根据应用id和应用名称查询应用的配置信息失败"})
		return
	}
	fmt.Println("configData: ", configData)

	//从缓存中获取用户id，然后查询用户详情信息
	uid := AppCache[MHTUUID].UserId
	UserInfo, err := models.GetUserInfo(uid)
	if err != nil {
		ctx.JSON(http.StatusOK, gin.H{"code": 0, "message": "根据用户id查询应用失败"})
		return
	}
	fmt.Println("UserInfo: ", UserInfo)
	//从configData中获取用户信息模板
	userInfoTemplate, ok := configData["userInfoTemplate"]
	if !ok {
		fmt.Println("Key 'userInfoTemplate' not found in the map")
		ctx.JSON(http.StatusOK, gin.H{"code": 0, "message": "Key 'userInfoTemplate' not found in the map"})
		return
	}
	//访问map中的DpId键的值
	DpId, ok := configData["DpId"]
	if !ok {
		fmt.Println("Key 为DpId的键在map中未发现")
		ctx.JSON(http.StatusOK, gin.H{"code": 0, "message": "Key 为DpId的键在map中未发现"})
		return
	}
	DpIdStr, ok := DpId.(string)
	if !ok {
		fmt.Println("Dp_id is not a string")
		ctx.JSON(http.StatusOK, gin.H{"code": 0, "message": "Dp_id不是一个字符串"})
		return
	}
	dp_id, err := strconv.ParseInt(DpIdStr, 10, 64)
	if err != nil {
		fmt.Println("从configData中获取的数字人id类型转换失败")
		ctx.JSON(http.StatusOK, gin.H{"code": 0, "message": "数字人id类型转换失败"})
		return
	}
	//将数字人id存入到缓存中
	AppCache[MHTUUID].DpId = dp_id
	fmt.Println(config.ColorPurple, "存入缓存的DpId: ", dp_id, config.ColorReset)

	// 断言 userInfoTemplate 为字符串类型
	userInfoTemplateStr, ok := userInfoTemplate.(string)
	if !ok {
		fmt.Println("userInfoTemplate is not a string")
		return
	}
	// 打印 userInfoTemplate 的值
	fmt.Println("userInfoTemplate: ", userInfoTemplateStr)

	// 从前端获取是否跳过MHT检测
	IsPassTest := ctx.PostForm("IsPassTest")

	//重新检测
	if IsPassTest == "" {
		AppCache[MHTUUID].IsPassMHT = "no"
		//从前端获取测量表的评估数据
		LearningAnxiety := ctx.PostForm("LearningAnxiety")
		AnxietyPeople := ctx.PostForm("AnxietyPeople")
		LonelinessTendency := ctx.PostForm("LonelinessTendency")
		SelfBlameTendency := ctx.PostForm("SelfBlameTendency")
		AllergicTendency := ctx.PostForm("AllergicTendency")
		PhysicalSign := ctx.PostForm("PhysicalSign")
		PhobicTendency := ctx.PostForm("PhobicTendency")
		ImpulsiveTendency := ctx.PostForm("ImpulsiveTendency")
		EvaluateResult := []string{}
		EvaluateResult = append(EvaluateResult, LearningAnxiety, AnxietyPeople, LonelinessTendency,
			SelfBlameTendency, AllergicTendency, PhysicalSign, PhobicTendency, ImpulsiveTendency)
		// 将用户信息和测量数据存入一个字符串数组中
		values := []string{
			UserInfo.UserName,
			UserInfo.UserSex,
			UserInfo.UserHeight,
			UserInfo.UserWeight,
			UserInfo.UserBirthday,
			LearningAnxiety,
			AnxietyPeople,
			LonelinessTendency,
			SelfBlameTendency,
			AllergicTendency,
			PhysicalSign,
			PhobicTendency,
			ImpulsiveTendency,
		}
		AnswerValues := ctx.PostForm("AnswerArr")
		AnswerArr := []string{}
		AnswerArr = append(AnswerArr, AnswerValues)
		/*
		   把填报测量的数据保存至数据库的用户应用数据中
		*/
		MHT_StatusData := MHTStatusData{
			AnswerArr:      AnswerArr,
			EvaluateResult: EvaluateResult,
		}
		// 将结构体转换为 JSON 字符串
		jsonData, err := json.Marshal(MHT_StatusData)
		if err != nil {
			fmt.Println("转换为 JSON 失败:", err)
			ctx.JSON(http.StatusOK, gin.H{"code": 0, "message": "MHT_StatusData转换json失败"})
			return
		}

		// 打印 JSON 字符串
		fmt.Println(string(jsonData))
		jsonDataStr := string(jsonData)
		err = models.UpdateOrAddUserApplicationDataByUserIdAndAppId(uid, app_Id, jsonDataStr)
		if err != nil {
			fmt.Println("将用户MHT状态数据存入数据库失败", err)
			ctx.JSON(http.StatusOK, gin.H{"code": 0, "message": "将用户MHT状态数据存入数据库失败"})
			return
		}

		/*
		   填充用户信息模板字符串中的占位符
		*/
		userInfoTemplateValue, err := FillUserInfoTemplate(userInfoTemplateStr, values)
		if err != nil {
			fmt.Println(" 填充用户信息模板字符串失败!")
			return
		} else {
			fmt.Println("userInfoTemplateValue", userInfoTemplateValue)
			//将用户信息模板字符串保存至缓存中
			AppCache[MHTUUID].UserInfoTemplate = userInfoTemplateValue
			/*
			  模拟用户登录
			*/
			//用户已经存在，模拟用户登录
			session := sessions.Default(ctx)
			//在这里修改,3表示有效时间为1800秒
			session.Options(sessions.Options{MaxAge: 1800})
			// 设置用户ID到会话中
			session.Set("UserID", utils.Strval(uid))
			if err := session.Save(); err != nil {
				// 如果保存Session失败，处理错误
				ctx.JSON(http.StatusInternalServerError, gin.H{"code": 0, "message": "模拟登录失败"})
				return
			}

			var userId = session.Get("UserID").(string)
			fmt.Println(config.ColorPurple, "从session中获取userId: ", userId, config.ColorReset)
			config.WorldLoginCacheCode.Set(userId, true, time.Hour)

			ctx.JSON(http.StatusOK, gin.H{
				"code":    1,
				"message": "MHT测量数据保存成功!",
				"UserId":  uid,
				"MHTUUID": MHTUUID,
				"DpId":    dp_id,
			})

		}

	} else {
		/*
			用户跳过做MHT量表，直接使用旧数据，自我诊疗
		*/
		// 变量用于存储解析后的数据
		var MHTResult MHTStatusData
		AppCache[MHTUUID].IsPassMHT = "yes"
		// 解析JSON字符串到结构体
		//判断从缓存里取出来的LastEvaluatedResult上次的MHT量表测量结果是否为空字符串
		if AppCache[MHTUUID].LastEvaluatedResult != "" {
			err := json.Unmarshal([]byte(AppCache[MHTUUID].LastEvaluatedResult), &MHTResult)
			if err != nil {
				log.Printf("JSON Unmarshaling failed: %s", err)
			}
		} else {
			ctx.JSON(http.StatusInternalServerError, gin.H{
				"code":    0,
				"UserId":  uid,
				"message": "该用户未进行过MHT心理测评",
			})
			return
		}
		// 将用户信息和测量数据存入一个字符串数组中
		MHT_values := []string{
			UserInfo.UserName,
			UserInfo.UserSex,
			UserInfo.UserHeight,
			UserInfo.UserWeight,
			UserInfo.UserBirthday,
		}

		MHT_values = append(MHT_values, MHTResult.EvaluateResult...)
		/*
		   填充用户信息模板字符串中的占位符
		*/
		userInfoTemplateValue, err := FillUserInfoTemplate(userInfoTemplateStr, MHT_values)
		if err != nil {
			fmt.Println(" 填充用户信息模板字符串失败!")
			return
		} else {
			fmt.Println("userInfoTemplateValue", userInfoTemplateValue)
			//将用户信息模板字符串保存至缓存中
			AppCache[MHTUUID].UserInfoTemplate = userInfoTemplateValue
			/*
			  模拟用户登录
			*/
			//用户已经存在，模拟用户登录
			session := sessions.Default(ctx)
			//在这里修改,3表示有效时间为1800秒
			session.Options(sessions.Options{MaxAge: 1800})
			// 设置用户ID到会话中
			session.Set("UserID", utils.Strval(uid))
			if err := session.Save(); err != nil {
				// 如果保存Session失败，处理错误
				ctx.JSON(http.StatusInternalServerError, gin.H{"code": 0, "message": "模拟登录失败"})
				return
			}

			var userId = session.Get("UserID").(string)
			fmt.Println(config.ColorPurple, "从session中获取userId: ", userId, config.ColorReset)
			config.WorldLoginCacheCode.Set(userId, true, time.Hour)

			ctx.JSON(http.StatusOK, gin.H{
				"code":    1,
				"message": "MHT测量成功!",
				"UserId":  uid,
				"MHTUUID": MHTUUID,
				"DpId":    dp_id,
			})

		}
	}

}