Go language development of door-to-door cooking system: How to implement user subscription function?

// 注册
func Signup(c *gin.Context) {
    // 获取注册表单参数
    var user User
    if err := c.ShouldBindJSON(&user); err != nil {
        // 处理参数错误
        c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
        return
    }

    // 存储用户信息到数据库
    err := db.Create(&user).Error
    if err != nil {
        c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
        return
    }

    c.JSON(http.StatusOK, gin.H{"message": "注册成功"})
}

// 登录
func Login(c *gin.Context) {
    // 获取登录表单参数
    var userReq UserReq
    if err := c.ShouldBindJSON(&userReq); err != nil {
        // 处理参数错误
        c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
        return
    }

    // 验证用户信息是否正确
    var user User
    err := db.Where("username = ? AND password = ?", userReq.Username, userReq.Password).First(&user).Error
    if err != nil {
        c.JSON(http.StatusUnauthorized, gin.H{"error": "用户名或密码错误"})
        return
    }

    // 生成JWT并返回给客户端
    token, err := generateToken(user.ID)
    if err != nil {
        c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
        return
    }

    c.JSON(http.StatusOK, gin.H{"token": token})
}

// 获取套餐列表
func GetPackages(c *gin.Context) {
    var packages []Package
    err := db.Find(&packages).Error
    if err != nil {
        c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
        return
    }

    c.JSON(http.StatusOK, gin.H{"packages": packages})
}

// 添加套餐
func AddPackage(c *gin.Context) {
    var package Package
    if err := c.ShouldBindJSON(&package); err != nil {
        c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
        return
    }

    err := db.Create(&package).Error
    if err != nil {
        c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
        return
    }

    c.JSON(http.StatusOK, gin.H{"message": "添加套餐成功"})
}

// 修改套餐
func UpdatePackage(c *gin.Context) {
    packageID := c.Param("id")
    var package Package
    if err := db.Where("id = ?", packageID).First(&package).Error; err != nil {
        c.JSON(http.StatusNotFound, gin.H{"error": "套餐不存在"})
        return
    }

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

    package.Name = newPackage.Name
    package.Price = newPackage.Price
    package.Description = newPackage.Description

    err := db.Save(&package).Error
    if err != nil {
        c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
        return
    }

    c.JSON(http.StatusOK, gin.H{"message": "修改套餐成功"})
}

// 删除套餐
func DeletePackage(c *gin.Context) {
    packageID := c.Param("id")
    var package Package
    if err := db.Where("id = ?", packageID).First(&package).Error; err != nil {
        c.JSON(http.StatusNotFound, gin.H{"error": "套餐不存在"})
        return
    }

    err := db.Delete(&package).Error
    if err != nil {
        c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
        return
    }

    c.JSON(http.StatusOK, gin.H{"message": "删除套餐成功"})
}

// 订阅套餐
func SubscribePackage(c *gin.Context) {
    userID := getUserIDFromToken(c)

    // 获取订阅表单参数
    var order OrderReq
    if err := c.ShouldBindJSON(&order); err != nil {
        c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
        return
    }

    // 验证套餐是否存在
    var package Package
    if err := db.Where("id = ?", order.PackageID).First(&package).Error; err != nil {
        c.JSON(http.StatusNotFound, gin.H{"error": "套餐不存在"})
        return
    }

    // 创建订单
    order := Order{
        UserID: userID,
        PackageID: order.PackageID,
        SubscribeDate: time.Now(),
        SubscribeStatus: 0,  // 未支付状态
    }
    err := db.Create(&order).Error
    if err != nil {
        c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
        return
    }

    c.JSON(http.StatusOK, gin.H{"message": "订阅成功"})
}

// 查看订单
func GetOrders(c *gin.Context) {
    userID := getUserIDFromToken(c)

    var orders []Order
    err := db.Where("user_id = ?", userID).Find(&orders).Error
    if err != nil {
        c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
        return
    }

    c.JSON(http.StatusOK, gin.H{"orders": orders})
}

// 取消订单
func CancelOrder(c *gin.Context) {
    userID := getUserIDFromToken(c)
    orderID := c.Param("id")

    var order Order
    if err := db.Where("id = ? AND user_id = ?", orderID, userID).First(&order).Error; err != nil {
        c.JSON(http.StatusNotFound, gin.H{"error": "订单不存在"})
        return
    }

    err := db.Delete(&order).Error
    if err != nil {
        c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
        return
    }

    c.JSON(http.StatusOK, gin.H{"message": "取消订单成功"})
}