SCADATrainSys/Tech/controllers/用户.go

// controllers/用户.go
package controllers

import (
	"Tech/common"
	"crypto/rand"
	"encoding/base64"
	"encoding/json"
	"sync"

	"github.com/beego/beego/v2/core/logs"
	beego "github.com/beego/beego/v2/server/web"
)

type UserController struct {
	beego.Controller
}

// 用户信息缓存，key为userName，value为用户信息
var userInfoCache = make(map[string]common.PersonalInfo)
var cacheMutex sync.RWMutex // 保护缓存的读写锁

var simpleTokenStore = make(map[string]string) // token -> userId

// GetUserInfoFromCache 通过用户名从缓存中获取用户信息
func GetUserInfoFromCache(userName string) (common.PersonalInfo, bool) {
	// 先尝试读取缓存
	cacheMutex.RLock()
	userInfo, exists := userInfoCache[userName]
	defer cacheMutex.RUnlock()

	if exists {
		return userInfo, true
	}

	return common.PersonalInfo{}, false
}

// GetUserInfoFromCache 通过人员GUID查询
func GetUserInfoFromCache_RYEMPID(RYEMPID string) (common.PersonalInfo, bool) {
	// 先尝试读取缓存
	cacheMutex.RLock()
	defer cacheMutex.RUnlock()

	// 遍历缓存查找匹配的RYEMPID
	for _, userInfo := range userInfoCache {
		if userInfo.RYEMPID == RYEMPID {
			return userInfo, true
		}
	}

	return common.PersonalInfo{}, false
}

// initUserInfoCache 初始化用户信息缓存
func InitUserInfoCache() {
	logs.Info("开始初始化用户信息缓存...")

	personalInfos, err := common.GetAllPersionInfo()
	if err != nil {
		logs.Error("获取所有用户信息失败: ", err)
		return
	}

	// 加锁更新缓存
	cacheMutex.Lock()
	defer cacheMutex.Unlock()

	for _, info := range personalInfos {
		// 使用RYEMPID作为用户名缓存用户信息
		userInfoCache[info.RYID] = info
	}

	logs.Info("用户信息缓存初始化完成，共缓存%d个用户", len(personalInfos))
}
func generateShortToken(userId string) string {
	b := make([]byte, 6)
	rand.Read(b)
	token := base64.RawURLEncoding.EncodeToString(b)
	simpleTokenStore[token] = userId
	return token
}

func validateShortToken(token string) (string, bool) {
	userId, ok := simpleTokenStore[token]
	return userId, ok
}

func deleteShortToken(token string) {
	delete(simpleTokenStore, token)
}

// UserLogin 用户登录认证并生成Token
func (c *UserController) UserLogin() {
	var req struct {
		UserName string `json:"userName"`
		Password string `json:"password"`
	}
	requestBody := c.Ctx.Input.RequestBody
	println("Request Body:", string(requestBody))
	if err := json.Unmarshal(c.Ctx.Input.RequestBody, &req); err != nil {
		c.Ctx.Output.SetStatus(400)
		c.Data["json"] = map[string]interface{}{
			"code": 400,
			"msg":  "请求参数格式错误: " + err.Error(),
		}
		c.ServeJSON()
		return
	}

	if req.UserName == "" || req.Password == "" {
		c.Ctx.Output.SetStatus(400)
		c.Data["json"] = map[string]interface{}{
			"code": 400,
			"msg":  "用户名和密码不能为空",
		}
		c.ServeJSON()
		return
	}

	// 使用信息化系统进行身份验证
	loginResp, err := common.LoginToInformationSystem(req.UserName, req.Password)
	if err != nil {
		c.Ctx.Output.SetStatus(500)
		c.Data["json"] = map[string]interface{}{
			"code": 500,
			"msg":  "信息化系统验证失败: " + err.Error(),
		}
		c.ServeJSON()
		return
	}

	// 检查登录结果
	if loginResp.ResultCode != "0" {
		c.Ctx.Output.SetStatus(401)
		c.Data["json"] = map[string]interface{}{
			"code": 401,
			"msg":  loginResp.ResultDesc,
		}
		c.ServeJSON()
		return
	}

	// 登录成功，获取用户详细信息
	personalInfoResp, err := common.GetPersonalInfoFromInformationSystem(loginResp.RYEMPID)
	if err != nil {
		c.Ctx.Output.SetStatus(500)
		c.Data["json"] = map[string]interface{}{
			"code": 500,
			"msg":  "获取用户信息失败: " + err.Error(),
		}
		c.ServeJSON()
		return
	}

	// 检查获取用户信息的结果
	if personalInfoResp.ResultCode != "0" {
		c.Ctx.Output.SetStatus(500)
		c.Data["json"] = map[string]interface{}{
			"code": 500,
			"msg":  "获取用户信息失败: " + personalInfoResp.ResultDesc,
		}
		c.ServeJSON()
		return
	}

	// 获取第一个用户的信息（通常只有一个）
	var personalInfo common.PersonalInfo
	if len(personalInfoResp.PersonalInfos) > 0 {
		personalInfo = personalInfoResp.PersonalInfos[0]
	}

	// 将用户信息存入缓存
	cacheMutex.Lock()
	userInfoCache[req.UserName] = personalInfo
	cacheMutex.Unlock()

	tokenString := generateShortToken(req.UserName)

	// 构建返回给前端的用户信息
	userInfo := map[string]interface{}{
		"token":          tokenString,
		"teacherId":      personalInfo.TeacherId,
		"orgid":          personalInfo.Orgid,
		"RYID":           personalInfo.RYID,
		"RYEMPID":        personalInfo.RYEMPID,
		"KQID":           personalInfo.KQID,
		"XM":             personalInfo.XM,
		"XB":             personalInfo.XB,
		"CSRQ":           personalInfo.CSRQ,
		"MM":             personalInfo.MM,
		"SSDW":           personalInfo.SSDW,
		"JG":             personalInfo.JG,
		"Fingerprints":   personalInfo.Fingerprints,
		"SF":             personalInfo.SF,
		"SFZH":           personalInfo.SFZH,
		"SJH":            personalInfo.SJH,
		"FaceData":       personalInfo.FaceData,
		"FaceDataLength": personalInfo.FaceDataLength,
		"ZW":             personalInfo.ZW,
		"SSJG":           personalInfo.SSJG,
		"GZ":             personalInfo.GZ,
		"JSDJ":           personalInfo.JSDJ,
		"XL":             personalInfo.XL,
		"Count":          personalInfo.Count,
	}

	c.Data["json"] = map[string]interface{}{
		"code": 200,
		"data": userInfo,
		"msg":  "登录成功",
	}
	c.ServeJSON()
}

// UserLogOut 用户登出
func (c *UserController) UserLogOut() {
	authHeader := c.Ctx.Input.Header("Authorization")
	if authHeader == "" {
		c.Ctx.Output.SetStatus(401)
		c.Data["json"] = map[string]interface{}{
			"code": 401,
			"msg":  "未提供认证信息",
		}
		c.ServeJSON()
		return
	}
	tokenString := authHeader
	if len(authHeader) > 7 && authHeader[:7] == "Bearer " {
		tokenString = authHeader[7:]
	}
	deleteShortToken(tokenString)
	c.DestroySession()
	c.Data["json"] = map[string]interface{}{
		"code": 200,
		"msg":  "登出成功",
	}
	c.ServeJSON()
}

// ValidateToken 简单token校验
func (c *UserController) ValidateToken() {
	authHeader := c.Ctx.Input.Header("Authorization")
	if authHeader == "" {
		c.Ctx.Output.SetStatus(401)
		c.Data["json"] = map[string]interface{}{
			"code": 401,
			"msg":  "未提供认证信息",
		}
		c.ServeJSON()
		return
	}
	tokenString := authHeader
	if len(authHeader) > 7 && authHeader[:7] == "Bearer " {
		tokenString = authHeader[7:]
	}
	userId, ok := validateShortToken(tokenString)
	if !ok {
		c.Ctx.Output.SetStatus(401)
		c.Data["json"] = map[string]interface{}{
			"code": 401,
			"msg":  "Token无效或已过期",
		}
		c.ServeJSON()
		return
	}
	c.Data["json"] = map[string]interface{}{
		"code": 200,
		"data": map[string]interface{}{
			"userid": userId,
		},
		"msg": "Token验证成功",
	}
	c.ServeJSON()
}