MTP20_IF/controllers/user/user.go

package user

import (
	"mtp2_if/global/app"
	"mtp2_if/global/e"
	"mtp2_if/logger"
	"mtp2_if/models"
	"net/http"

	"github.com/gin-gonic/gin"
)

// QueryUserReferNumReq 获取用户邀请码请求参数
type QueryUserReferNumReq struct {
	UserID int `form:"userID" binding:"required"`
}

// QueryUserReferNum 获取用户邀请码
// @Summary 获取用户邀请码
// @Produce json
// @Param userID query int true "用户ID"
// @Success 200 {object} app.Response
// @Failure 500 {object} app.Response
// @Router /User/QueryUserReferNum [get]
// @Tags 用户信息
func QueryUserReferNum(c *gin.Context) {
	appG := app.Gin{C: c}

	// 获取请求参数
	var req QueryUserReferNumReq
	if err := appG.C.ShouldBindQuery(&req); err != nil {
		logger.GetLogger().Errorf("QueryUserReferNum failed: %s", err.Error())
		appG.Response(http.StatusBadRequest, e.INVALID_PARAMS, nil)
		return
	}

	var (
		userAccount *models.Useraccount
		err         error
	)
	if userAccount, err = models.GetUserAccount(req.UserID); err != nil {
		// 查询失败
		logger.GetLogger().Errorf("QueryUserReferNum failed: %s", err.Error())
		appG.Response(http.StatusBadRequest, e.ERROR_QUERY_FAIL, nil)
		return
	}

	// 查询成功
	logger.GetLogger().Debugln("QueryUserReferNum successed: %v", userAccount.Refernum)
	appG.Response(http.StatusOK, e.SUCCESS, userAccount.Refernum)
}

// QueryUserInfoReq 获取用户信息请求参数
type QueryUserInfoReq struct {
	UserID int `form:"userID" binding:"required"`
}

// QueryUserInfo 获取用户信息
// @Summary 获取用户信息
// @Produce json
// @Security ApiKeyAuth
// @Param userID query int true "用户ID"
// @Success 200 {object} models.Userinfo
// @Failure 500 {object} app.Response
// @Router /User/QueryUserInfo [get]
// @Tags 用户信息
func QueryUserInfo(c *gin.Context) {
	appG := app.Gin{C: c}

	// 获取请求参数
	var req QueryUserReferNumReq
	if err := appG.C.ShouldBindQuery(&req); err != nil {
		logger.GetLogger().Errorf("QueryUserInfo failed: %s", err.Error())
		appG.Response(http.StatusBadRequest, e.INVALID_PARAMS, nil)
		return
	}

	// 查询数据
	var (
		data *models.Userinfo
		err  error
	)
	if data, err = models.GetUserInfo(req.UserID); err != nil {
		// 查询失败
		logger.GetLogger().Errorf("QueryUserInfo failed: %s", err.Error())
		appG.Response(http.StatusBadRequest, e.ERROR_QUERY_FAIL, nil)
		return
	}

	// 查询成功
	logger.GetLogger().Debugln("QueryUserInfo successed: %v", data)
	appG.Response(http.StatusOK, e.SUCCESS, data)
}

// GetUserAuthStatusReq 获取用户实名认证状态请求参数
type GetUserAuthStatusReq struct {
	UserID int `form:"userID" binding:"required"` // 用户ID
}

// GetUserAuthStatus 获取用户实名认证状态
// @Summary 获取用户实名认证状态
// @Produce json
// @Security ApiKeyAuth
// @Param userID query int true "用户ID"
// @Success 200 {bool} app.Response
// @Failure 500 {object} app.Response
// @Router /User/GetUserAuthStatus [get]
// @Tags 用户信息
func GetUserAuthStatus(c *gin.Context) {
	appG := app.Gin{C: c}

	// 获取请求参数
	var req GetUserAuthStatusReq
	if err := appG.C.ShouldBindQuery(&req); err != nil {
		logger.GetLogger().Errorf("GetUserAuthStatus failed: %s", err.Error())
		appG.Response(http.StatusBadRequest, e.INVALID_PARAMS, nil)
		return
	}

	isAuth := false
	var (
		userAccount *models.Useraccount
		err         error
	)
	if userAccount, err = models.GetUserAccount(req.UserID); err != nil {
		// 查询失败
		logger.GetLogger().Errorf("GetUserAuthStatus failed: %s", err.Error())
		appG.Response(http.StatusBadRequest, e.ERROR_QUERY_FAIL, nil)
		return
	}
	if userAccount != nil {
		if userAccount.Hasauth == 1 {
			isAuth = true
		}
	}

	// 查询成功
	logger.GetLogger().Debugln("GetUserAuthStatus successed: %v", isAuth)
	appG.Response(http.StatusOK, e.SUCCESS, isAuth)
}

// QueryUserFavoriteGoodsesReq 获取用户商品收藏信息请求参数
type QueryUserFavoriteGoodsesReq struct {
	UserID int `form:"userID" binding:"required"`
}

// QueryUserFavoriteGoodses 获取用户商品收藏信息
// @Summary 获取用户商品收藏信息
// @Produce json
// @Security ApiKeyAuth
// @Param userID query int true "用户ID"
// @Success 200 {bool} models.Userfavoritegoods
// @Failure 500 {object} app.Response
// @Router /User/QueryUserFavoriteGoodses [get]
// @Tags 用户信息
func QueryUserFavoriteGoodses(c *gin.Context) {
	appG := app.Gin{C: c}

	// 获取请求参数
	var req QueryUserFavoriteGoodsesReq
	if err := appG.C.ShouldBindQuery(&req); err != nil {
		logger.GetLogger().Errorf("QueryUserFavoriteGoodses failed: %s", err.Error())
		appG.Response(http.StatusBadRequest, e.INVALID_PARAMS, nil)
		return
	}

	userFavoriteGoodses, err := models.GetUserFavoriteGoodses(req.UserID)
	if err != nil {
		// 查询失败
		logger.GetLogger().Errorf("GetUserAuthStatus failed: %s", err.Error())
		appG.Response(http.StatusBadRequest, e.ERROR_QUERY_FAIL, nil)
		return
	}

	// 查询成功
	logger.GetLogger().Debugln("QueryUserFavoriteGoodses successed: %v", userFavoriteGoodses)
	appG.Response(http.StatusOK, e.SUCCESS, userFavoriteGoodses)
}

// UpdateUserFavoriteGoodsReq 更新用户商品收藏信息请求参数
type UpdateUserFavoriteGoodsReq struct {
	UserID  int `form:"userID" binding:"required"`
	GoodsID int `form:"goodsID" binding:"required"`
}

// AddUserFavoriteGoods 添加用户商品收藏信息
// @Summary 添加用户商品收藏信息
// @Produce json
// @Security ApiKeyAuth
// @Param userID query int true "用户ID"
// @Param goodsID query int true "商品ID"
// @Success 200 {object} app.Response
// @Failure 500 {object} app.Response
// @Router /User/AddUserFavoriteGoods [post]
// @Tags 用户信息
func AddUserFavoriteGoods(c *gin.Context) {
	appG := app.Gin{C: c}

	// 获取请求参数
	var req UpdateUserFavoriteGoodsReq
	if err := appG.C.ShouldBind(&req); err != nil {
		logger.GetLogger().Errorf("AddUserFavoriteGoods failed: %s", err.Error())
		appG.Response(http.StatusBadRequest, e.INVALID_PARAMS, nil)
		return
	}

	if err := models.InsertUserFavoriteGoods(req.UserID, req.GoodsID); err != nil {
		// 执行失败
		logger.GetLogger().Errorf("AddUserFavoriteGoods failed: %s", err.Error())
		appG.Response(http.StatusBadRequest, e.ERROR_OPERATION_FAILED, nil)
		return
	}

	// 执行成功
	logger.GetLogger().Debugln("AddUserFavoriteGoods successed: %v", "ok")
	appG.Response(http.StatusOK, e.SUCCESS, "")
}

// RemoveUserFavoriteGoods 移除用户商品收藏信息
// @Summary 移除用户商品收藏信息
// @Produce json
// @Security ApiKeyAuth
// @Param userID query int true "用户ID"
// @Param goodsID query int true "商品ID"
// @Success 200 {object} app.Response
// @Failure 500 {object} app.Response
// @Router /User/RemoveUserFavoriteGoods [post]
// @Tags 用户信息
func RemoveUserFavoriteGoods(c *gin.Context) {
	appG := app.Gin{C: c}

	// 获取请求参数
	var req UpdateUserFavoriteGoodsReq
	if err := appG.C.ShouldBind(&req); err != nil {
		logger.GetLogger().Errorf("RemoveUserFavoriteGoods failed: %s", err.Error())
		appG.Response(http.StatusBadRequest, e.INVALID_PARAMS, nil)
		return
	}

	if err := models.DelUserFavoriteGoods(req.UserID, req.GoodsID); err != nil {
		// 执行失败
		logger.GetLogger().Errorf("RemoveUserFavoriteGoods failed: %s", err.Error())
		appG.Response(http.StatusBadRequest, e.ERROR_OPERATION_FAILED, nil)
		return
	}

	// 执行成功
	logger.GetLogger().Debugln("RemoveUserFavoriteGoods successed: %v", "ok")
	appG.Response(http.StatusOK, e.SUCCESS, "")
}

// QueryMessageBoardReq 获取用户留言板信息请求参数
type QueryMessageBoardReq struct {
	UserID int `form:"userID" binding:"required"`
}

// QueryMessageBoard 获取用户留言板信息
// @Summary 获取用户留言板信息
// @Produce json
// @Security ApiKeyAuth
// @Param userID query int true "用户ID"
// @Success 200 {bool} models.Messageboard
// @Failure 500 {object} app.Response
// @Router /User/QueryMessageBoard [get]
// @Tags 用户信息
func QueryMessageBoard(c *gin.Context) {
	appG := app.Gin{C: c}

	// 获取请求参数
	var req QueryMessageBoardReq
	if err := appG.C.ShouldBindQuery(&req); err != nil {
		logger.GetLogger().Errorf("QueryMessageBoard failed: %s", err.Error())
		appG.Response(http.StatusBadRequest, e.INVALID_PARAMS, nil)
		return
	}

	messageBoards, err := models.GetMessageBoard(req.UserID)
	if err != nil {
		// 查询失败
		logger.GetLogger().Errorf("QueryMessageBoard failed: %s", err.Error())
		appG.Response(http.StatusBadRequest, e.ERROR_QUERY_FAIL, nil)
		return
	}

	// 查询成功
	logger.GetLogger().Debugln("QueryMessageBoard successed: %v", messageBoards)
	appG.Response(http.StatusOK, e.SUCCESS, messageBoards)
}

// AddMessageBoardReq 添加用户留言板信息请求参数
type AddMessageBoardReq struct {
	UserID  int    `form:"userID" binding:"required"`
	Message string `form:"message" binding:"required"`
}

// AddMessageBoard 添加用户留言板信息
// @Summary 添加用户留言板信息
// @Produce json
// @Security ApiKeyAuth
// @Param userID query int true "用户ID"
// @Param message query string true "留言信息"
// @Success 200 {object} app.Response
// @Failure 500 {object} app.Response
// @Router /User/AddMessageBoard [post]
// @Tags 用户信息
func AddMessageBoard(c *gin.Context) {
	appG := app.Gin{C: c}

	// 获取请求参数
	var req AddMessageBoardReq
	if err := appG.C.ShouldBind(&req); err != nil {
		logger.GetLogger().Errorf("AddMessageBoard failed: %s", err.Error())
		appG.Response(http.StatusBadRequest, e.INVALID_PARAMS, nil)
		return
	}

	if errCode := models.InsertMessageBoard(req.UserID, req.Message); errCode != 0 {
		// 执行失败
		logger.GetLogger().Errorf("AddMessageBoard failed: %s", e.GetMsg(errCode))
		appG.Response(http.StatusBadRequest, errCode, nil)
		return
	}

	// 执行成功
	logger.GetLogger().Debugln("AddMessageBoard successed: %v", "ok")
	appG.Response(http.StatusOK, e.SUCCESS, "")
}