baize/framework/core/api/response/response.go

package response

import (
	"encoding/json"
	"git.sxidc.com/go-framework/baize/framework/core/api"
	"git.sxidc.com/go-framework/baize/framework/core/infrastructure/logger"
	"git.sxidc.com/service-supports/fserr"
	"git.sxidc.com/service-supports/websocket"
)

type SendResponseFunc[O any] func(c *api.Context, statusCode int, data O, err error)

func NoResponse(_ *api.Context, _ int, _ any, _ error) {
	return
}

func SendMsgResponse(c *api.Context, statusCode int, _ any, err error) {
	msgResp := formMsgResponse(err)
	c.JSON(statusCode, msgResp)
}

type IDResponse struct {
	MsgResponse
	ID string `json:"id"`
}

func SendIDResponse(c *api.Context, statusCode int, id string, err error) {
	msgResp := formMsgResponse(err)
	c.JSON(statusCode, IDResponse{
		MsgResponse: msgResp,
		ID:          id,
	})
}

type InfoResponse[T any] struct {
	MsgResponse
	Info T `json:"info"`
}

func SendInfoResponse[T any](c *api.Context, statusCode int, info T, err error) {
	msgResp := formMsgResponse(err)
	c.JSON(statusCode, InfoResponse[T]{
		MsgResponse: msgResp,
		Info:        info,
	})
}

type InfosResponse[T any] struct {
	MsgResponse
	InfosData[T]
}

func SendInfosResponse[T any](c *api.Context, statusCode int, data InfosData[T], err error) {
	msgResp := formMsgResponse(err)
	c.JSON(statusCode, InfosResponse[T]{
		MsgResponse: msgResp,
		InfosData:   data,
	})
}

func StructToMap(originStruct any) map[string]any {
	jsonBytes, err := json.Marshal(originStruct)
	if err != nil {
		panic(err)
	}

	retMap := make(map[string]any)
	err = json.Unmarshal(jsonBytes, &retMap)
	if err != nil {
		panic(err)
	}

	return retMap
}

func SendMapResponse(c *api.Context, statusCode int, data map[string]any, err error) {
	msgRespMap := formMapMsgResponse(err)
	for key, value := range data {
		msgRespMap[key] = value
	}

	c.JSON(statusCode, msgRespMap)
}

type MsgResponse struct {
	Success bool   `json:"success"`
	ErrCode int    `json:"errCode"`
	Msg     string `json:"msg"`
}

func formMsgResponse(err error) MsgResponse {
	if err != nil {
		logger.GetInstance().Error(err)
		serviceErr := fserr.ParseCode(err)

		return MsgResponse{
			Success: false,
			ErrCode: serviceErr.BusinessCode,
			Msg:     serviceErr.Msg,
		}
	}

	return MsgResponse{
		Success: true,
		ErrCode: 0,
		Msg:     "操作成功",
	}
}

func formMapMsgResponse(err error) map[string]any {
	resp := make(map[string]any)
	if err != nil {
		logger.GetInstance().Error(err)
		serviceErr := fserr.ParseCode(err)

		resp["success"] = false
		resp["errCode"] = serviceErr.BusinessCode
		resp["msg"] = serviceErr.Msg

		return resp
	}

	resp["success"] = true
	resp["errCode"] = 0
	resp["msg"] = "操作成功"

	return resp
}

func WSSendMessage(groupID string, obj any) {
	message, err := json.Marshal(obj)
	if err != nil {
		logger.GetInstance().Error(fserr.New(err.Error()))
		return
	}

	err = websocket.GetInstance().BroadCast(groupID, message)
	if err != nil {
		logger.GetInstance().Error(fserr.New(err.Error()))
		return
	}
}

func SendString(c *api.Context, statusCode int, data string, err error) {
	if err != nil {
		c.String(statusCode, err.Error())
		return
	}

	c.String(statusCode, data)
}

func WriteBytes(c *api.Context, statusCode int, bytes []byte, err error) {
	if err != nil {
		c.AbortWithStatus(statusCode)
		return
	}

	_, err = c.Writer.Write(bytes)
	if err != nil {
		logger.GetInstance().Error(fserr.New(err.Error()))
		c.AbortWithStatus(statusCode)
		return
	}

	c.Writer.Flush()
}

type WXOrderResponse struct {
	ReturnCode string `xml:"return_code"`
	ReturnMsg  string `xml:"return_msg"`
}

func SendWXOrderResponse(c *api.Context, statusCode int, _ any, err error) {
	if err != nil {
		c.XML(statusCode, &WXOrderResponse{
			ReturnCode: "FAIL",
			ReturnMsg:  err.Error(),
		})
		return
	}

	c.XML(statusCode, &WXOrderResponse{
		ReturnCode: "SUCCESS",
	})
}