kpt-tmr-group/http/handler/system/user.go

package system

import (
	"kpt-tmr-group/http/middleware"
	"kpt-tmr-group/pkg/apierr"
	"kpt-tmr-group/pkg/apiok"
	"kpt-tmr-group/pkg/valid"
	operationPb "kpt-tmr-group/proto/go/backend/operation"
	"net/http"
	"strconv"

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

func Auth(c *gin.Context) {
	var req operationPb.UserAuth
	if err := c.BindJSON(&req); err != nil {
		apierr.AbortBadRequest(c, http.StatusBadRequest, err)
		return
	}

	if err := valid.ValidateStruct(&req,
		valid.Field(&req.UserName, valid.Required),
		valid.Field(&req.Password, valid.Required),
	); err != nil {
		apierr.AbortBadRequest(c, http.StatusBadRequest, err)
		return
	}

	res, err := middleware.Dependency(c).StoreEventHub.OpsService.Auth(c, &req)
	if err != nil {
		apierr.ClassifiedAbort(c, err)
		return
	}
	c.JSON(http.StatusOK, apiok.CommonResponse(res))
}

func AddSystemUser(c *gin.Context) {
	var req operationPb.AddSystemUser
	if err := c.BindJSON(&req); err != nil {
		apierr.AbortBadRequest(c, http.StatusBadRequest, err)
		return
	}

	if err := valid.ValidateStruct(&req,
		valid.Field(&req.Name, valid.Required),
		valid.Field(&req.Phone, valid.Required),
		valid.Field(&req.EmployeeName, valid.Required),
		valid.Field(&req.Roles, valid.NotNil),
		valid.Field(&req.IsShow, valid.Max(2), valid.Min(1)),
		valid.Field(&req.CreateUser, valid.Required),
	); err != nil {
		apierr.AbortBadRequest(c, http.StatusBadRequest, err)
		return
	}

	if err := middleware.Dependency(c).StoreEventHub.OpsService.CreateSystemUser(c, &req); err != nil {
		apierr.ClassifiedAbort(c, err)
		return
	}
	c.JSON(http.StatusOK, apiok.CommonResponse(apiok.NewApiOk(true)))
}

func GetUserInfo(c *gin.Context) {
	token := middleware.GetToken(c)
	if err := valid.Validate(token, valid.Required); err != nil {
		apierr.ClassifiedAbort(c, err)
		return
	}
	res, err := middleware.BackendOperation(c).OpsService.GetUserInfo(c, token)
	if err != nil {
		apierr.ClassifiedAbort(c, err)
		return
	}

	c.JSON(http.StatusOK, apiok.CommonResponse(res))
}

func SearchSystemUserList(c *gin.Context) {
	var req operationPb.SearchUserRequest
	if err := c.BindJSON(&req); err != nil {
		apierr.AbortBadRequest(c, http.StatusBadRequest, err)
		return
	}

	if err := valid.ValidateStruct(&req,
		valid.Field(&req.IsShow, valid.Max(2), valid.Min(1)),
	); err != nil {
		apierr.AbortBadRequest(c, http.StatusBadRequest, err)
		return
	}

	req.Pagination = &operationPb.PaginationModel{
		Page:       int32(c.GetInt(middleware.Page)),
		PageSize:   int32(c.GetInt(middleware.PageSize)),
		PageOffset: int32(c.GetInt(middleware.PageOffset)),
	}

	res, err := middleware.Dependency(c).StoreEventHub.OpsService.SearchSystemUserList(c, &req)
	if err != nil {
		apierr.ClassifiedAbort(c, err)
		return
	}
	c.JSON(http.StatusOK, apiok.CommonResponse(res))
}

func EditSystemUser(c *gin.Context) {
	var req operationPb.AddSystemUser
	if err := c.BindJSON(&req); err != nil {
		apierr.AbortBadRequest(c, http.StatusBadRequest, err)
		return
	}

	if err := valid.ValidateStruct(&req,
		valid.Field(&req.Id, valid.Required, valid.Min(1)),
		valid.Field(&req.Name, valid.Required),
		valid.Field(&req.Phone, valid.Required),
		valid.Field(&req.EmployeeName, valid.Required),
		valid.Field(&req.Roles, valid.Required),
		valid.Field(&req.CreateUser, valid.Required),
	); err != nil {
		apierr.AbortBadRequest(c, http.StatusBadRequest, err)
		return
	}

	if err := middleware.Dependency(c).StoreEventHub.OpsService.EditSystemUser(c, &req); err != nil {
		apierr.ClassifiedAbort(c, err)
		return
	}
	c.JSON(http.StatusOK, apiok.CommonResponse(apiok.NewApiOk(true)))
}

func DeleteUser(c *gin.Context) {
	userIdStr := c.Param("user_id")
	userId, _ := strconv.Atoi(userIdStr)

	if err := valid.Validate(userId, valid.Required, valid.Min(1)); err != nil {
		apierr.ClassifiedAbort(c, err)
		return
	}

	if err := middleware.BackendOperation(c).OpsService.DeleteSystemUser(c, int64(userId)); err != nil {
		apierr.ClassifiedAbort(c, err)
		return
	}

	c.JSON(http.StatusOK, apiok.CommonResponse(apiok.NewApiOk(true)))
}

func IsShowSystemUser(c *gin.Context) {
	var req operationPb.IsShowSystemUserRequest
	if err := c.BindJSON(&req); err != nil {
		apierr.AbortBadRequest(c, http.StatusBadRequest, err)
		return
	}

	if err := valid.ValidateStruct(&req,
		valid.Field(&req.UserId, valid.Required, valid.Min(1)),
		valid.Field(&req.IsShow, valid.Required, valid.Min(1), valid.Max(2)),
	); err != nil {
		apierr.AbortBadRequest(c, http.StatusBadRequest, err)
		return
	}

	if err := middleware.Dependency(c).StoreEventHub.OpsService.IsShowSystemUser(c, &req); err != nil {
		apierr.ClassifiedAbort(c, err)
		return
	}
	c.JSON(http.StatusOK, apiok.CommonResponse(apiok.NewApiOk(true)))
}