138 lines
3.2 KiB
Go
138 lines
3.2 KiB
Go
package server
|
|
|
|
import (
|
|
"encoding/hex"
|
|
"io"
|
|
v1 "sandc/api/eonline/v1"
|
|
"strings"
|
|
|
|
nethttp "net/http"
|
|
|
|
"github.com/go-kratos/kratos/v2/errors"
|
|
"github.com/go-kratos/kratos/v2/transport/http"
|
|
"github.com/google/wire"
|
|
"github.com/xxtea/xxtea-go/xxtea"
|
|
)
|
|
|
|
// EncryptKey is the key for encryption
|
|
const DecryptKey = "tk423&(gBUjX#$s0628"
|
|
|
|
// ProviderSet is server providers.
|
|
var ProviderSet = wire.NewSet(NewHTTPServer, NewGRPCServer, NewRegistrar, NewDiscovery, NewAsynqServer)
|
|
|
|
type ResData struct {
|
|
Code int `json:"code"`
|
|
Msg string `json:"msg"`
|
|
Data interface{} `json:"data"`
|
|
}
|
|
|
|
// DefaultErrorEncoder encodes the error to the HTTP response
|
|
func DefaultErrorEncoder(w nethttp.ResponseWriter, r *nethttp.Request, err error) {
|
|
se := errors.FromError(err)
|
|
codec, _ := http.CodecForRequest(r, "Accept")
|
|
reply := ResData{
|
|
Code: int(se.Code),
|
|
Msg: se.Message,
|
|
Data: nil,
|
|
}
|
|
|
|
// if strings.Contains(se.Message, "email not support") {
|
|
// reply.Code = 1
|
|
// }
|
|
|
|
// if strings.Contains(se.Message, "no payout chance") {
|
|
// reply.Code = 1
|
|
// }
|
|
|
|
body, err := codec.Marshal(reply)
|
|
if err != nil {
|
|
//给出自定义code
|
|
w.WriteHeader(nethttp.StatusInternalServerError)
|
|
return
|
|
}
|
|
|
|
w.Header().Set("Content-Type", strings.Join([]string{"application", codec.Name()}, "/"))
|
|
w.WriteHeader(200)
|
|
|
|
//加密
|
|
if r.Header.Get("encrypt") == "true" {
|
|
s := xxtea.Encrypt(body, []byte(DecryptKey))
|
|
body = []byte(hex.EncodeToString(s))
|
|
}
|
|
|
|
_, _ = w.Write(body)
|
|
}
|
|
|
|
// DefaultResponseEncoder encodes the object to the HTTP response.
|
|
func DefaultResponseEncoder(w nethttp.ResponseWriter, r *nethttp.Request, v interface{}) error {
|
|
codec, _ := http.CodecForRequest(r, "Accept")
|
|
|
|
//断言接口类型
|
|
if _, ok := v.(*v1.PayoutCallbackReply); ok {
|
|
w.Write([]byte("success"))
|
|
return nil
|
|
}
|
|
dv := v
|
|
data, err := codec.Marshal(dv)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
reply := struct {
|
|
Code int `json:"code"`
|
|
Msg string `json:"msg"`
|
|
}{
|
|
Code: 0,
|
|
Msg: "sucess",
|
|
}
|
|
|
|
replyData, err := codec.Marshal(reply)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
//fmt.Println(string(data))
|
|
var newData = make([]byte, 0, len(replyData)+len(data)+8)
|
|
newData = append(newData, replyData[:len(replyData)-1]...)
|
|
newData = append(newData, []byte(`,"data":`)...)
|
|
newData = append(newData, data...)
|
|
newData = append(newData, '}')
|
|
|
|
w.Header().Set("Content-Type", "application/json")
|
|
|
|
if r.Header.Get("encrypt") == "true" {
|
|
s := xxtea.Encrypt(newData, []byte(DecryptKey))
|
|
newData = []byte(hex.EncodeToString(s))
|
|
}
|
|
|
|
_, err = w.Write(newData)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func DefaultRequestDecoder(r *http.Request, v interface{}) error {
|
|
codec, ok := http.CodecForRequest(r, "Content-Type")
|
|
if !ok {
|
|
return errors.BadRequest("CODEC", r.Header.Get("Content-Type"))
|
|
}
|
|
data, err := io.ReadAll(r.Body)
|
|
if err != nil {
|
|
return errors.BadRequest("CODEC", err.Error())
|
|
}
|
|
_ = r.Body.Close()
|
|
if r.Header.Get("encrypt") == "true" {
|
|
if r.Header.Get("params") != "" {
|
|
p, _ := hex.DecodeString(r.Header.Get("params"))
|
|
data = xxtea.Decrypt(p, []byte(DecryptKey))
|
|
} else {
|
|
data = []byte("{}")
|
|
}
|
|
}
|
|
|
|
if err = codec.Unmarshal(data, v); err != nil {
|
|
return errors.BadRequest("CODEC", err.Error())
|
|
}
|
|
return nil
|
|
}
|