ku-kratos-layout/api/helloworld/v1/greeter_http.pb.go

// Code generated by protoc-gen-go-http. DO NOT EDIT.

package v1

import (
	context "context"
	json "encoding/json"
	common "git.ikuban.com/server/kratos-utils/common"
	http1 "git.ikuban.com/server/kratos-utils/http"
	binding "git.ikuban.com/server/kratos-utils/http/binding"
	reply "git.ikuban.com/server/kratos-utils/http/reply"
	base "git.ikuban.com/server/we-protobuf/api/base"
	errors "github.com/go-kratos/kratos/v2/errors"
	http2 "github.com/go-kratos/kratos/v2/transport/http"
	mux "github.com/gorilla/mux"
	status "google.golang.org/grpc/status"
	http "net/http"
)

// This is a compile-time assertion to ensure that this generated file
// is compatible with the kratos package it is being compiled against.
var _ = new(http.Request)
var _ = new(json.Token)
var _ = new(status.Status)
var _ = new(context.Context)
var _ = new(common.JWT)
var _ = new(reply.SuccessReply)
var _ = new(base.Html)
var _ = new(errors.Error)
var _ = binding.MapProto
var _ = http1.ContentTypeHeader
var _ = mux.NewRouter

const _ = http2.SupportPackageIsVersion1

type GreeterHandler interface {
	SayHello(context.Context, *HelloRequest) (*HelloReply, error)
}

func NewGreeterHandler(srv GreeterHandler, opts ...http2.HandleOption) http.Handler {
	h := http2.HandleOptions{
		Error:  http1.ErrHandle,
		Encode: http1.EncodeResponse,
		Decode: http1.DecodeRequest,
	}
	for _, o := range opts {
		o(&h)
	}
	r := mux.NewRouter()

	r.HandleFunc("/helloworld/{name}", func(w http.ResponseWriter, r *http.Request) {
		var in HelloRequest
		if err := h.Decode(r, &in); err != nil {
			h.Error(w, r, err)
			return
		}

		if err := binding.MapProto(&in, mux.Vars(r)); err != nil {
			h.Error(w, r, err)
			return
		}

		next := func(ctx context.Context, req interface{}) (interface{}, error) {
			return srv.SayHello(ctx, req.(*HelloRequest))
		}
		if h.Middleware != nil {
			next = h.Middleware(next)
		}
		out, err := next(r.Context(), &in)
		if err != nil {
			errStatus := errors.FromError(err)
			if errStatus != nil {
				if errStatus.Reason != "" {
					fail := &reply.SuccessReply{
						Code:    errStatus.GRPCStatus().Proto().Code,
						Message: errStatus.GRPCStatus().Message(),
					}
					var obj interface{}
					json.Unmarshal([]byte(errors.Reason(err)), &obj)
					fail.Data = obj
					w.WriteHeader(400)
					if err := h.Encode(w, r, fail); err != nil {
						h.Error(w, r, err)
					}
					return
				}
			}
			h.Error(w, r, err)
			return
		}
		success := &reply.SuccessReply{
			Code: 0,
		}
		if out != nil {
			success.Data = out
		}
		if err := h.Encode(w, r, success); err != nil {
			h.Error(w, r, err)
		}
	}).Methods("GET")

	return r
}