zzyxyz_go_api/internal/handlers/user_np.go

// internal/handlers/user_np.go

package handlers

import (
	"net/http"

	api "git.zzyxyz.com/zzy/zzyxyz_go_api/gen/user_np"
	"git.zzyxyz.com/zzy/zzyxyz_go_api/internal/models"
	"github.com/gin-gonic/gin"
	"gorm.io/driver/sqlite"
	"gorm.io/gorm"
)

type UserNPImpl struct {
	db *gorm.DB
}

func NewUserNP(dbPath string) (*UserNPImpl, error) {
	var err error
	var db *gorm.DB
	db, err = gorm.Open(sqlite.Open(dbPath), &gorm.Config{})
	if err != nil {
		return nil, err
	}

	// 自动迁移表结构
	err = db.AutoMigrate(&models.UserNP{})
	if err != nil {
		return nil, err
	}

	return &UserNPImpl{db: db}, nil
}

// PostAuthLogin 用户登录
func (u *UserNPImpl) PostAuthLogin(c *gin.Context) {
	var req api.PostAuthLoginJSONRequestBody
	if err := c.ShouldBindJSON(&req); err != nil {
		c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
		return
	}

	// 查找用户
	var user models.UserNP
	if err := u.db.Where("username = ?", req.Username).First(&user).Error; err != nil {
		c.JSON(http.StatusUnauthorized, gin.H{"error": "用户名或密码错误"})
		return
	}

	// 验证密码
	if !user.CheckPassword(req.Password) {
		c.JSON(http.StatusUnauthorized, gin.H{"error": "用户名或密码错误"})
		return
	}

	// 生成JWT token
	token, err := user.GenerateSimpleJWT()
	if err != nil {
		c.JSON(http.StatusInternalServerError, gin.H{"error": "无法生成访问令牌"})
		return
	}

	// 更新用户token字段（可选）
	user.Token = &token
	u.db.Save(&user)

	c.JSON(http.StatusOK, api.LoginResponse{
		Token:  &token,
		UserId: &user.ID,
	})
}

// PostAuthRegister 用户注册
func (u *UserNPImpl) PostAuthRegister(c *gin.Context) {
	var req api.PostAuthRegisterJSONRequestBody
	if err := c.ShouldBindJSON(&req); err != nil {
		c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
		return
	}

	// 检查用户名是否已存在
	var existingUser models.UserNP
	if err := u.db.Where("username = ?", req.Username).First(&existingUser).Error; err == nil {
		c.JSON(http.StatusConflict, gin.H{"error": "用户名已存在"})
		return
	}

	// 创建新用户
	user := models.UserNP{
		Username: req.Username,
		Email:    req.Email,
	}

	// 加密密码
	if err := user.HashPassword(req.Password); err != nil {
		c.JSON(http.StatusInternalServerError, gin.H{"error": "密码处理失败"})
		return
	}

	// 保存到数据库
	if err := u.db.Create(&user).Error; err != nil {
		c.JSON(http.StatusInternalServerError, gin.H{"error": "用户创建失败"})
		return
	}

	c.JSON(http.StatusCreated, nil)
}

// PutAuthPassword 修改密码
func (u *UserNPImpl) PutAuthPassword(c *gin.Context) {
	// 获取Authorization头中的token
	authHeader := c.GetHeader("Authorization")
	if authHeader == "" {
		c.JSON(http.StatusUnauthorized, gin.H{"error": "缺少访问令牌"})
		return
	}

	// 验证token并获取用户名
	username, err := models.CheckSimpleJWT(authHeader)
	if err != nil {
		c.JSON(http.StatusUnauthorized, gin.H{"error": err.Error()})
		return
	}

	var req api.PutAuthPasswordJSONRequestBody
	if err := c.ShouldBindJSON(&req); err != nil {
		c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
		return
	}

	// 查找用户
	var user models.UserNP
	if err := u.db.Where("username = ?", username).First(&user).Error; err != nil {
		c.JSON(http.StatusUnauthorized, gin.H{"error": "用户不存在"})
		return
	}

	// 验证旧密码
	if !user.CheckPassword(req.OldPassword) {
		c.JSON(http.StatusUnauthorized, gin.H{"error": "旧密码错误"})
		return
	}

	// 加密新密码
	if err := user.HashPassword(req.NewPassword); err != nil {
		c.JSON(http.StatusInternalServerError, gin.H{"error": "密码处理失败"})
		return
	}

	// 保存到数据库
	if err := u.db.Save(&user).Error; err != nil {
		c.JSON(http.StatusInternalServerError, gin.H{"error": "密码更新失败"})
		return
	}

	// 生成新的JWT token
	token, err := user.GenerateSimpleJWT()
	if err != nil {
		c.JSON(http.StatusInternalServerError, gin.H{"error": "无法生成新的访问令牌"})
		return
	}

	// 更新用户token字段
	user.Token = &token
	u.db.Save(&user)

	c.JSON(http.StatusOK, nil)
}

// Make sure we conform to ServerInterface
var _ api.ServerInterface = (*UserNPImpl)(nil)