SCADATrainSys/Tech/controllers/用户.go

// controllers/用户.go
package controllers

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

	"github.com/beego/beego/v2/client/orm"
	"github.com/beego/beego/v2/core/logs"
	beego "github.com/beego/beego/v2/server/web"
	"github.com/sirupsen/logrus"
)

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

var CurrentLoginMode int = 0 // 0-信息化验证，1-本地数据库验证

// 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
}

// decryptMD5Password 尝试解密MD5密码
func decryptMD5Password(hash string) string {

	// 无法解密，返回原始hash值
	return hash
}

// initUserInfoCache 初始化用户信息缓存
func InitUserInfoCache() {
	logs.Info("开始初始化用户信息缓存...")
	common.LogInfo("开始初始化用户信息缓存...", logrus.Fields{
		"module": "user",
		"action": "cache_init",
	})

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

	var tempUser []models.UserData

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

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

		// 转换为UserData结构并添加到tempUser数组
		var userTypeInt int
		// SF字段：1-学生 2-教师
		if info.SF == "1" {
			userTypeInt = 1 // 学生
		} else if info.SF == "2" {
			userTypeInt = 2 // 教师
		} else {
			userTypeInt = 0 // 默认管理员
		}

		// 创建UserData结构体
		userData := models.UserData{
			RYID:     info.RYID,
			RYEMPID:  info.RYEMPID,
			UserName: info.XM, // 使用姓名作为用户名
			UserType: userTypeInt,
			Password: "123", // 存储明文密码
		}

		tempUser = append(tempUser, userData)
	}

	// 批量插入数据库以提高效率
	o := orm.NewOrm()

	// 开始事务
	txOrmer, err := o.Begin()
	if err != nil {
		logs.Error("开启事务失败: ", err)
		return
	}

	// 先清空现有的UserData表
	_, err = txOrmer.Raw("DELETE FROM UserData").Exec()
	if err != nil {
		txOrmer.Rollback()
		logs.Error("清空用户数据表失败: ", err)
		return
	}

	// 批量插入用户数据
	if len(tempUser) > 0 {
		// 使用批量插入提高效率
		_, err = txOrmer.InsertMulti(len(tempUser), tempUser)
		if err != nil {
			txOrmer.Rollback()
			logs.Error("批量插入用户数据失败: ", err)
			return
		}
	}

	// 提交事务
	err = txOrmer.Commit()
	if err != nil {
		logs.Error("提交事务失败: ", err)
		return
	}

	logs.Info("用户信息缓存初始化完成，共缓存%d个用户到数据库", len(tempUser))
	common.LogInfo("用户信息缓存初始化完成", logrus.Fields{
		"module": "user",
		"action": "cache_init_complete",
		"user_count": len(tempUser),
	})
}
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"`
		LoginMode int    `json:"loginMode"` // 0-信息化验证，1-本地数据库验证
	}
	requestBody := c.Ctx.Input.RequestBody
	println("Request Body:", string(requestBody))
	
	// 记录用户登录请求
	clientIP := c.Ctx.Input.IP()
	
	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()
		
		// 记录登录失败日志
		common.LogUserAction(req.UserName, req.UserName, "login_failed", "user", logrus.Fields{
			"reason": "invalid_request_format",
			"ip":     clientIP,
			"error":  err.Error(),
		})
		return
	}

	if req.UserName == "" || req.Password == "" {
		c.Ctx.Output.SetStatus(400)
		c.Data["json"] = map[string]interface{}{
			"code": 400,
			"msg":  "用户名和密码不能为空",
		}
		c.ServeJSON()
		
		// 记录登录失败日志
		common.LogUserAction(req.UserName, req.UserName, "login_failed", "user", logrus.Fields{
			"reason": "empty_credentials",
			"ip":     clientIP,
		})
		return
	}

	var personalInfo common.PersonalInfo

	// 根据loginMode选择验证方式
	if req.LoginMode == 1 {
		// 本地数据库验证
		common.LogDebug("用户登录尝试", logrus.Fields{
			"module": "user",
			"action": "local_login_attempt",
			"username": req.UserName,
			"login_mode": "local",
			"ip": clientIP,
		})
		
		o := orm.NewOrm()
		var userData models.UserData
		err := o.QueryTable(new(models.UserData)).Filter("人员ID", req.UserName).One(&userData)
		if err != nil {
			c.Ctx.Output.SetStatus(401)
			c.Data["json"] = map[string]interface{}{
				"code": 401,
				"msg":  "用户名或密码错误",
			}
			c.ServeJSON()
			
			// 记录登录失败日志
			common.LogUserAction(req.UserName, req.UserName, "login_failed", "user", logrus.Fields{
				"reason": "user_not_found",
				"login_mode": "local",
				"ip": clientIP,
			})
			return
		}

		// 验证密码
		if userData.Password != req.Password {
			c.Ctx.Output.SetStatus(401)
			c.Data["json"] = map[string]interface{}{
				"code": 401,
				"msg":  "用户名或密码错误",
			}
			c.ServeJSON()
			
			// 记录登录失败日志
			common.LogUserAction(req.UserName, req.UserName, "login_failed", "user", logrus.Fields{
				"reason": "wrong_password",
				"login_mode": "local",
				"ip": clientIP,
			})
			return
		}

		// 从缓存中获取详细信息（如果有）
		if info, exists := GetUserInfoFromCache(userData.RYID); exists {
			personalInfo = info
		} else {
			// 如果缓存中没有，创建基本信息
			personalInfo = common.PersonalInfo{
				RYID:    userData.RYID,
				RYEMPID: userData.RYEMPID,
				XM:      userData.UserName,
				SF:      fmt.Sprintf("%d", userData.UserType),
			}
		}

		CurrentLoginMode = 1
	} else {
		// 默认使用信息化系统验证 (req.LoginMode == 0)
		common.LogDebug("用户登录尝试", logrus.Fields{
			"module": "user",
			"action": "info_system_login_attempt",
			"username": req.UserName,
			"login_mode": "info_system",
			"ip": clientIP,
		})
		
		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()
			
			// 记录登录失败日志
			common.LogUserAction(req.UserName, req.UserName, "login_failed", "user", logrus.Fields{
				"reason": "info_system_error",
				"login_mode": "info_system",
				"ip": clientIP,
				"error": err.Error(),
			})
			return
		}

		// 检查登录结果
		if loginResp.ResultCode != "0" {
			c.Ctx.Output.SetStatus(401)
			c.Data["json"] = map[string]interface{}{
				"code": 401,
				"msg":  loginResp.ResultDesc,
			}
			c.ServeJSON()
			
			// 记录登录失败日志
			common.LogUserAction(req.UserName, req.UserName, "login_failed", "user", logrus.Fields{
				"reason": "info_system_rejected",
				"login_mode": "info_system",
				"ip": clientIP,
				"result_code": loginResp.ResultCode,
				"result_desc": loginResp.ResultDesc,
			})
			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
		}

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

		CurrentLoginMode = 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,
		"LoginMode":      CurrentLoginMode,
	}

	// 记录登录成功日志
	loginModeStr := "local"
	if CurrentLoginMode == 0 {
		loginModeStr = "info_system"
	}
	common.LogUserAction(personalInfo.RYID, personalInfo.XM, "login_success", "user", logrus.Fields{
		"login_mode": loginModeStr,
		"ip": clientIP,
		"user_type": personalInfo.SF,
		"organization": personalInfo.SSDW,
	})

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

// UserLogOut 用户登出
func (c *UserController) UserLogOut() {
	clientIP := c.Ctx.Input.IP()
	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:]
	}
	
	// 从token获取用户信息用于日志记录
	userId, ok := validateShortToken(tokenString)
	userName := "unknown"
	if ok && userId != "" {
		// 尝试从缓存获取用户名
		if userInfo, exists := GetUserInfoFromCache(userId); exists {
			userName = userInfo.XM
		}
	}
	
	deleteShortToken(tokenString)
	c.DestroySession()
	
	// 记录登出日志
	common.LogUserAction(userId, userName, "logout", "user", logrus.Fields{
		"ip": clientIP,
	})
	
	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()
}