ranker_http.pb.go

// Code generated by protoc-gen-go-server. DO NOT EDIT.
// See https://github.com/eolymp/contracts/tree/main/cmd/protoc-gen-go-server for more details.

package ranker

import (
	context "context"
	fmt "fmt"
	mux "github.com/gorilla/mux"
	websocket "golang.org/x/net/websocket"
	grpc "google.golang.org/grpc"
	codes "google.golang.org/grpc/codes"
	metadata "google.golang.org/grpc/metadata"
	status "google.golang.org/grpc/status"
	protojson "google.golang.org/protobuf/encoding/protojson"
	proto "google.golang.org/protobuf/proto"
	ioutil "io/ioutil"
	http "net/http"
)

// _Ranker_HTTPReadQueryString parses body into proto.Message
func _Ranker_HTTPReadQueryString(r *http.Request, v proto.Message) error {
	query := r.URL.Query().Get("q")
	if query == "" {
		return nil
	}

	if err := (protojson.UnmarshalOptions{DiscardUnknown: true}.Unmarshal([]byte(query), v)); err != nil {
		return err
	}

	return nil
}

// _Ranker_HTTPReadRequestBody parses body into proto.Message
func _Ranker_HTTPReadRequestBody(r *http.Request, v proto.Message) error {
	data, err := ioutil.ReadAll(r.Body)
	if err != nil {
		return err
	}

	if err := (protojson.UnmarshalOptions{DiscardUnknown: true}.Unmarshal(data, v)); err != nil {
		return err
	}

	return nil
}

// _Ranker_HTTPWriteResponse writes proto.Message to HTTP response
func _Ranker_HTTPWriteResponse(w http.ResponseWriter, v proto.Message, h, t metadata.MD) {
	data, err := protojson.Marshal(v)
	if err != nil {
		_Ranker_HTTPWriteErrorResponse(w, err)
		return
	}

	w.Header().Set("Content-Type", "application/json")

	if v := append(h.Get("cache-control"), t.Get("cache-control")...); len(v) > 0 {
		w.Header().Set("Cache-Control", v[len(v)-1])
	}

	if v := append(h.Get("etag"), t.Get("etag")...); len(v) > 0 {
		w.Header().Set("ETag", v[len(v)-1])
	}

	if v := append(h.Get("last-modified"), t.Get("last-modified")...); len(v) > 0 {
		w.Header().Set("Last-Modified", v[len(v)-1])
	}

	w.WriteHeader(http.StatusOK)

	_, _ = w.Write(data)
}

// _Ranker_HTTPWriteErrorResponse writes error to HTTP response with error status code
func _Ranker_HTTPWriteErrorResponse(w http.ResponseWriter, e error) {
	s := status.Convert(e)

	w.Header().Set("Content-Type", "application/json")

	switch s.Code() {
	case codes.OK:
		w.WriteHeader(http.StatusOK)
	case codes.Canceled:
		w.WriteHeader(http.StatusGatewayTimeout)
	case codes.Unknown:
		w.WriteHeader(http.StatusInternalServerError)
	case codes.InvalidArgument:
		w.WriteHeader(http.StatusBadRequest)
	case codes.DeadlineExceeded:
		w.WriteHeader(http.StatusGatewayTimeout)
	case codes.NotFound:
		w.WriteHeader(http.StatusNotFound)
	case codes.AlreadyExists:
		w.WriteHeader(http.StatusConflict)
	case codes.PermissionDenied:
		w.WriteHeader(http.StatusForbidden)
	case codes.ResourceExhausted:
		w.WriteHeader(http.StatusTooManyRequests)
	case codes.FailedPrecondition:
		w.WriteHeader(http.StatusPreconditionFailed)
	case codes.Aborted:
		w.WriteHeader(http.StatusServiceUnavailable)
	case codes.OutOfRange:
		w.WriteHeader(http.StatusRequestedRangeNotSatisfiable)
	case codes.Unimplemented:
		w.WriteHeader(http.StatusNotImplemented)
	case codes.Internal:
		w.WriteHeader(http.StatusInternalServerError)
	case codes.Unavailable:
		w.WriteHeader(http.StatusServiceUnavailable)
	case codes.DataLoss:
		w.WriteHeader(http.StatusInternalServerError)
	case codes.Unauthenticated:
		w.WriteHeader(http.StatusUnauthorized)
	default:
		w.WriteHeader(http.StatusInternalServerError)
	}

	data, err := protojson.Marshal(s.Proto())
	if err != nil {
		panic(err)
	}

	_, _ = w.Write(data)
}

// _Ranker_WebsocketErrorResponse writes error to websocket connection
func _Ranker_WebsocketErrorResponse(conn *websocket.Conn, e error) {
	switch status.Convert(e).Code() {
	case codes.OK:
		conn.WriteClose(1000)
	case codes.Canceled:
		conn.WriteClose(1000)
	case codes.Unknown:
		conn.WriteClose(1011)
	case codes.InvalidArgument:
		conn.WriteClose(1003)
	case codes.DeadlineExceeded:
		conn.WriteClose(1000)
	case codes.NotFound:
		conn.WriteClose(1000)
	case codes.AlreadyExists:
		conn.WriteClose(1000)
	case codes.PermissionDenied:
		conn.WriteClose(1000)
	case codes.ResourceExhausted:
		conn.WriteClose(1000)
	case codes.FailedPrecondition:
		conn.WriteClose(1000)
	case codes.Aborted:
		conn.WriteClose(1000)
	case codes.OutOfRange:
		conn.WriteClose(1000)
	case codes.Unimplemented:
		conn.WriteClose(1011)
	case codes.Internal:
		conn.WriteClose(1011)
	case codes.Unavailable:
		conn.WriteClose(1011)
	case codes.DataLoss:
		conn.WriteClose(1011)
	case codes.Unauthenticated:
		conn.WriteClose(1000)
	default:
		conn.WriteClose(1000)
	}
}

// _Ranker_WebsocketCodec implements protobuf codec for websockets package
var _Ranker_WebsocketCodec = websocket.Codec{
	Marshal: func(v interface{}) ([]byte, byte, error) {
		m, ok := v.(proto.Message)
		if !ok {
			panic(fmt.Errorf("invalid message type %T", v))
		}

		d, err := protojson.Marshal(m)
		if err != nil {
			return nil, 0, err
		}

		return d, websocket.TextFrame, err
	},
	Unmarshal: func(d []byte, t byte, v interface{}) error {
		m, ok := v.(proto.Message)
		if !ok {
			panic(fmt.Errorf("invalid message type %T", v))
		}

		return protojson.UnmarshalOptions{DiscardUnknown: true}.Unmarshal(d, m)
	},
}

// RegisterRankerHttpHandlers adds handlers for for RankerClient
// This constructor creates http.Handler, the actual implementation might change at any moment
func RegisterRankerHttpHandlers(router *mux.Router, prefix string, cli RankerClient) {
	router.Handle(prefix+"/scoreboards", _Ranker_CreateScoreboard_Rule0(cli)).
		Methods("POST").
		Name("eolymp.ranker.Ranker.CreateScoreboard")
	router.Handle(prefix+"/scoreboards/{scoreboard_id}", _Ranker_UpdateScoreboard_Rule0(cli)).
		Methods("PUT").
		Name("eolymp.ranker.Ranker.UpdateScoreboard")
	router.Handle(prefix+"/scoreboards/{scoreboard_id}/rebuild", _Ranker_RebuildScoreboard_Rule0(cli)).
		Methods("POST").
		Name("eolymp.ranker.Ranker.RebuildScoreboard")
	router.Handle(prefix+"/scoreboards/{scoreboard_id}", _Ranker_DeleteScoreboard_Rule0(cli)).
		Methods("DELETE").
		Name("eolymp.ranker.Ranker.DeleteScoreboard")
	router.Handle(prefix+"/scoreboards/{scoreboard_id}", _Ranker_DescribeScoreboard_Rule0(cli)).
		Methods("GET").
		Name("eolymp.ranker.Ranker.DescribeScoreboard")
	router.Handle(prefix+"/scoreboards", _Ranker_ListScoreboards_Rule0(cli)).
		Methods("GET").
		Name("eolymp.ranker.Ranker.ListScoreboards")
	router.Handle(prefix+"/scoreboards/{scoreboard_id}/rows/{member_id}", _Ranker_DescribeScoreboardRow_Rule0(cli)).
		Methods("GET").
		Name("eolymp.ranker.Ranker.DescribeScoreboardRow")
	router.Handle(prefix+"/scoreboards/{scoreboard_id}/rows", _Ranker_ListScoreboardRows_Rule0(cli)).
		Methods("GET").
		Name("eolymp.ranker.Ranker.ListScoreboardRows")
	router.Handle(prefix+"/scoreboards/{scoreboard_id}/columns", _Ranker_AddScoreboardColumn_Rule0(cli)).
		Methods("POST").
		Name("eolymp.ranker.Ranker.AddScoreboardColumn")
	router.Handle(prefix+"/scoreboards/{scoreboard_id}/columns/{column_id}", _Ranker_UpdateScoreboardColumn_Rule0(cli)).
		Methods("PUT").
		Name("eolymp.ranker.Ranker.UpdateScoreboardColumn")
	router.Handle(prefix+"/scoreboards/{scoreboard_id}/columns/{column_id}", _Ranker_DeleteScoreboardColumn_Rule0(cli)).
		Methods("DELETE").
		Name("eolymp.ranker.Ranker.DeleteScoreboardColumn")
	router.Handle(prefix+"/scoreboards/{scoreboard_id}/columns/{column_id}", _Ranker_DescribeScoreboardColumn_Rule0(cli)).
		Methods("GET").
		Name("eolymp.ranker.Ranker.DescribeScoreboardColumn")
	router.Handle(prefix+"/scoreboards/{scoreboard_id}/columns", _Ranker_ListScoreboardColumns_Rule0(cli)).
		Methods("GET").
		Name("eolymp.ranker.Ranker.ListScoreboardColumns")
	router.Handle(prefix+"/scoreboards/{scoreboard_id}/activities", _Ranker_ListActivities_Rule0(cli)).
		Methods("GET").
		Name("eolymp.ranker.Ranker.ListActivities")
	router.Handle(prefix+"/scoreboards/{scoreboard_id}/schedule", _Ranker_ScheduleAction_Rule0(cli)).
		Methods("POST").
		Name("eolymp.ranker.Ranker.ScheduleAction")
	router.Handle(prefix+"/scoreboards/{scoreboard_id}/schedule/{action_id}", _Ranker_UnscheduleAction_Rule0(cli)).
		Methods("DELETE").
		Name("eolymp.ranker.Ranker.UnscheduleAction")
	router.Handle(prefix+"/scoreboards/{scoreboard_id}/schedule", _Ranker_ListScheduledActions_Rule0(cli)).
		Methods("GET").
		Name("eolymp.ranker.Ranker.ListScheduledActions")
}

func _Ranker_CreateScoreboard_Rule0(cli RankerClient) http.Handler {
	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		in := &CreateScoreboardInput{}

		if err := _Ranker_HTTPReadRequestBody(r, in); err != nil {
			err = status.Error(codes.InvalidArgument, err.Error())
			_Ranker_HTTPWriteErrorResponse(w, err)
			return
		}

		var header, trailer metadata.MD

		out, err := cli.CreateScoreboard(r.Context(), in, grpc.Header(&header), grpc.Trailer(&trailer))
		if err != nil {
			_Ranker_HTTPWriteErrorResponse(w, err)
			return
		}

		_Ranker_HTTPWriteResponse(w, out, header, trailer)
	})
}

func _Ranker_UpdateScoreboard_Rule0(cli RankerClient) http.Handler {
	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		in := &UpdateScoreboardInput{}

		if err := _Ranker_HTTPReadRequestBody(r, in); err != nil {
			err = status.Error(codes.InvalidArgument, err.Error())
			_Ranker_HTTPWriteErrorResponse(w, err)
			return
		}

		vars := mux.Vars(r)
		in.ScoreboardId = vars["scoreboard_id"]

		var header, trailer metadata.MD

		out, err := cli.UpdateScoreboard(r.Context(), in, grpc.Header(&header), grpc.Trailer(&trailer))
		if err != nil {
			_Ranker_HTTPWriteErrorResponse(w, err)
			return
		}

		_Ranker_HTTPWriteResponse(w, out, header, trailer)
	})
}

func _Ranker_RebuildScoreboard_Rule0(cli RankerClient) http.Handler {
	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		in := &RebuildScoreboardInput{}

		if err := _Ranker_HTTPReadRequestBody(r, in); err != nil {
			err = status.Error(codes.InvalidArgument, err.Error())
			_Ranker_HTTPWriteErrorResponse(w, err)
			return
		}

		vars := mux.Vars(r)
		in.ScoreboardId = vars["scoreboard_id"]

		var header, trailer metadata.MD

		out, err := cli.RebuildScoreboard(r.Context(), in, grpc.Header(&header), grpc.Trailer(&trailer))
		if err != nil {
			_Ranker_HTTPWriteErrorResponse(w, err)
			return
		}

		_Ranker_HTTPWriteResponse(w, out, header, trailer)
	})
}

func _Ranker_DeleteScoreboard_Rule0(cli RankerClient) http.Handler {
	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		in := &DeleteScoreboardInput{}

		if err := _Ranker_HTTPReadRequestBody(r, in); err != nil {
			err = status.Error(codes.InvalidArgument, err.Error())
			_Ranker_HTTPWriteErrorResponse(w, err)
			return
		}

		vars := mux.Vars(r)
		in.ScoreboardId = vars["scoreboard_id"]

		var header, trailer metadata.MD

		out, err := cli.DeleteScoreboard(r.Context(), in, grpc.Header(&header), grpc.Trailer(&trailer))
		if err != nil {
			_Ranker_HTTPWriteErrorResponse(w, err)
			return
		}

		_Ranker_HTTPWriteResponse(w, out, header, trailer)
	})
}

func _Ranker_DescribeScoreboard_Rule0(cli RankerClient) http.Handler {
	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		in := &DescribeScoreboardInput{}

		if err := _Ranker_HTTPReadQueryString(r, in); err != nil {
			err = status.Error(codes.InvalidArgument, err.Error())
			_Ranker_HTTPWriteErrorResponse(w, err)
			return
		}

		vars := mux.Vars(r)
		in.ScoreboardId = vars["scoreboard_id"]

		var header, trailer metadata.MD

		out, err := cli.DescribeScoreboard(r.Context(), in, grpc.Header(&header), grpc.Trailer(&trailer))
		if err != nil {
			_Ranker_HTTPWriteErrorResponse(w, err)
			return
		}

		_Ranker_HTTPWriteResponse(w, out, header, trailer)
	})
}

func _Ranker_ListScoreboards_Rule0(cli RankerClient) http.Handler {
	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		in := &ListScoreboardsInput{}

		if err := _Ranker_HTTPReadQueryString(r, in); err != nil {
			err = status.Error(codes.InvalidArgument, err.Error())
			_Ranker_HTTPWriteErrorResponse(w, err)
			return
		}

		var header, trailer metadata.MD

		out, err := cli.ListScoreboards(r.Context(), in, grpc.Header(&header), grpc.Trailer(&trailer))
		if err != nil {
			_Ranker_HTTPWriteErrorResponse(w, err)
			return
		}

		_Ranker_HTTPWriteResponse(w, out, header, trailer)
	})
}

func _Ranker_DescribeScoreboardRow_Rule0(cli RankerClient) http.Handler {
	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		in := &DescribeScoreboardRowInput{}

		if err := _Ranker_HTTPReadQueryString(r, in); err != nil {
			err = status.Error(codes.InvalidArgument, err.Error())
			_Ranker_HTTPWriteErrorResponse(w, err)
			return
		}

		vars := mux.Vars(r)
		in.ScoreboardId = vars["scoreboard_id"]
		in.MemberId = vars["member_id"]

		var header, trailer metadata.MD

		out, err := cli.DescribeScoreboardRow(r.Context(), in, grpc.Header(&header), grpc.Trailer(&trailer))
		if err != nil {
			_Ranker_HTTPWriteErrorResponse(w, err)
			return
		}

		_Ranker_HTTPWriteResponse(w, out, header, trailer)
	})
}

func _Ranker_ListScoreboardRows_Rule0(cli RankerClient) http.Handler {
	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		in := &ListScoreboardRowsInput{}

		if err := _Ranker_HTTPReadQueryString(r, in); err != nil {
			err = status.Error(codes.InvalidArgument, err.Error())
			_Ranker_HTTPWriteErrorResponse(w, err)
			return
		}

		vars := mux.Vars(r)
		in.ScoreboardId = vars["scoreboard_id"]

		var header, trailer metadata.MD

		out, err := cli.ListScoreboardRows(r.Context(), in, grpc.Header(&header), grpc.Trailer(&trailer))
		if err != nil {
			_Ranker_HTTPWriteErrorResponse(w, err)
			return
		}

		_Ranker_HTTPWriteResponse(w, out, header, trailer)
	})
}

func _Ranker_AddScoreboardColumn_Rule0(cli RankerClient) http.Handler {
	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		in := &AddScoreboardColumnInput{}

		if err := _Ranker_HTTPReadRequestBody(r, in); err != nil {
			err = status.Error(codes.InvalidArgument, err.Error())
			_Ranker_HTTPWriteErrorResponse(w, err)
			return
		}

		vars := mux.Vars(r)
		in.ScoreboardId = vars["scoreboard_id"]

		var header, trailer metadata.MD

		out, err := cli.AddScoreboardColumn(r.Context(), in, grpc.Header(&header), grpc.Trailer(&trailer))
		if err != nil {
			_Ranker_HTTPWriteErrorResponse(w, err)
			return
		}

		_Ranker_HTTPWriteResponse(w, out, header, trailer)
	})
}

func _Ranker_UpdateScoreboardColumn_Rule0(cli RankerClient) http.Handler {
	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		in := &UpdateScoreboardColumnInput{}

		if err := _Ranker_HTTPReadRequestBody(r, in); err != nil {
			err = status.Error(codes.InvalidArgument, err.Error())
			_Ranker_HTTPWriteErrorResponse(w, err)
			return
		}

		vars := mux.Vars(r)
		in.ScoreboardId = vars["scoreboard_id"]
		in.ColumnId = vars["column_id"]

		var header, trailer metadata.MD

		out, err := cli.UpdateScoreboardColumn(r.Context(), in, grpc.Header(&header), grpc.Trailer(&trailer))
		if err != nil {
			_Ranker_HTTPWriteErrorResponse(w, err)
			return
		}

		_Ranker_HTTPWriteResponse(w, out, header, trailer)
	})
}

func _Ranker_DeleteScoreboardColumn_Rule0(cli RankerClient) http.Handler {
	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		in := &DeleteScoreboardColumnInput{}

		if err := _Ranker_HTTPReadRequestBody(r, in); err != nil {
			err = status.Error(codes.InvalidArgument, err.Error())
			_Ranker_HTTPWriteErrorResponse(w, err)
			return
		}

		vars := mux.Vars(r)
		in.ScoreboardId = vars["scoreboard_id"]
		in.ColumnId = vars["column_id"]

		var header, trailer metadata.MD

		out, err := cli.DeleteScoreboardColumn(r.Context(), in, grpc.Header(&header), grpc.Trailer(&trailer))
		if err != nil {
			_Ranker_HTTPWriteErrorResponse(w, err)
			return
		}

		_Ranker_HTTPWriteResponse(w, out, header, trailer)
	})
}

func _Ranker_DescribeScoreboardColumn_Rule0(cli RankerClient) http.Handler {
	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		in := &DescribeScoreboardColumnInput{}

		if err := _Ranker_HTTPReadQueryString(r, in); err != nil {
			err = status.Error(codes.InvalidArgument, err.Error())
			_Ranker_HTTPWriteErrorResponse(w, err)
			return
		}

		vars := mux.Vars(r)
		in.ScoreboardId = vars["scoreboard_id"]
		in.ColumnId = vars["column_id"]

		var header, trailer metadata.MD

		out, err := cli.DescribeScoreboardColumn(r.Context(), in, grpc.Header(&header), grpc.Trailer(&trailer))
		if err != nil {
			_Ranker_HTTPWriteErrorResponse(w, err)
			return
		}

		_Ranker_HTTPWriteResponse(w, out, header, trailer)
	})
}

func _Ranker_ListScoreboardColumns_Rule0(cli RankerClient) http.Handler {
	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		in := &ListScoreboardColumnsInput{}

		if err := _Ranker_HTTPReadQueryString(r, in); err != nil {
			err = status.Error(codes.InvalidArgument, err.Error())
			_Ranker_HTTPWriteErrorResponse(w, err)
			return
		}

		vars := mux.Vars(r)
		in.ScoreboardId = vars["scoreboard_id"]

		var header, trailer metadata.MD

		out, err := cli.ListScoreboardColumns(r.Context(), in, grpc.Header(&header), grpc.Trailer(&trailer))
		if err != nil {
			_Ranker_HTTPWriteErrorResponse(w, err)
			return
		}

		_Ranker_HTTPWriteResponse(w, out, header, trailer)
	})
}

func _Ranker_ListActivities_Rule0(cli RankerClient) http.Handler {
	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		in := &ListActivitiesInput{}

		if err := _Ranker_HTTPReadQueryString(r, in); err != nil {
			err = status.Error(codes.InvalidArgument, err.Error())
			_Ranker_HTTPWriteErrorResponse(w, err)
			return
		}

		vars := mux.Vars(r)
		in.ScoreboardId = vars["scoreboard_id"]

		var header, trailer metadata.MD

		out, err := cli.ListActivities(r.Context(), in, grpc.Header(&header), grpc.Trailer(&trailer))
		if err != nil {
			_Ranker_HTTPWriteErrorResponse(w, err)
			return
		}

		_Ranker_HTTPWriteResponse(w, out, header, trailer)
	})
}

func _Ranker_ScheduleAction_Rule0(cli RankerClient) http.Handler {
	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		in := &ScheduleActionInput{}

		if err := _Ranker_HTTPReadRequestBody(r, in); err != nil {
			err = status.Error(codes.InvalidArgument, err.Error())
			_Ranker_HTTPWriteErrorResponse(w, err)
			return
		}

		vars := mux.Vars(r)
		in.ScoreboardId = vars["scoreboard_id"]

		var header, trailer metadata.MD

		out, err := cli.ScheduleAction(r.Context(), in, grpc.Header(&header), grpc.Trailer(&trailer))
		if err != nil {
			_Ranker_HTTPWriteErrorResponse(w, err)
			return
		}

		_Ranker_HTTPWriteResponse(w, out, header, trailer)
	})
}

func _Ranker_UnscheduleAction_Rule0(cli RankerClient) http.Handler {
	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		in := &UnscheduleActionInput{}

		if err := _Ranker_HTTPReadRequestBody(r, in); err != nil {
			err = status.Error(codes.InvalidArgument, err.Error())
			_Ranker_HTTPWriteErrorResponse(w, err)
			return
		}

		vars := mux.Vars(r)
		in.ScoreboardId = vars["scoreboard_id"]
		in.ActionId = vars["action_id"]

		var header, trailer metadata.MD

		out, err := cli.UnscheduleAction(r.Context(), in, grpc.Header(&header), grpc.Trailer(&trailer))
		if err != nil {
			_Ranker_HTTPWriteErrorResponse(w, err)
			return
		}

		_Ranker_HTTPWriteResponse(w, out, header, trailer)
	})
}

func _Ranker_ListScheduledActions_Rule0(cli RankerClient) http.Handler {
	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		in := &ListScheduledActionsInput{}

		if err := _Ranker_HTTPReadQueryString(r, in); err != nil {
			err = status.Error(codes.InvalidArgument, err.Error())
			_Ranker_HTTPWriteErrorResponse(w, err)
			return
		}

		vars := mux.Vars(r)
		in.ScoreboardId = vars["scoreboard_id"]

		var header, trailer metadata.MD

		out, err := cli.ListScheduledActions(r.Context(), in, grpc.Header(&header), grpc.Trailer(&trailer))
		if err != nil {
			_Ranker_HTTPWriteErrorResponse(w, err)
			return
		}

		_Ranker_HTTPWriteResponse(w, out, header, trailer)
	})
}

type _RankerHandler = func(ctx context.Context, in proto.Message) (proto.Message, error)
type _RankerMiddleware = func(ctx context.Context, method string, in proto.Message, handler _RankerHandler) (out proto.Message, err error)
type RankerInterceptor struct {
	middleware []_RankerMiddleware
	client     RankerClient
}

// NewRankerInterceptor constructs additional middleware for a server based on annotations in proto files
func NewRankerInterceptor(cli RankerClient, middleware ..._RankerMiddleware) *RankerInterceptor {
	return &RankerInterceptor{client: cli, middleware: middleware}
}

func (i *RankerInterceptor) CreateScoreboard(ctx context.Context, in *CreateScoreboardInput, opts ...grpc.CallOption) (*CreateScoreboardOutput, error) {
	handler := func(ctx context.Context, in proto.Message) (proto.Message, error) {
		message, ok := in.(*CreateScoreboardInput)
		if !ok && in != nil {
			panic(fmt.Errorf("request input type is invalid: want *CreateScoreboardInput, got %T", in))
		}

		return i.client.CreateScoreboard(ctx, message, opts...)
	}

	for _, mw := range i.middleware {
		mw := mw
		next := handler

		handler = func(ctx context.Context, in proto.Message) (proto.Message, error) {
			return mw(ctx, "eolymp.ranker.Ranker.CreateScoreboard", in, next)
		}
	}

	out, err := handler(ctx, in)
	if err != nil {
		return nil, err
	}

	message, ok := out.(*CreateScoreboardOutput)
	if !ok && out != nil {
		panic(fmt.Errorf("output type is invalid: want *CreateScoreboardOutput, got %T", out))
	}

	return message, err
}

func (i *RankerInterceptor) UpdateScoreboard(ctx context.Context, in *UpdateScoreboardInput, opts ...grpc.CallOption) (*UpdateScoreboardOutput, error) {
	handler := func(ctx context.Context, in proto.Message) (proto.Message, error) {
		message, ok := in.(*UpdateScoreboardInput)
		if !ok && in != nil {
			panic(fmt.Errorf("request input type is invalid: want *UpdateScoreboardInput, got %T", in))
		}

		return i.client.UpdateScoreboard(ctx, message, opts...)
	}

	for _, mw := range i.middleware {
		mw := mw
		next := handler

		handler = func(ctx context.Context, in proto.Message) (proto.Message, error) {
			return mw(ctx, "eolymp.ranker.Ranker.UpdateScoreboard", in, next)
		}
	}

	out, err := handler(ctx, in)
	if err != nil {
		return nil, err
	}

	message, ok := out.(*UpdateScoreboardOutput)
	if !ok && out != nil {
		panic(fmt.Errorf("output type is invalid: want *UpdateScoreboardOutput, got %T", out))
	}

	return message, err
}

func (i *RankerInterceptor) RebuildScoreboard(ctx context.Context, in *RebuildScoreboardInput, opts ...grpc.CallOption) (*RebuildScoreboardOutput, error) {
	handler := func(ctx context.Context, in proto.Message) (proto.Message, error) {
		message, ok := in.(*RebuildScoreboardInput)
		if !ok && in != nil {
			panic(fmt.Errorf("request input type is invalid: want *RebuildScoreboardInput, got %T", in))
		}

		return i.client.RebuildScoreboard(ctx, message, opts...)
	}

	for _, mw := range i.middleware {
		mw := mw
		next := handler

		handler = func(ctx context.Context, in proto.Message) (proto.Message, error) {
			return mw(ctx, "eolymp.ranker.Ranker.RebuildScoreboard", in, next)
		}
	}

	out, err := handler(ctx, in)
	if err != nil {
		return nil, err
	}

	message, ok := out.(*RebuildScoreboardOutput)
	if !ok && out != nil {
		panic(fmt.Errorf("output type is invalid: want *RebuildScoreboardOutput, got %T", out))
	}

	return message, err
}

func (i *RankerInterceptor) DeleteScoreboard(ctx context.Context, in *DeleteScoreboardInput, opts ...grpc.CallOption) (*DeleteScoreboardOutput, error) {
	handler := func(ctx context.Context, in proto.Message) (proto.Message, error) {
		message, ok := in.(*DeleteScoreboardInput)
		if !ok && in != nil {
			panic(fmt.Errorf("request input type is invalid: want *DeleteScoreboardInput, got %T", in))
		}

		return i.client.DeleteScoreboard(ctx, message, opts...)
	}

	for _, mw := range i.middleware {
		mw := mw
		next := handler

		handler = func(ctx context.Context, in proto.Message) (proto.Message, error) {
			return mw(ctx, "eolymp.ranker.Ranker.DeleteScoreboard", in, next)
		}
	}

	out, err := handler(ctx, in)
	if err != nil {
		return nil, err
	}

	message, ok := out.(*DeleteScoreboardOutput)
	if !ok && out != nil {
		panic(fmt.Errorf("output type is invalid: want *DeleteScoreboardOutput, got %T", out))
	}

	return message, err
}

func (i *RankerInterceptor) DescribeScoreboard(ctx context.Context, in *DescribeScoreboardInput, opts ...grpc.CallOption) (*DescribeScoreboardOutput, error) {
	handler := func(ctx context.Context, in proto.Message) (proto.Message, error) {
		message, ok := in.(*DescribeScoreboardInput)
		if !ok && in != nil {
			panic(fmt.Errorf("request input type is invalid: want *DescribeScoreboardInput, got %T", in))
		}

		return i.client.DescribeScoreboard(ctx, message, opts...)
	}

	for _, mw := range i.middleware {
		mw := mw
		next := handler

		handler = func(ctx context.Context, in proto.Message) (proto.Message, error) {
			return mw(ctx, "eolymp.ranker.Ranker.DescribeScoreboard", in, next)
		}
	}

	out, err := handler(ctx, in)
	if err != nil {
		return nil, err
	}

	message, ok := out.(*DescribeScoreboardOutput)
	if !ok && out != nil {
		panic(fmt.Errorf("output type is invalid: want *DescribeScoreboardOutput, got %T", out))
	}

	return message, err
}

func (i *RankerInterceptor) ListScoreboards(ctx context.Context, in *ListScoreboardsInput, opts ...grpc.CallOption) (*ListScoreboardsOutput, error) {
	handler := func(ctx context.Context, in proto.Message) (proto.Message, error) {
		message, ok := in.(*ListScoreboardsInput)
		if !ok && in != nil {
			panic(fmt.Errorf("request input type is invalid: want *ListScoreboardsInput, got %T", in))
		}

		return i.client.ListScoreboards(ctx, message, opts...)
	}

	for _, mw := range i.middleware {
		mw := mw
		next := handler

		handler = func(ctx context.Context, in proto.Message) (proto.Message, error) {
			return mw(ctx, "eolymp.ranker.Ranker.ListScoreboards", in, next)
		}
	}

	out, err := handler(ctx, in)
	if err != nil {
		return nil, err
	}

	message, ok := out.(*ListScoreboardsOutput)
	if !ok && out != nil {
		panic(fmt.Errorf("output type is invalid: want *ListScoreboardsOutput, got %T", out))
	}

	return message, err
}

func (i *RankerInterceptor) DescribeScoreboardRow(ctx context.Context, in *DescribeScoreboardRowInput, opts ...grpc.CallOption) (*DescribeScoreboardRowOutput, error) {
	handler := func(ctx context.Context, in proto.Message) (proto.Message, error) {
		message, ok := in.(*DescribeScoreboardRowInput)
		if !ok && in != nil {
			panic(fmt.Errorf("request input type is invalid: want *DescribeScoreboardRowInput, got %T", in))
		}

		return i.client.DescribeScoreboardRow(ctx, message, opts...)
	}

	for _, mw := range i.middleware {
		mw := mw
		next := handler

		handler = func(ctx context.Context, in proto.Message) (proto.Message, error) {
			return mw(ctx, "eolymp.ranker.Ranker.DescribeScoreboardRow", in, next)
		}
	}

	out, err := handler(ctx, in)
	if err != nil {
		return nil, err
	}

	message, ok := out.(*DescribeScoreboardRowOutput)
	if !ok && out != nil {
		panic(fmt.Errorf("output type is invalid: want *DescribeScoreboardRowOutput, got %T", out))
	}

	return message, err
}

func (i *RankerInterceptor) ListScoreboardRows(ctx context.Context, in *ListScoreboardRowsInput, opts ...grpc.CallOption) (*ListScoreboardRowsOutput, error) {
	handler := func(ctx context.Context, in proto.Message) (proto.Message, error) {
		message, ok := in.(*ListScoreboardRowsInput)
		if !ok && in != nil {
			panic(fmt.Errorf("request input type is invalid: want *ListScoreboardRowsInput, got %T", in))
		}

		return i.client.ListScoreboardRows(ctx, message, opts...)
	}

	for _, mw := range i.middleware {
		mw := mw
		next := handler

		handler = func(ctx context.Context, in proto.Message) (proto.Message, error) {
			return mw(ctx, "eolymp.ranker.Ranker.ListScoreboardRows", in, next)
		}
	}

	out, err := handler(ctx, in)
	if err != nil {
		return nil, err
	}

	message, ok := out.(*ListScoreboardRowsOutput)
	if !ok && out != nil {
		panic(fmt.Errorf("output type is invalid: want *ListScoreboardRowsOutput, got %T", out))
	}

	return message, err
}

func (i *RankerInterceptor) AddScoreboardColumn(ctx context.Context, in *AddScoreboardColumnInput, opts ...grpc.CallOption) (*AddScoreboardColumnOutput, error) {
	handler := func(ctx context.Context, in proto.Message) (proto.Message, error) {
		message, ok := in.(*AddScoreboardColumnInput)
		if !ok && in != nil {
			panic(fmt.Errorf("request input type is invalid: want *AddScoreboardColumnInput, got %T", in))
		}

		return i.client.AddScoreboardColumn(ctx, message, opts...)
	}

	for _, mw := range i.middleware {
		mw := mw
		next := handler

		handler = func(ctx context.Context, in proto.Message) (proto.Message, error) {
			return mw(ctx, "eolymp.ranker.Ranker.AddScoreboardColumn", in, next)
		}
	}

	out, err := handler(ctx, in)
	if err != nil {
		return nil, err
	}

	message, ok := out.(*AddScoreboardColumnOutput)
	if !ok && out != nil {
		panic(fmt.Errorf("output type is invalid: want *AddScoreboardColumnOutput, got %T", out))
	}

	return message, err
}

func (i *RankerInterceptor) UpdateScoreboardColumn(ctx context.Context, in *UpdateScoreboardColumnInput, opts ...grpc.CallOption) (*UpdateScoreboardColumnOutput, error) {
	handler := func(ctx context.Context, in proto.Message) (proto.Message, error) {
		message, ok := in.(*UpdateScoreboardColumnInput)
		if !ok && in != nil {
			panic(fmt.Errorf("request input type is invalid: want *UpdateScoreboardColumnInput, got %T", in))
		}

		return i.client.UpdateScoreboardColumn(ctx, message, opts...)
	}

	for _, mw := range i.middleware {
		mw := mw
		next := handler

		handler = func(ctx context.Context, in proto.Message) (proto.Message, error) {
			return mw(ctx, "eolymp.ranker.Ranker.UpdateScoreboardColumn", in, next)
		}
	}

	out, err := handler(ctx, in)
	if err != nil {
		return nil, err
	}

	message, ok := out.(*UpdateScoreboardColumnOutput)
	if !ok && out != nil {
		panic(fmt.Errorf("output type is invalid: want *UpdateScoreboardColumnOutput, got %T", out))
	}

	return message, err
}

func (i *RankerInterceptor) DeleteScoreboardColumn(ctx context.Context, in *DeleteScoreboardColumnInput, opts ...grpc.CallOption) (*DeleteScoreboardColumnOutput, error) {
	handler := func(ctx context.Context, in proto.Message) (proto.Message, error) {
		message, ok := in.(*DeleteScoreboardColumnInput)
		if !ok && in != nil {
			panic(fmt.Errorf("request input type is invalid: want *DeleteScoreboardColumnInput, got %T", in))
		}

		return i.client.DeleteScoreboardColumn(ctx, message, opts...)
	}

	for _, mw := range i.middleware {
		mw := mw
		next := handler

		handler = func(ctx context.Context, in proto.Message) (proto.Message, error) {
			return mw(ctx, "eolymp.ranker.Ranker.DeleteScoreboardColumn", in, next)
		}
	}

	out, err := handler(ctx, in)
	if err != nil {
		return nil, err
	}

	message, ok := out.(*DeleteScoreboardColumnOutput)
	if !ok && out != nil {
		panic(fmt.Errorf("output type is invalid: want *DeleteScoreboardColumnOutput, got %T", out))
	}

	return message, err
}

func (i *RankerInterceptor) DescribeScoreboardColumn(ctx context.Context, in *DescribeScoreboardColumnInput, opts ...grpc.CallOption) (*DescribeScoreboardColumnOutput, error) {
	handler := func(ctx context.Context, in proto.Message) (proto.Message, error) {
		message, ok := in.(*DescribeScoreboardColumnInput)
		if !ok && in != nil {
			panic(fmt.Errorf("request input type is invalid: want *DescribeScoreboardColumnInput, got %T", in))
		}

		return i.client.DescribeScoreboardColumn(ctx, message, opts...)
	}

	for _, mw := range i.middleware {
		mw := mw
		next := handler

		handler = func(ctx context.Context, in proto.Message) (proto.Message, error) {
			return mw(ctx, "eolymp.ranker.Ranker.DescribeScoreboardColumn", in, next)
		}
	}

	out, err := handler(ctx, in)
	if err != nil {
		return nil, err
	}

	message, ok := out.(*DescribeScoreboardColumnOutput)
	if !ok && out != nil {
		panic(fmt.Errorf("output type is invalid: want *DescribeScoreboardColumnOutput, got %T", out))
	}

	return message, err
}

func (i *RankerInterceptor) ListScoreboardColumns(ctx context.Context, in *ListScoreboardColumnsInput, opts ...grpc.CallOption) (*ListScoreboardColumnsOutput, error) {
	handler := func(ctx context.Context, in proto.Message) (proto.Message, error) {
		message, ok := in.(*ListScoreboardColumnsInput)
		if !ok && in != nil {
			panic(fmt.Errorf("request input type is invalid: want *ListScoreboardColumnsInput, got %T", in))
		}

		return i.client.ListScoreboardColumns(ctx, message, opts...)
	}

	for _, mw := range i.middleware {
		mw := mw
		next := handler

		handler = func(ctx context.Context, in proto.Message) (proto.Message, error) {
			return mw(ctx, "eolymp.ranker.Ranker.ListScoreboardColumns", in, next)
		}
	}

	out, err := handler(ctx, in)
	if err != nil {
		return nil, err
	}

	message, ok := out.(*ListScoreboardColumnsOutput)
	if !ok && out != nil {
		panic(fmt.Errorf("output type is invalid: want *ListScoreboardColumnsOutput, got %T", out))
	}

	return message, err
}

func (i *RankerInterceptor) ListActivities(ctx context.Context, in *ListActivitiesInput, opts ...grpc.CallOption) (*ListActivitiesOutput, error) {
	handler := func(ctx context.Context, in proto.Message) (proto.Message, error) {
		message, ok := in.(*ListActivitiesInput)
		if !ok && in != nil {
			panic(fmt.Errorf("request input type is invalid: want *ListActivitiesInput, got %T", in))
		}

		return i.client.ListActivities(ctx, message, opts...)
	}

	for _, mw := range i.middleware {
		mw := mw
		next := handler

		handler = func(ctx context.Context, in proto.Message) (proto.Message, error) {
			return mw(ctx, "eolymp.ranker.Ranker.ListActivities", in, next)
		}
	}

	out, err := handler(ctx, in)
	if err != nil {
		return nil, err
	}

	message, ok := out.(*ListActivitiesOutput)
	if !ok && out != nil {
		panic(fmt.Errorf("output type is invalid: want *ListActivitiesOutput, got %T", out))
	}

	return message, err
}

func (i *RankerInterceptor) ScheduleAction(ctx context.Context, in *ScheduleActionInput, opts ...grpc.CallOption) (*ScheduleActionOutput, error) {
	handler := func(ctx context.Context, in proto.Message) (proto.Message, error) {
		message, ok := in.(*ScheduleActionInput)
		if !ok && in != nil {
			panic(fmt.Errorf("request input type is invalid: want *ScheduleActionInput, got %T", in))
		}

		return i.client.ScheduleAction(ctx, message, opts...)
	}

	for _, mw := range i.middleware {
		mw := mw
		next := handler

		handler = func(ctx context.Context, in proto.Message) (proto.Message, error) {
			return mw(ctx, "eolymp.ranker.Ranker.ScheduleAction", in, next)
		}
	}

	out, err := handler(ctx, in)
	if err != nil {
		return nil, err
	}

	message, ok := out.(*ScheduleActionOutput)
	if !ok && out != nil {
		panic(fmt.Errorf("output type is invalid: want *ScheduleActionOutput, got %T", out))
	}

	return message, err
}

func (i *RankerInterceptor) UnscheduleAction(ctx context.Context, in *UnscheduleActionInput, opts ...grpc.CallOption) (*UnscheduleActionOutput, error) {
	handler := func(ctx context.Context, in proto.Message) (proto.Message, error) {
		message, ok := in.(*UnscheduleActionInput)
		if !ok && in != nil {
			panic(fmt.Errorf("request input type is invalid: want *UnscheduleActionInput, got %T", in))
		}

		return i.client.UnscheduleAction(ctx, message, opts...)
	}

	for _, mw := range i.middleware {
		mw := mw
		next := handler

		handler = func(ctx context.Context, in proto.Message) (proto.Message, error) {
			return mw(ctx, "eolymp.ranker.Ranker.UnscheduleAction", in, next)
		}
	}

	out, err := handler(ctx, in)
	if err != nil {
		return nil, err
	}

	message, ok := out.(*UnscheduleActionOutput)
	if !ok && out != nil {
		panic(fmt.Errorf("output type is invalid: want *UnscheduleActionOutput, got %T", out))
	}

	return message, err
}

func (i *RankerInterceptor) ListScheduledActions(ctx context.Context, in *ListScheduledActionsInput, opts ...grpc.CallOption) (*ListScheduledActionsOutput, error) {
	handler := func(ctx context.Context, in proto.Message) (proto.Message, error) {
		message, ok := in.(*ListScheduledActionsInput)
		if !ok && in != nil {
			panic(fmt.Errorf("request input type is invalid: want *ListScheduledActionsInput, got %T", in))
		}

		return i.client.ListScheduledActions(ctx, message, opts...)
	}

	for _, mw := range i.middleware {
		mw := mw
		next := handler

		handler = func(ctx context.Context, in proto.Message) (proto.Message, error) {
			return mw(ctx, "eolymp.ranker.Ranker.ListScheduledActions", in, next)
		}
	}

	out, err := handler(ctx, in)
	if err != nil {
		return nil, err
	}

	message, ok := out.(*ListScheduledActionsOutput)
	if !ok && out != nil {
		panic(fmt.Errorf("output type is invalid: want *ListScheduledActionsOutput, got %T", out))
	}

	return message, err
}