mirror of
https://github.com/langhuihui/monibuca.git
synced 2025-09-27 01:15:52 +08:00
5871 lines
298 KiB
Go
5871 lines
298 KiB
Go
// Code generated by protoc-gen-grpc-gateway. DO NOT EDIT.
|
|
// source: gb28181.proto
|
|
|
|
/*
|
|
Package pb is a reverse proxy.
|
|
|
|
It translates gRPC into RESTful JSON APIs.
|
|
*/
|
|
package pb
|
|
|
|
import (
|
|
"context"
|
|
"errors"
|
|
"io"
|
|
"net/http"
|
|
|
|
"github.com/grpc-ecosystem/grpc-gateway/v2/runtime"
|
|
"github.com/grpc-ecosystem/grpc-gateway/v2/utilities"
|
|
"google.golang.org/grpc"
|
|
"google.golang.org/grpc/codes"
|
|
"google.golang.org/grpc/grpclog"
|
|
"google.golang.org/grpc/metadata"
|
|
"google.golang.org/grpc/status"
|
|
"google.golang.org/protobuf/proto"
|
|
"google.golang.org/protobuf/types/known/emptypb"
|
|
)
|
|
|
|
// Suppress "imported and not used" errors
|
|
var (
|
|
_ codes.Code
|
|
_ io.Reader
|
|
_ status.Status
|
|
_ = errors.New
|
|
_ = runtime.String
|
|
_ = utilities.NewDoubleArray
|
|
_ = metadata.Join
|
|
)
|
|
|
|
var filter_Api_List_0 = &utilities.DoubleArray{Encoding: map[string]int{}, Base: []int(nil), Check: []int(nil)}
|
|
|
|
func request_Api_List_0(ctx context.Context, marshaler runtime.Marshaler, client ApiClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
|
|
var (
|
|
protoReq GetDevicesRequest
|
|
metadata runtime.ServerMetadata
|
|
)
|
|
io.Copy(io.Discard, req.Body)
|
|
if err := req.ParseForm(); err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
|
|
}
|
|
if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Api_List_0); err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
|
|
}
|
|
msg, err := client.List(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
|
|
return msg, metadata, err
|
|
}
|
|
|
|
func local_request_Api_List_0(ctx context.Context, marshaler runtime.Marshaler, server ApiServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
|
|
var (
|
|
protoReq GetDevicesRequest
|
|
metadata runtime.ServerMetadata
|
|
)
|
|
if err := req.ParseForm(); err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
|
|
}
|
|
if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Api_List_0); err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
|
|
}
|
|
msg, err := server.List(ctx, &protoReq)
|
|
return msg, metadata, err
|
|
}
|
|
|
|
func request_Api_GetDevice_0(ctx context.Context, marshaler runtime.Marshaler, client ApiClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
|
|
var (
|
|
protoReq GetDeviceRequest
|
|
metadata runtime.ServerMetadata
|
|
err error
|
|
)
|
|
io.Copy(io.Discard, req.Body)
|
|
val, ok := pathParams["deviceId"]
|
|
if !ok {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "deviceId")
|
|
}
|
|
protoReq.DeviceId, err = runtime.String(val)
|
|
if err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "deviceId", err)
|
|
}
|
|
msg, err := client.GetDevice(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
|
|
return msg, metadata, err
|
|
}
|
|
|
|
func local_request_Api_GetDevice_0(ctx context.Context, marshaler runtime.Marshaler, server ApiServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
|
|
var (
|
|
protoReq GetDeviceRequest
|
|
metadata runtime.ServerMetadata
|
|
err error
|
|
)
|
|
val, ok := pathParams["deviceId"]
|
|
if !ok {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "deviceId")
|
|
}
|
|
protoReq.DeviceId, err = runtime.String(val)
|
|
if err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "deviceId", err)
|
|
}
|
|
msg, err := server.GetDevice(ctx, &protoReq)
|
|
return msg, metadata, err
|
|
}
|
|
|
|
var filter_Api_GetDevices_0 = &utilities.DoubleArray{Encoding: map[string]int{}, Base: []int(nil), Check: []int(nil)}
|
|
|
|
func request_Api_GetDevices_0(ctx context.Context, marshaler runtime.Marshaler, client ApiClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
|
|
var (
|
|
protoReq GetDevicesRequest
|
|
metadata runtime.ServerMetadata
|
|
)
|
|
io.Copy(io.Discard, req.Body)
|
|
if err := req.ParseForm(); err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
|
|
}
|
|
if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Api_GetDevices_0); err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
|
|
}
|
|
msg, err := client.GetDevices(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
|
|
return msg, metadata, err
|
|
}
|
|
|
|
func local_request_Api_GetDevices_0(ctx context.Context, marshaler runtime.Marshaler, server ApiServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
|
|
var (
|
|
protoReq GetDevicesRequest
|
|
metadata runtime.ServerMetadata
|
|
)
|
|
if err := req.ParseForm(); err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
|
|
}
|
|
if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Api_GetDevices_0); err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
|
|
}
|
|
msg, err := server.GetDevices(ctx, &protoReq)
|
|
return msg, metadata, err
|
|
}
|
|
|
|
var filter_Api_GetChannels_0 = &utilities.DoubleArray{Encoding: map[string]int{"deviceId": 0}, Base: []int{1, 1, 0}, Check: []int{0, 1, 2}}
|
|
|
|
func request_Api_GetChannels_0(ctx context.Context, marshaler runtime.Marshaler, client ApiClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
|
|
var (
|
|
protoReq GetChannelsRequest
|
|
metadata runtime.ServerMetadata
|
|
err error
|
|
)
|
|
io.Copy(io.Discard, req.Body)
|
|
val, ok := pathParams["deviceId"]
|
|
if !ok {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "deviceId")
|
|
}
|
|
protoReq.DeviceId, err = runtime.String(val)
|
|
if err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "deviceId", err)
|
|
}
|
|
if err := req.ParseForm(); err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
|
|
}
|
|
if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Api_GetChannels_0); err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
|
|
}
|
|
msg, err := client.GetChannels(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
|
|
return msg, metadata, err
|
|
}
|
|
|
|
func local_request_Api_GetChannels_0(ctx context.Context, marshaler runtime.Marshaler, server ApiServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
|
|
var (
|
|
protoReq GetChannelsRequest
|
|
metadata runtime.ServerMetadata
|
|
err error
|
|
)
|
|
val, ok := pathParams["deviceId"]
|
|
if !ok {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "deviceId")
|
|
}
|
|
protoReq.DeviceId, err = runtime.String(val)
|
|
if err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "deviceId", err)
|
|
}
|
|
if err := req.ParseForm(); err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
|
|
}
|
|
if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Api_GetChannels_0); err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
|
|
}
|
|
msg, err := server.GetChannels(ctx, &protoReq)
|
|
return msg, metadata, err
|
|
}
|
|
|
|
func request_Api_SyncDevice_0(ctx context.Context, marshaler runtime.Marshaler, client ApiClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
|
|
var (
|
|
protoReq SyncDeviceRequest
|
|
metadata runtime.ServerMetadata
|
|
err error
|
|
)
|
|
io.Copy(io.Discard, req.Body)
|
|
val, ok := pathParams["deviceId"]
|
|
if !ok {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "deviceId")
|
|
}
|
|
protoReq.DeviceId, err = runtime.String(val)
|
|
if err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "deviceId", err)
|
|
}
|
|
msg, err := client.SyncDevice(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
|
|
return msg, metadata, err
|
|
}
|
|
|
|
func local_request_Api_SyncDevice_0(ctx context.Context, marshaler runtime.Marshaler, server ApiServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
|
|
var (
|
|
protoReq SyncDeviceRequest
|
|
metadata runtime.ServerMetadata
|
|
err error
|
|
)
|
|
val, ok := pathParams["deviceId"]
|
|
if !ok {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "deviceId")
|
|
}
|
|
protoReq.DeviceId, err = runtime.String(val)
|
|
if err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "deviceId", err)
|
|
}
|
|
msg, err := server.SyncDevice(ctx, &protoReq)
|
|
return msg, metadata, err
|
|
}
|
|
|
|
func request_Api_DeleteDevice_0(ctx context.Context, marshaler runtime.Marshaler, client ApiClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
|
|
var (
|
|
protoReq DeleteDeviceRequest
|
|
metadata runtime.ServerMetadata
|
|
err error
|
|
)
|
|
io.Copy(io.Discard, req.Body)
|
|
val, ok := pathParams["deviceId"]
|
|
if !ok {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "deviceId")
|
|
}
|
|
protoReq.DeviceId, err = runtime.String(val)
|
|
if err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "deviceId", err)
|
|
}
|
|
msg, err := client.DeleteDevice(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
|
|
return msg, metadata, err
|
|
}
|
|
|
|
func local_request_Api_DeleteDevice_0(ctx context.Context, marshaler runtime.Marshaler, server ApiServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
|
|
var (
|
|
protoReq DeleteDeviceRequest
|
|
metadata runtime.ServerMetadata
|
|
err error
|
|
)
|
|
val, ok := pathParams["deviceId"]
|
|
if !ok {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "deviceId")
|
|
}
|
|
protoReq.DeviceId, err = runtime.String(val)
|
|
if err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "deviceId", err)
|
|
}
|
|
msg, err := server.DeleteDevice(ctx, &protoReq)
|
|
return msg, metadata, err
|
|
}
|
|
|
|
var filter_Api_GetSubChannels_0 = &utilities.DoubleArray{Encoding: map[string]int{"deviceId": 0, "channelId": 1}, Base: []int{1, 1, 2, 0, 0}, Check: []int{0, 1, 1, 2, 3}}
|
|
|
|
func request_Api_GetSubChannels_0(ctx context.Context, marshaler runtime.Marshaler, client ApiClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
|
|
var (
|
|
protoReq GetSubChannelsRequest
|
|
metadata runtime.ServerMetadata
|
|
err error
|
|
)
|
|
io.Copy(io.Discard, req.Body)
|
|
val, ok := pathParams["deviceId"]
|
|
if !ok {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "deviceId")
|
|
}
|
|
protoReq.DeviceId, err = runtime.String(val)
|
|
if err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "deviceId", err)
|
|
}
|
|
val, ok = pathParams["channelId"]
|
|
if !ok {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "channelId")
|
|
}
|
|
protoReq.ChannelId, err = runtime.String(val)
|
|
if err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "channelId", err)
|
|
}
|
|
if err := req.ParseForm(); err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
|
|
}
|
|
if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Api_GetSubChannels_0); err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
|
|
}
|
|
msg, err := client.GetSubChannels(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
|
|
return msg, metadata, err
|
|
}
|
|
|
|
func local_request_Api_GetSubChannels_0(ctx context.Context, marshaler runtime.Marshaler, server ApiServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
|
|
var (
|
|
protoReq GetSubChannelsRequest
|
|
metadata runtime.ServerMetadata
|
|
err error
|
|
)
|
|
val, ok := pathParams["deviceId"]
|
|
if !ok {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "deviceId")
|
|
}
|
|
protoReq.DeviceId, err = runtime.String(val)
|
|
if err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "deviceId", err)
|
|
}
|
|
val, ok = pathParams["channelId"]
|
|
if !ok {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "channelId")
|
|
}
|
|
protoReq.ChannelId, err = runtime.String(val)
|
|
if err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "channelId", err)
|
|
}
|
|
if err := req.ParseForm(); err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
|
|
}
|
|
if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Api_GetSubChannels_0); err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
|
|
}
|
|
msg, err := server.GetSubChannels(ctx, &protoReq)
|
|
return msg, metadata, err
|
|
}
|
|
|
|
func request_Api_ChangeAudio_0(ctx context.Context, marshaler runtime.Marshaler, client ApiClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
|
|
var (
|
|
protoReq ChangeAudioRequest
|
|
metadata runtime.ServerMetadata
|
|
)
|
|
if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && !errors.Is(err, io.EOF) {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
|
|
}
|
|
msg, err := client.ChangeAudio(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
|
|
return msg, metadata, err
|
|
}
|
|
|
|
func local_request_Api_ChangeAudio_0(ctx context.Context, marshaler runtime.Marshaler, server ApiServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
|
|
var (
|
|
protoReq ChangeAudioRequest
|
|
metadata runtime.ServerMetadata
|
|
)
|
|
if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && !errors.Is(err, io.EOF) {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
|
|
}
|
|
msg, err := server.ChangeAudio(ctx, &protoReq)
|
|
return msg, metadata, err
|
|
}
|
|
|
|
func request_Api_UpdateChannelStreamIdentification_0(ctx context.Context, marshaler runtime.Marshaler, client ApiClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
|
|
var (
|
|
protoReq Channel
|
|
metadata runtime.ServerMetadata
|
|
)
|
|
if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && !errors.Is(err, io.EOF) {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
|
|
}
|
|
msg, err := client.UpdateChannelStreamIdentification(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
|
|
return msg, metadata, err
|
|
}
|
|
|
|
func local_request_Api_UpdateChannelStreamIdentification_0(ctx context.Context, marshaler runtime.Marshaler, server ApiServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
|
|
var (
|
|
protoReq Channel
|
|
metadata runtime.ServerMetadata
|
|
)
|
|
if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && !errors.Is(err, io.EOF) {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
|
|
}
|
|
msg, err := server.UpdateChannelStreamIdentification(ctx, &protoReq)
|
|
return msg, metadata, err
|
|
}
|
|
|
|
func request_Api_UpdateTransport_0(ctx context.Context, marshaler runtime.Marshaler, client ApiClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
|
|
var (
|
|
protoReq UpdateTransportRequest
|
|
metadata runtime.ServerMetadata
|
|
err error
|
|
)
|
|
io.Copy(io.Discard, req.Body)
|
|
val, ok := pathParams["deviceId"]
|
|
if !ok {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "deviceId")
|
|
}
|
|
protoReq.DeviceId, err = runtime.String(val)
|
|
if err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "deviceId", err)
|
|
}
|
|
val, ok = pathParams["streamMode"]
|
|
if !ok {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "streamMode")
|
|
}
|
|
protoReq.StreamMode, err = runtime.String(val)
|
|
if err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "streamMode", err)
|
|
}
|
|
msg, err := client.UpdateTransport(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
|
|
return msg, metadata, err
|
|
}
|
|
|
|
func local_request_Api_UpdateTransport_0(ctx context.Context, marshaler runtime.Marshaler, server ApiServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
|
|
var (
|
|
protoReq UpdateTransportRequest
|
|
metadata runtime.ServerMetadata
|
|
err error
|
|
)
|
|
val, ok := pathParams["deviceId"]
|
|
if !ok {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "deviceId")
|
|
}
|
|
protoReq.DeviceId, err = runtime.String(val)
|
|
if err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "deviceId", err)
|
|
}
|
|
val, ok = pathParams["streamMode"]
|
|
if !ok {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "streamMode")
|
|
}
|
|
protoReq.StreamMode, err = runtime.String(val)
|
|
if err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "streamMode", err)
|
|
}
|
|
msg, err := server.UpdateTransport(ctx, &protoReq)
|
|
return msg, metadata, err
|
|
}
|
|
|
|
func request_Api_AddDevice_0(ctx context.Context, marshaler runtime.Marshaler, client ApiClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
|
|
var (
|
|
protoReq Device
|
|
metadata runtime.ServerMetadata
|
|
)
|
|
if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && !errors.Is(err, io.EOF) {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
|
|
}
|
|
msg, err := client.AddDevice(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
|
|
return msg, metadata, err
|
|
}
|
|
|
|
func local_request_Api_AddDevice_0(ctx context.Context, marshaler runtime.Marshaler, server ApiServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
|
|
var (
|
|
protoReq Device
|
|
metadata runtime.ServerMetadata
|
|
)
|
|
if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && !errors.Is(err, io.EOF) {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
|
|
}
|
|
msg, err := server.AddDevice(ctx, &protoReq)
|
|
return msg, metadata, err
|
|
}
|
|
|
|
func request_Api_UpdateDevice_0(ctx context.Context, marshaler runtime.Marshaler, client ApiClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
|
|
var (
|
|
protoReq Device
|
|
metadata runtime.ServerMetadata
|
|
)
|
|
if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && !errors.Is(err, io.EOF) {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
|
|
}
|
|
msg, err := client.UpdateDevice(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
|
|
return msg, metadata, err
|
|
}
|
|
|
|
func local_request_Api_UpdateDevice_0(ctx context.Context, marshaler runtime.Marshaler, server ApiServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
|
|
var (
|
|
protoReq Device
|
|
metadata runtime.ServerMetadata
|
|
)
|
|
if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && !errors.Is(err, io.EOF) {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
|
|
}
|
|
msg, err := server.UpdateDevice(ctx, &protoReq)
|
|
return msg, metadata, err
|
|
}
|
|
|
|
func request_Api_GetDeviceStatus_0(ctx context.Context, marshaler runtime.Marshaler, client ApiClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
|
|
var (
|
|
protoReq GetDeviceStatusRequest
|
|
metadata runtime.ServerMetadata
|
|
err error
|
|
)
|
|
io.Copy(io.Discard, req.Body)
|
|
val, ok := pathParams["deviceId"]
|
|
if !ok {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "deviceId")
|
|
}
|
|
protoReq.DeviceId, err = runtime.String(val)
|
|
if err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "deviceId", err)
|
|
}
|
|
msg, err := client.GetDeviceStatus(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
|
|
return msg, metadata, err
|
|
}
|
|
|
|
func local_request_Api_GetDeviceStatus_0(ctx context.Context, marshaler runtime.Marshaler, server ApiServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
|
|
var (
|
|
protoReq GetDeviceStatusRequest
|
|
metadata runtime.ServerMetadata
|
|
err error
|
|
)
|
|
val, ok := pathParams["deviceId"]
|
|
if !ok {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "deviceId")
|
|
}
|
|
protoReq.DeviceId, err = runtime.String(val)
|
|
if err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "deviceId", err)
|
|
}
|
|
msg, err := server.GetDeviceStatus(ctx, &protoReq)
|
|
return msg, metadata, err
|
|
}
|
|
|
|
var filter_Api_GetDeviceAlarm_0 = &utilities.DoubleArray{Encoding: map[string]int{"deviceId": 0}, Base: []int{1, 1, 0}, Check: []int{0, 1, 2}}
|
|
|
|
func request_Api_GetDeviceAlarm_0(ctx context.Context, marshaler runtime.Marshaler, client ApiClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
|
|
var (
|
|
protoReq GetDeviceAlarmRequest
|
|
metadata runtime.ServerMetadata
|
|
err error
|
|
)
|
|
io.Copy(io.Discard, req.Body)
|
|
val, ok := pathParams["deviceId"]
|
|
if !ok {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "deviceId")
|
|
}
|
|
protoReq.DeviceId, err = runtime.String(val)
|
|
if err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "deviceId", err)
|
|
}
|
|
if err := req.ParseForm(); err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
|
|
}
|
|
if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Api_GetDeviceAlarm_0); err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
|
|
}
|
|
msg, err := client.GetDeviceAlarm(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
|
|
return msg, metadata, err
|
|
}
|
|
|
|
func local_request_Api_GetDeviceAlarm_0(ctx context.Context, marshaler runtime.Marshaler, server ApiServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
|
|
var (
|
|
protoReq GetDeviceAlarmRequest
|
|
metadata runtime.ServerMetadata
|
|
err error
|
|
)
|
|
val, ok := pathParams["deviceId"]
|
|
if !ok {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "deviceId")
|
|
}
|
|
protoReq.DeviceId, err = runtime.String(val)
|
|
if err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "deviceId", err)
|
|
}
|
|
if err := req.ParseForm(); err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
|
|
}
|
|
if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Api_GetDeviceAlarm_0); err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
|
|
}
|
|
msg, err := server.GetDeviceAlarm(ctx, &protoReq)
|
|
return msg, metadata, err
|
|
}
|
|
|
|
func request_Api_GetSyncStatus_0(ctx context.Context, marshaler runtime.Marshaler, client ApiClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
|
|
var (
|
|
protoReq GetSyncStatusRequest
|
|
metadata runtime.ServerMetadata
|
|
err error
|
|
)
|
|
io.Copy(io.Discard, req.Body)
|
|
val, ok := pathParams["deviceId"]
|
|
if !ok {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "deviceId")
|
|
}
|
|
protoReq.DeviceId, err = runtime.String(val)
|
|
if err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "deviceId", err)
|
|
}
|
|
msg, err := client.GetSyncStatus(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
|
|
return msg, metadata, err
|
|
}
|
|
|
|
func local_request_Api_GetSyncStatus_0(ctx context.Context, marshaler runtime.Marshaler, server ApiServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
|
|
var (
|
|
protoReq GetSyncStatusRequest
|
|
metadata runtime.ServerMetadata
|
|
err error
|
|
)
|
|
val, ok := pathParams["deviceId"]
|
|
if !ok {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "deviceId")
|
|
}
|
|
protoReq.DeviceId, err = runtime.String(val)
|
|
if err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "deviceId", err)
|
|
}
|
|
msg, err := server.GetSyncStatus(ctx, &protoReq)
|
|
return msg, metadata, err
|
|
}
|
|
|
|
func request_Api_GetSubscribeInfo_0(ctx context.Context, marshaler runtime.Marshaler, client ApiClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
|
|
var (
|
|
protoReq GetSubscribeInfoRequest
|
|
metadata runtime.ServerMetadata
|
|
err error
|
|
)
|
|
io.Copy(io.Discard, req.Body)
|
|
val, ok := pathParams["deviceId"]
|
|
if !ok {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "deviceId")
|
|
}
|
|
protoReq.DeviceId, err = runtime.String(val)
|
|
if err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "deviceId", err)
|
|
}
|
|
msg, err := client.GetSubscribeInfo(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
|
|
return msg, metadata, err
|
|
}
|
|
|
|
func local_request_Api_GetSubscribeInfo_0(ctx context.Context, marshaler runtime.Marshaler, server ApiServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
|
|
var (
|
|
protoReq GetSubscribeInfoRequest
|
|
metadata runtime.ServerMetadata
|
|
err error
|
|
)
|
|
val, ok := pathParams["deviceId"]
|
|
if !ok {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "deviceId")
|
|
}
|
|
protoReq.DeviceId, err = runtime.String(val)
|
|
if err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "deviceId", err)
|
|
}
|
|
msg, err := server.GetSubscribeInfo(ctx, &protoReq)
|
|
return msg, metadata, err
|
|
}
|
|
|
|
var filter_Api_GetSnap_0 = &utilities.DoubleArray{Encoding: map[string]int{"deviceId": 0, "channelId": 1}, Base: []int{1, 1, 2, 0, 0}, Check: []int{0, 1, 1, 2, 3}}
|
|
|
|
func request_Api_GetSnap_0(ctx context.Context, marshaler runtime.Marshaler, client ApiClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
|
|
var (
|
|
protoReq GetSnapRequest
|
|
metadata runtime.ServerMetadata
|
|
err error
|
|
)
|
|
io.Copy(io.Discard, req.Body)
|
|
val, ok := pathParams["deviceId"]
|
|
if !ok {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "deviceId")
|
|
}
|
|
protoReq.DeviceId, err = runtime.String(val)
|
|
if err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "deviceId", err)
|
|
}
|
|
val, ok = pathParams["channelId"]
|
|
if !ok {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "channelId")
|
|
}
|
|
protoReq.ChannelId, err = runtime.String(val)
|
|
if err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "channelId", err)
|
|
}
|
|
if err := req.ParseForm(); err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
|
|
}
|
|
if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Api_GetSnap_0); err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
|
|
}
|
|
msg, err := client.GetSnap(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
|
|
return msg, metadata, err
|
|
}
|
|
|
|
func local_request_Api_GetSnap_0(ctx context.Context, marshaler runtime.Marshaler, server ApiServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
|
|
var (
|
|
protoReq GetSnapRequest
|
|
metadata runtime.ServerMetadata
|
|
err error
|
|
)
|
|
val, ok := pathParams["deviceId"]
|
|
if !ok {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "deviceId")
|
|
}
|
|
protoReq.DeviceId, err = runtime.String(val)
|
|
if err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "deviceId", err)
|
|
}
|
|
val, ok = pathParams["channelId"]
|
|
if !ok {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "channelId")
|
|
}
|
|
protoReq.ChannelId, err = runtime.String(val)
|
|
if err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "channelId", err)
|
|
}
|
|
if err := req.ParseForm(); err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
|
|
}
|
|
if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Api_GetSnap_0); err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
|
|
}
|
|
msg, err := server.GetSnap(ctx, &protoReq)
|
|
return msg, metadata, err
|
|
}
|
|
|
|
var filter_Api_StopConvert_0 = &utilities.DoubleArray{Encoding: map[string]int{"key": 0}, Base: []int{1, 1, 0}, Check: []int{0, 1, 2}}
|
|
|
|
func request_Api_StopConvert_0(ctx context.Context, marshaler runtime.Marshaler, client ApiClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
|
|
var (
|
|
protoReq ConvertStopRequest
|
|
metadata runtime.ServerMetadata
|
|
err error
|
|
)
|
|
io.Copy(io.Discard, req.Body)
|
|
val, ok := pathParams["key"]
|
|
if !ok {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "key")
|
|
}
|
|
protoReq.Key, err = runtime.String(val)
|
|
if err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "key", err)
|
|
}
|
|
if err := req.ParseForm(); err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
|
|
}
|
|
if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Api_StopConvert_0); err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
|
|
}
|
|
msg, err := client.StopConvert(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
|
|
return msg, metadata, err
|
|
}
|
|
|
|
func local_request_Api_StopConvert_0(ctx context.Context, marshaler runtime.Marshaler, server ApiServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
|
|
var (
|
|
protoReq ConvertStopRequest
|
|
metadata runtime.ServerMetadata
|
|
err error
|
|
)
|
|
val, ok := pathParams["key"]
|
|
if !ok {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "key")
|
|
}
|
|
protoReq.Key, err = runtime.String(val)
|
|
if err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "key", err)
|
|
}
|
|
if err := req.ParseForm(); err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
|
|
}
|
|
if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Api_StopConvert_0); err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
|
|
}
|
|
msg, err := server.StopConvert(ctx, &protoReq)
|
|
return msg, metadata, err
|
|
}
|
|
|
|
var filter_Api_StartBroadcast_0 = &utilities.DoubleArray{Encoding: map[string]int{"deviceId": 0, "channelId": 1}, Base: []int{1, 1, 2, 0, 0}, Check: []int{0, 1, 1, 2, 3}}
|
|
|
|
func request_Api_StartBroadcast_0(ctx context.Context, marshaler runtime.Marshaler, client ApiClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
|
|
var (
|
|
protoReq BroadcastRequest
|
|
metadata runtime.ServerMetadata
|
|
err error
|
|
)
|
|
io.Copy(io.Discard, req.Body)
|
|
val, ok := pathParams["deviceId"]
|
|
if !ok {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "deviceId")
|
|
}
|
|
protoReq.DeviceId, err = runtime.String(val)
|
|
if err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "deviceId", err)
|
|
}
|
|
val, ok = pathParams["channelId"]
|
|
if !ok {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "channelId")
|
|
}
|
|
protoReq.ChannelId, err = runtime.String(val)
|
|
if err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "channelId", err)
|
|
}
|
|
if err := req.ParseForm(); err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
|
|
}
|
|
if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Api_StartBroadcast_0); err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
|
|
}
|
|
msg, err := client.StartBroadcast(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
|
|
return msg, metadata, err
|
|
}
|
|
|
|
func local_request_Api_StartBroadcast_0(ctx context.Context, marshaler runtime.Marshaler, server ApiServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
|
|
var (
|
|
protoReq BroadcastRequest
|
|
metadata runtime.ServerMetadata
|
|
err error
|
|
)
|
|
val, ok := pathParams["deviceId"]
|
|
if !ok {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "deviceId")
|
|
}
|
|
protoReq.DeviceId, err = runtime.String(val)
|
|
if err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "deviceId", err)
|
|
}
|
|
val, ok = pathParams["channelId"]
|
|
if !ok {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "channelId")
|
|
}
|
|
protoReq.ChannelId, err = runtime.String(val)
|
|
if err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "channelId", err)
|
|
}
|
|
if err := req.ParseForm(); err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
|
|
}
|
|
if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Api_StartBroadcast_0); err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
|
|
}
|
|
msg, err := server.StartBroadcast(ctx, &protoReq)
|
|
return msg, metadata, err
|
|
}
|
|
|
|
var filter_Api_StopBroadcast_0 = &utilities.DoubleArray{Encoding: map[string]int{"deviceId": 0, "channelId": 1}, Base: []int{1, 1, 2, 0, 0}, Check: []int{0, 1, 1, 2, 3}}
|
|
|
|
func request_Api_StopBroadcast_0(ctx context.Context, marshaler runtime.Marshaler, client ApiClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
|
|
var (
|
|
protoReq BroadcastRequest
|
|
metadata runtime.ServerMetadata
|
|
err error
|
|
)
|
|
io.Copy(io.Discard, req.Body)
|
|
val, ok := pathParams["deviceId"]
|
|
if !ok {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "deviceId")
|
|
}
|
|
protoReq.DeviceId, err = runtime.String(val)
|
|
if err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "deviceId", err)
|
|
}
|
|
val, ok = pathParams["channelId"]
|
|
if !ok {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "channelId")
|
|
}
|
|
protoReq.ChannelId, err = runtime.String(val)
|
|
if err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "channelId", err)
|
|
}
|
|
if err := req.ParseForm(); err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
|
|
}
|
|
if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Api_StopBroadcast_0); err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
|
|
}
|
|
msg, err := client.StopBroadcast(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
|
|
return msg, metadata, err
|
|
}
|
|
|
|
func local_request_Api_StopBroadcast_0(ctx context.Context, marshaler runtime.Marshaler, server ApiServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
|
|
var (
|
|
protoReq BroadcastRequest
|
|
metadata runtime.ServerMetadata
|
|
err error
|
|
)
|
|
val, ok := pathParams["deviceId"]
|
|
if !ok {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "deviceId")
|
|
}
|
|
protoReq.DeviceId, err = runtime.String(val)
|
|
if err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "deviceId", err)
|
|
}
|
|
val, ok = pathParams["channelId"]
|
|
if !ok {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "channelId")
|
|
}
|
|
protoReq.ChannelId, err = runtime.String(val)
|
|
if err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "channelId", err)
|
|
}
|
|
if err := req.ParseForm(); err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
|
|
}
|
|
if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Api_StopBroadcast_0); err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
|
|
}
|
|
msg, err := server.StopBroadcast(ctx, &protoReq)
|
|
return msg, metadata, err
|
|
}
|
|
|
|
func request_Api_GetAllSSRC_0(ctx context.Context, marshaler runtime.Marshaler, client ApiClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
|
|
var (
|
|
protoReq emptypb.Empty
|
|
metadata runtime.ServerMetadata
|
|
)
|
|
io.Copy(io.Discard, req.Body)
|
|
msg, err := client.GetAllSSRC(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
|
|
return msg, metadata, err
|
|
}
|
|
|
|
func local_request_Api_GetAllSSRC_0(ctx context.Context, marshaler runtime.Marshaler, server ApiServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
|
|
var (
|
|
protoReq emptypb.Empty
|
|
metadata runtime.ServerMetadata
|
|
)
|
|
msg, err := server.GetAllSSRC(ctx, &protoReq)
|
|
return msg, metadata, err
|
|
}
|
|
|
|
var filter_Api_GetRawChannel_0 = &utilities.DoubleArray{Encoding: map[string]int{}, Base: []int(nil), Check: []int(nil)}
|
|
|
|
func request_Api_GetRawChannel_0(ctx context.Context, marshaler runtime.Marshaler, client ApiClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
|
|
var (
|
|
protoReq GetRawChannelRequest
|
|
metadata runtime.ServerMetadata
|
|
)
|
|
io.Copy(io.Discard, req.Body)
|
|
if err := req.ParseForm(); err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
|
|
}
|
|
if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Api_GetRawChannel_0); err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
|
|
}
|
|
msg, err := client.GetRawChannel(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
|
|
return msg, metadata, err
|
|
}
|
|
|
|
func local_request_Api_GetRawChannel_0(ctx context.Context, marshaler runtime.Marshaler, server ApiServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
|
|
var (
|
|
protoReq GetRawChannelRequest
|
|
metadata runtime.ServerMetadata
|
|
)
|
|
if err := req.ParseForm(); err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
|
|
}
|
|
if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Api_GetRawChannel_0); err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
|
|
}
|
|
msg, err := server.GetRawChannel(ctx, &protoReq)
|
|
return msg, metadata, err
|
|
}
|
|
|
|
func request_Api_AddPlatform_0(ctx context.Context, marshaler runtime.Marshaler, client ApiClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
|
|
var (
|
|
protoReq Platform
|
|
metadata runtime.ServerMetadata
|
|
)
|
|
if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && !errors.Is(err, io.EOF) {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
|
|
}
|
|
msg, err := client.AddPlatform(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
|
|
return msg, metadata, err
|
|
}
|
|
|
|
func local_request_Api_AddPlatform_0(ctx context.Context, marshaler runtime.Marshaler, server ApiServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
|
|
var (
|
|
protoReq Platform
|
|
metadata runtime.ServerMetadata
|
|
)
|
|
if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && !errors.Is(err, io.EOF) {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
|
|
}
|
|
msg, err := server.AddPlatform(ctx, &protoReq)
|
|
return msg, metadata, err
|
|
}
|
|
|
|
func request_Api_GetPlatform_0(ctx context.Context, marshaler runtime.Marshaler, client ApiClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
|
|
var (
|
|
protoReq GetPlatformRequest
|
|
metadata runtime.ServerMetadata
|
|
err error
|
|
)
|
|
io.Copy(io.Discard, req.Body)
|
|
val, ok := pathParams["id"]
|
|
if !ok {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "id")
|
|
}
|
|
protoReq.Id, err = runtime.Int32(val)
|
|
if err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "id", err)
|
|
}
|
|
msg, err := client.GetPlatform(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
|
|
return msg, metadata, err
|
|
}
|
|
|
|
func local_request_Api_GetPlatform_0(ctx context.Context, marshaler runtime.Marshaler, server ApiServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
|
|
var (
|
|
protoReq GetPlatformRequest
|
|
metadata runtime.ServerMetadata
|
|
err error
|
|
)
|
|
val, ok := pathParams["id"]
|
|
if !ok {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "id")
|
|
}
|
|
protoReq.Id, err = runtime.Int32(val)
|
|
if err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "id", err)
|
|
}
|
|
msg, err := server.GetPlatform(ctx, &protoReq)
|
|
return msg, metadata, err
|
|
}
|
|
|
|
func request_Api_UpdatePlatform_0(ctx context.Context, marshaler runtime.Marshaler, client ApiClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
|
|
var (
|
|
protoReq Platform
|
|
metadata runtime.ServerMetadata
|
|
)
|
|
if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && !errors.Is(err, io.EOF) {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
|
|
}
|
|
msg, err := client.UpdatePlatform(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
|
|
return msg, metadata, err
|
|
}
|
|
|
|
func local_request_Api_UpdatePlatform_0(ctx context.Context, marshaler runtime.Marshaler, server ApiServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
|
|
var (
|
|
protoReq Platform
|
|
metadata runtime.ServerMetadata
|
|
)
|
|
if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && !errors.Is(err, io.EOF) {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
|
|
}
|
|
msg, err := server.UpdatePlatform(ctx, &protoReq)
|
|
return msg, metadata, err
|
|
}
|
|
|
|
func request_Api_DeletePlatform_0(ctx context.Context, marshaler runtime.Marshaler, client ApiClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
|
|
var (
|
|
protoReq DeletePlatformRequest
|
|
metadata runtime.ServerMetadata
|
|
err error
|
|
)
|
|
io.Copy(io.Discard, req.Body)
|
|
val, ok := pathParams["id"]
|
|
if !ok {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "id")
|
|
}
|
|
protoReq.Id, err = runtime.Int32(val)
|
|
if err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "id", err)
|
|
}
|
|
msg, err := client.DeletePlatform(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
|
|
return msg, metadata, err
|
|
}
|
|
|
|
func local_request_Api_DeletePlatform_0(ctx context.Context, marshaler runtime.Marshaler, server ApiServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
|
|
var (
|
|
protoReq DeletePlatformRequest
|
|
metadata runtime.ServerMetadata
|
|
err error
|
|
)
|
|
val, ok := pathParams["id"]
|
|
if !ok {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "id")
|
|
}
|
|
protoReq.Id, err = runtime.Int32(val)
|
|
if err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "id", err)
|
|
}
|
|
msg, err := server.DeletePlatform(ctx, &protoReq)
|
|
return msg, metadata, err
|
|
}
|
|
|
|
var filter_Api_ListPlatforms_0 = &utilities.DoubleArray{Encoding: map[string]int{}, Base: []int(nil), Check: []int(nil)}
|
|
|
|
func request_Api_ListPlatforms_0(ctx context.Context, marshaler runtime.Marshaler, client ApiClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
|
|
var (
|
|
protoReq ListPlatformsRequest
|
|
metadata runtime.ServerMetadata
|
|
)
|
|
io.Copy(io.Discard, req.Body)
|
|
if err := req.ParseForm(); err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
|
|
}
|
|
if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Api_ListPlatforms_0); err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
|
|
}
|
|
msg, err := client.ListPlatforms(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
|
|
return msg, metadata, err
|
|
}
|
|
|
|
func local_request_Api_ListPlatforms_0(ctx context.Context, marshaler runtime.Marshaler, server ApiServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
|
|
var (
|
|
protoReq ListPlatformsRequest
|
|
metadata runtime.ServerMetadata
|
|
)
|
|
if err := req.ParseForm(); err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
|
|
}
|
|
if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Api_ListPlatforms_0); err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
|
|
}
|
|
msg, err := server.ListPlatforms(ctx, &protoReq)
|
|
return msg, metadata, err
|
|
}
|
|
|
|
var filter_Api_QueryRecord_0 = &utilities.DoubleArray{Encoding: map[string]int{"deviceId": 0, "channelId": 1}, Base: []int{1, 1, 2, 0, 0}, Check: []int{0, 1, 1, 2, 3}}
|
|
|
|
func request_Api_QueryRecord_0(ctx context.Context, marshaler runtime.Marshaler, client ApiClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
|
|
var (
|
|
protoReq QueryRecordRequest
|
|
metadata runtime.ServerMetadata
|
|
err error
|
|
)
|
|
io.Copy(io.Discard, req.Body)
|
|
val, ok := pathParams["deviceId"]
|
|
if !ok {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "deviceId")
|
|
}
|
|
protoReq.DeviceId, err = runtime.String(val)
|
|
if err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "deviceId", err)
|
|
}
|
|
val, ok = pathParams["channelId"]
|
|
if !ok {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "channelId")
|
|
}
|
|
protoReq.ChannelId, err = runtime.String(val)
|
|
if err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "channelId", err)
|
|
}
|
|
if err := req.ParseForm(); err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
|
|
}
|
|
if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Api_QueryRecord_0); err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
|
|
}
|
|
msg, err := client.QueryRecord(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
|
|
return msg, metadata, err
|
|
}
|
|
|
|
func local_request_Api_QueryRecord_0(ctx context.Context, marshaler runtime.Marshaler, server ApiServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
|
|
var (
|
|
protoReq QueryRecordRequest
|
|
metadata runtime.ServerMetadata
|
|
err error
|
|
)
|
|
val, ok := pathParams["deviceId"]
|
|
if !ok {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "deviceId")
|
|
}
|
|
protoReq.DeviceId, err = runtime.String(val)
|
|
if err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "deviceId", err)
|
|
}
|
|
val, ok = pathParams["channelId"]
|
|
if !ok {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "channelId")
|
|
}
|
|
protoReq.ChannelId, err = runtime.String(val)
|
|
if err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "channelId", err)
|
|
}
|
|
if err := req.ParseForm(); err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
|
|
}
|
|
if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Api_QueryRecord_0); err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
|
|
}
|
|
msg, err := server.QueryRecord(ctx, &protoReq)
|
|
return msg, metadata, err
|
|
}
|
|
|
|
var filter_Api_PtzControl_0 = &utilities.DoubleArray{Encoding: map[string]int{"deviceId": 0, "channelId": 1}, Base: []int{1, 1, 2, 0, 0}, Check: []int{0, 1, 1, 2, 3}}
|
|
|
|
func request_Api_PtzControl_0(ctx context.Context, marshaler runtime.Marshaler, client ApiClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
|
|
var (
|
|
protoReq PtzControlRequest
|
|
metadata runtime.ServerMetadata
|
|
err error
|
|
)
|
|
io.Copy(io.Discard, req.Body)
|
|
val, ok := pathParams["deviceId"]
|
|
if !ok {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "deviceId")
|
|
}
|
|
protoReq.DeviceId, err = runtime.String(val)
|
|
if err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "deviceId", err)
|
|
}
|
|
val, ok = pathParams["channelId"]
|
|
if !ok {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "channelId")
|
|
}
|
|
protoReq.ChannelId, err = runtime.String(val)
|
|
if err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "channelId", err)
|
|
}
|
|
if err := req.ParseForm(); err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
|
|
}
|
|
if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Api_PtzControl_0); err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
|
|
}
|
|
msg, err := client.PtzControl(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
|
|
return msg, metadata, err
|
|
}
|
|
|
|
func local_request_Api_PtzControl_0(ctx context.Context, marshaler runtime.Marshaler, server ApiServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
|
|
var (
|
|
protoReq PtzControlRequest
|
|
metadata runtime.ServerMetadata
|
|
err error
|
|
)
|
|
val, ok := pathParams["deviceId"]
|
|
if !ok {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "deviceId")
|
|
}
|
|
protoReq.DeviceId, err = runtime.String(val)
|
|
if err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "deviceId", err)
|
|
}
|
|
val, ok = pathParams["channelId"]
|
|
if !ok {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "channelId")
|
|
}
|
|
protoReq.ChannelId, err = runtime.String(val)
|
|
if err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "channelId", err)
|
|
}
|
|
if err := req.ParseForm(); err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
|
|
}
|
|
if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Api_PtzControl_0); err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
|
|
}
|
|
msg, err := server.PtzControl(ctx, &protoReq)
|
|
return msg, metadata, err
|
|
}
|
|
|
|
var filter_Api_IrisControl_0 = &utilities.DoubleArray{Encoding: map[string]int{"deviceId": 0, "channelId": 1}, Base: []int{1, 1, 2, 0, 0}, Check: []int{0, 1, 1, 2, 3}}
|
|
|
|
func request_Api_IrisControl_0(ctx context.Context, marshaler runtime.Marshaler, client ApiClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
|
|
var (
|
|
protoReq IrisControlRequest
|
|
metadata runtime.ServerMetadata
|
|
err error
|
|
)
|
|
io.Copy(io.Discard, req.Body)
|
|
val, ok := pathParams["deviceId"]
|
|
if !ok {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "deviceId")
|
|
}
|
|
protoReq.DeviceId, err = runtime.String(val)
|
|
if err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "deviceId", err)
|
|
}
|
|
val, ok = pathParams["channelId"]
|
|
if !ok {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "channelId")
|
|
}
|
|
protoReq.ChannelId, err = runtime.String(val)
|
|
if err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "channelId", err)
|
|
}
|
|
if err := req.ParseForm(); err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
|
|
}
|
|
if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Api_IrisControl_0); err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
|
|
}
|
|
msg, err := client.IrisControl(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
|
|
return msg, metadata, err
|
|
}
|
|
|
|
func local_request_Api_IrisControl_0(ctx context.Context, marshaler runtime.Marshaler, server ApiServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
|
|
var (
|
|
protoReq IrisControlRequest
|
|
metadata runtime.ServerMetadata
|
|
err error
|
|
)
|
|
val, ok := pathParams["deviceId"]
|
|
if !ok {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "deviceId")
|
|
}
|
|
protoReq.DeviceId, err = runtime.String(val)
|
|
if err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "deviceId", err)
|
|
}
|
|
val, ok = pathParams["channelId"]
|
|
if !ok {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "channelId")
|
|
}
|
|
protoReq.ChannelId, err = runtime.String(val)
|
|
if err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "channelId", err)
|
|
}
|
|
if err := req.ParseForm(); err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
|
|
}
|
|
if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Api_IrisControl_0); err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
|
|
}
|
|
msg, err := server.IrisControl(ctx, &protoReq)
|
|
return msg, metadata, err
|
|
}
|
|
|
|
var filter_Api_FocusControl_0 = &utilities.DoubleArray{Encoding: map[string]int{"deviceId": 0, "channelId": 1}, Base: []int{1, 1, 2, 0, 0}, Check: []int{0, 1, 1, 2, 3}}
|
|
|
|
func request_Api_FocusControl_0(ctx context.Context, marshaler runtime.Marshaler, client ApiClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
|
|
var (
|
|
protoReq FocusControlRequest
|
|
metadata runtime.ServerMetadata
|
|
err error
|
|
)
|
|
io.Copy(io.Discard, req.Body)
|
|
val, ok := pathParams["deviceId"]
|
|
if !ok {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "deviceId")
|
|
}
|
|
protoReq.DeviceId, err = runtime.String(val)
|
|
if err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "deviceId", err)
|
|
}
|
|
val, ok = pathParams["channelId"]
|
|
if !ok {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "channelId")
|
|
}
|
|
protoReq.ChannelId, err = runtime.String(val)
|
|
if err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "channelId", err)
|
|
}
|
|
if err := req.ParseForm(); err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
|
|
}
|
|
if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Api_FocusControl_0); err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
|
|
}
|
|
msg, err := client.FocusControl(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
|
|
return msg, metadata, err
|
|
}
|
|
|
|
func local_request_Api_FocusControl_0(ctx context.Context, marshaler runtime.Marshaler, server ApiServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
|
|
var (
|
|
protoReq FocusControlRequest
|
|
metadata runtime.ServerMetadata
|
|
err error
|
|
)
|
|
val, ok := pathParams["deviceId"]
|
|
if !ok {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "deviceId")
|
|
}
|
|
protoReq.DeviceId, err = runtime.String(val)
|
|
if err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "deviceId", err)
|
|
}
|
|
val, ok = pathParams["channelId"]
|
|
if !ok {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "channelId")
|
|
}
|
|
protoReq.ChannelId, err = runtime.String(val)
|
|
if err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "channelId", err)
|
|
}
|
|
if err := req.ParseForm(); err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
|
|
}
|
|
if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Api_FocusControl_0); err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
|
|
}
|
|
msg, err := server.FocusControl(ctx, &protoReq)
|
|
return msg, metadata, err
|
|
}
|
|
|
|
var filter_Api_QueryPreset_0 = &utilities.DoubleArray{Encoding: map[string]int{"deviceId": 0, "channelId": 1}, Base: []int{1, 1, 2, 0, 0}, Check: []int{0, 1, 1, 2, 3}}
|
|
|
|
func request_Api_QueryPreset_0(ctx context.Context, marshaler runtime.Marshaler, client ApiClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
|
|
var (
|
|
protoReq PresetRequest
|
|
metadata runtime.ServerMetadata
|
|
err error
|
|
)
|
|
io.Copy(io.Discard, req.Body)
|
|
val, ok := pathParams["deviceId"]
|
|
if !ok {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "deviceId")
|
|
}
|
|
protoReq.DeviceId, err = runtime.String(val)
|
|
if err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "deviceId", err)
|
|
}
|
|
val, ok = pathParams["channelId"]
|
|
if !ok {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "channelId")
|
|
}
|
|
protoReq.ChannelId, err = runtime.String(val)
|
|
if err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "channelId", err)
|
|
}
|
|
if err := req.ParseForm(); err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
|
|
}
|
|
if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Api_QueryPreset_0); err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
|
|
}
|
|
msg, err := client.QueryPreset(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
|
|
return msg, metadata, err
|
|
}
|
|
|
|
func local_request_Api_QueryPreset_0(ctx context.Context, marshaler runtime.Marshaler, server ApiServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
|
|
var (
|
|
protoReq PresetRequest
|
|
metadata runtime.ServerMetadata
|
|
err error
|
|
)
|
|
val, ok := pathParams["deviceId"]
|
|
if !ok {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "deviceId")
|
|
}
|
|
protoReq.DeviceId, err = runtime.String(val)
|
|
if err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "deviceId", err)
|
|
}
|
|
val, ok = pathParams["channelId"]
|
|
if !ok {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "channelId")
|
|
}
|
|
protoReq.ChannelId, err = runtime.String(val)
|
|
if err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "channelId", err)
|
|
}
|
|
if err := req.ParseForm(); err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
|
|
}
|
|
if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Api_QueryPreset_0); err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
|
|
}
|
|
msg, err := server.QueryPreset(ctx, &protoReq)
|
|
return msg, metadata, err
|
|
}
|
|
|
|
var filter_Api_AddPreset_0 = &utilities.DoubleArray{Encoding: map[string]int{"deviceId": 0, "channelId": 1}, Base: []int{1, 1, 2, 0, 0}, Check: []int{0, 1, 1, 2, 3}}
|
|
|
|
func request_Api_AddPreset_0(ctx context.Context, marshaler runtime.Marshaler, client ApiClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
|
|
var (
|
|
protoReq PresetRequest
|
|
metadata runtime.ServerMetadata
|
|
err error
|
|
)
|
|
io.Copy(io.Discard, req.Body)
|
|
val, ok := pathParams["deviceId"]
|
|
if !ok {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "deviceId")
|
|
}
|
|
protoReq.DeviceId, err = runtime.String(val)
|
|
if err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "deviceId", err)
|
|
}
|
|
val, ok = pathParams["channelId"]
|
|
if !ok {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "channelId")
|
|
}
|
|
protoReq.ChannelId, err = runtime.String(val)
|
|
if err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "channelId", err)
|
|
}
|
|
if err := req.ParseForm(); err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
|
|
}
|
|
if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Api_AddPreset_0); err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
|
|
}
|
|
msg, err := client.AddPreset(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
|
|
return msg, metadata, err
|
|
}
|
|
|
|
func local_request_Api_AddPreset_0(ctx context.Context, marshaler runtime.Marshaler, server ApiServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
|
|
var (
|
|
protoReq PresetRequest
|
|
metadata runtime.ServerMetadata
|
|
err error
|
|
)
|
|
val, ok := pathParams["deviceId"]
|
|
if !ok {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "deviceId")
|
|
}
|
|
protoReq.DeviceId, err = runtime.String(val)
|
|
if err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "deviceId", err)
|
|
}
|
|
val, ok = pathParams["channelId"]
|
|
if !ok {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "channelId")
|
|
}
|
|
protoReq.ChannelId, err = runtime.String(val)
|
|
if err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "channelId", err)
|
|
}
|
|
if err := req.ParseForm(); err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
|
|
}
|
|
if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Api_AddPreset_0); err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
|
|
}
|
|
msg, err := server.AddPreset(ctx, &protoReq)
|
|
return msg, metadata, err
|
|
}
|
|
|
|
var filter_Api_CallPreset_0 = &utilities.DoubleArray{Encoding: map[string]int{"deviceId": 0, "channelId": 1}, Base: []int{1, 1, 2, 0, 0}, Check: []int{0, 1, 1, 2, 3}}
|
|
|
|
func request_Api_CallPreset_0(ctx context.Context, marshaler runtime.Marshaler, client ApiClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
|
|
var (
|
|
protoReq PresetRequest
|
|
metadata runtime.ServerMetadata
|
|
err error
|
|
)
|
|
io.Copy(io.Discard, req.Body)
|
|
val, ok := pathParams["deviceId"]
|
|
if !ok {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "deviceId")
|
|
}
|
|
protoReq.DeviceId, err = runtime.String(val)
|
|
if err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "deviceId", err)
|
|
}
|
|
val, ok = pathParams["channelId"]
|
|
if !ok {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "channelId")
|
|
}
|
|
protoReq.ChannelId, err = runtime.String(val)
|
|
if err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "channelId", err)
|
|
}
|
|
if err := req.ParseForm(); err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
|
|
}
|
|
if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Api_CallPreset_0); err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
|
|
}
|
|
msg, err := client.CallPreset(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
|
|
return msg, metadata, err
|
|
}
|
|
|
|
func local_request_Api_CallPreset_0(ctx context.Context, marshaler runtime.Marshaler, server ApiServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
|
|
var (
|
|
protoReq PresetRequest
|
|
metadata runtime.ServerMetadata
|
|
err error
|
|
)
|
|
val, ok := pathParams["deviceId"]
|
|
if !ok {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "deviceId")
|
|
}
|
|
protoReq.DeviceId, err = runtime.String(val)
|
|
if err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "deviceId", err)
|
|
}
|
|
val, ok = pathParams["channelId"]
|
|
if !ok {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "channelId")
|
|
}
|
|
protoReq.ChannelId, err = runtime.String(val)
|
|
if err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "channelId", err)
|
|
}
|
|
if err := req.ParseForm(); err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
|
|
}
|
|
if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Api_CallPreset_0); err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
|
|
}
|
|
msg, err := server.CallPreset(ctx, &protoReq)
|
|
return msg, metadata, err
|
|
}
|
|
|
|
var filter_Api_DeletePreset_0 = &utilities.DoubleArray{Encoding: map[string]int{"deviceId": 0, "channelId": 1}, Base: []int{1, 1, 2, 0, 0}, Check: []int{0, 1, 1, 2, 3}}
|
|
|
|
func request_Api_DeletePreset_0(ctx context.Context, marshaler runtime.Marshaler, client ApiClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
|
|
var (
|
|
protoReq PresetRequest
|
|
metadata runtime.ServerMetadata
|
|
err error
|
|
)
|
|
io.Copy(io.Discard, req.Body)
|
|
val, ok := pathParams["deviceId"]
|
|
if !ok {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "deviceId")
|
|
}
|
|
protoReq.DeviceId, err = runtime.String(val)
|
|
if err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "deviceId", err)
|
|
}
|
|
val, ok = pathParams["channelId"]
|
|
if !ok {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "channelId")
|
|
}
|
|
protoReq.ChannelId, err = runtime.String(val)
|
|
if err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "channelId", err)
|
|
}
|
|
if err := req.ParseForm(); err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
|
|
}
|
|
if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Api_DeletePreset_0); err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
|
|
}
|
|
msg, err := client.DeletePreset(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
|
|
return msg, metadata, err
|
|
}
|
|
|
|
func local_request_Api_DeletePreset_0(ctx context.Context, marshaler runtime.Marshaler, server ApiServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
|
|
var (
|
|
protoReq PresetRequest
|
|
metadata runtime.ServerMetadata
|
|
err error
|
|
)
|
|
val, ok := pathParams["deviceId"]
|
|
if !ok {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "deviceId")
|
|
}
|
|
protoReq.DeviceId, err = runtime.String(val)
|
|
if err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "deviceId", err)
|
|
}
|
|
val, ok = pathParams["channelId"]
|
|
if !ok {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "channelId")
|
|
}
|
|
protoReq.ChannelId, err = runtime.String(val)
|
|
if err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "channelId", err)
|
|
}
|
|
if err := req.ParseForm(); err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
|
|
}
|
|
if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Api_DeletePreset_0); err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
|
|
}
|
|
msg, err := server.DeletePreset(ctx, &protoReq)
|
|
return msg, metadata, err
|
|
}
|
|
|
|
var filter_Api_AddCruisePoint_0 = &utilities.DoubleArray{Encoding: map[string]int{"deviceId": 0, "channelId": 1}, Base: []int{1, 1, 2, 0, 0}, Check: []int{0, 1, 1, 2, 3}}
|
|
|
|
func request_Api_AddCruisePoint_0(ctx context.Context, marshaler runtime.Marshaler, client ApiClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
|
|
var (
|
|
protoReq CruisePointRequest
|
|
metadata runtime.ServerMetadata
|
|
err error
|
|
)
|
|
io.Copy(io.Discard, req.Body)
|
|
val, ok := pathParams["deviceId"]
|
|
if !ok {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "deviceId")
|
|
}
|
|
protoReq.DeviceId, err = runtime.String(val)
|
|
if err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "deviceId", err)
|
|
}
|
|
val, ok = pathParams["channelId"]
|
|
if !ok {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "channelId")
|
|
}
|
|
protoReq.ChannelId, err = runtime.String(val)
|
|
if err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "channelId", err)
|
|
}
|
|
if err := req.ParseForm(); err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
|
|
}
|
|
if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Api_AddCruisePoint_0); err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
|
|
}
|
|
msg, err := client.AddCruisePoint(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
|
|
return msg, metadata, err
|
|
}
|
|
|
|
func local_request_Api_AddCruisePoint_0(ctx context.Context, marshaler runtime.Marshaler, server ApiServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
|
|
var (
|
|
protoReq CruisePointRequest
|
|
metadata runtime.ServerMetadata
|
|
err error
|
|
)
|
|
val, ok := pathParams["deviceId"]
|
|
if !ok {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "deviceId")
|
|
}
|
|
protoReq.DeviceId, err = runtime.String(val)
|
|
if err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "deviceId", err)
|
|
}
|
|
val, ok = pathParams["channelId"]
|
|
if !ok {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "channelId")
|
|
}
|
|
protoReq.ChannelId, err = runtime.String(val)
|
|
if err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "channelId", err)
|
|
}
|
|
if err := req.ParseForm(); err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
|
|
}
|
|
if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Api_AddCruisePoint_0); err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
|
|
}
|
|
msg, err := server.AddCruisePoint(ctx, &protoReq)
|
|
return msg, metadata, err
|
|
}
|
|
|
|
var filter_Api_DeleteCruisePoint_0 = &utilities.DoubleArray{Encoding: map[string]int{"deviceId": 0, "channelId": 1}, Base: []int{1, 1, 2, 0, 0}, Check: []int{0, 1, 1, 2, 3}}
|
|
|
|
func request_Api_DeleteCruisePoint_0(ctx context.Context, marshaler runtime.Marshaler, client ApiClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
|
|
var (
|
|
protoReq CruisePointRequest
|
|
metadata runtime.ServerMetadata
|
|
err error
|
|
)
|
|
io.Copy(io.Discard, req.Body)
|
|
val, ok := pathParams["deviceId"]
|
|
if !ok {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "deviceId")
|
|
}
|
|
protoReq.DeviceId, err = runtime.String(val)
|
|
if err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "deviceId", err)
|
|
}
|
|
val, ok = pathParams["channelId"]
|
|
if !ok {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "channelId")
|
|
}
|
|
protoReq.ChannelId, err = runtime.String(val)
|
|
if err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "channelId", err)
|
|
}
|
|
if err := req.ParseForm(); err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
|
|
}
|
|
if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Api_DeleteCruisePoint_0); err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
|
|
}
|
|
msg, err := client.DeleteCruisePoint(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
|
|
return msg, metadata, err
|
|
}
|
|
|
|
func local_request_Api_DeleteCruisePoint_0(ctx context.Context, marshaler runtime.Marshaler, server ApiServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
|
|
var (
|
|
protoReq CruisePointRequest
|
|
metadata runtime.ServerMetadata
|
|
err error
|
|
)
|
|
val, ok := pathParams["deviceId"]
|
|
if !ok {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "deviceId")
|
|
}
|
|
protoReq.DeviceId, err = runtime.String(val)
|
|
if err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "deviceId", err)
|
|
}
|
|
val, ok = pathParams["channelId"]
|
|
if !ok {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "channelId")
|
|
}
|
|
protoReq.ChannelId, err = runtime.String(val)
|
|
if err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "channelId", err)
|
|
}
|
|
if err := req.ParseForm(); err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
|
|
}
|
|
if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Api_DeleteCruisePoint_0); err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
|
|
}
|
|
msg, err := server.DeleteCruisePoint(ctx, &protoReq)
|
|
return msg, metadata, err
|
|
}
|
|
|
|
var filter_Api_SetCruiseSpeed_0 = &utilities.DoubleArray{Encoding: map[string]int{"deviceId": 0, "channelId": 1}, Base: []int{1, 1, 2, 0, 0}, Check: []int{0, 1, 1, 2, 3}}
|
|
|
|
func request_Api_SetCruiseSpeed_0(ctx context.Context, marshaler runtime.Marshaler, client ApiClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
|
|
var (
|
|
protoReq CruiseSpeedRequest
|
|
metadata runtime.ServerMetadata
|
|
err error
|
|
)
|
|
io.Copy(io.Discard, req.Body)
|
|
val, ok := pathParams["deviceId"]
|
|
if !ok {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "deviceId")
|
|
}
|
|
protoReq.DeviceId, err = runtime.String(val)
|
|
if err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "deviceId", err)
|
|
}
|
|
val, ok = pathParams["channelId"]
|
|
if !ok {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "channelId")
|
|
}
|
|
protoReq.ChannelId, err = runtime.String(val)
|
|
if err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "channelId", err)
|
|
}
|
|
if err := req.ParseForm(); err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
|
|
}
|
|
if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Api_SetCruiseSpeed_0); err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
|
|
}
|
|
msg, err := client.SetCruiseSpeed(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
|
|
return msg, metadata, err
|
|
}
|
|
|
|
func local_request_Api_SetCruiseSpeed_0(ctx context.Context, marshaler runtime.Marshaler, server ApiServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
|
|
var (
|
|
protoReq CruiseSpeedRequest
|
|
metadata runtime.ServerMetadata
|
|
err error
|
|
)
|
|
val, ok := pathParams["deviceId"]
|
|
if !ok {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "deviceId")
|
|
}
|
|
protoReq.DeviceId, err = runtime.String(val)
|
|
if err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "deviceId", err)
|
|
}
|
|
val, ok = pathParams["channelId"]
|
|
if !ok {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "channelId")
|
|
}
|
|
protoReq.ChannelId, err = runtime.String(val)
|
|
if err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "channelId", err)
|
|
}
|
|
if err := req.ParseForm(); err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
|
|
}
|
|
if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Api_SetCruiseSpeed_0); err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
|
|
}
|
|
msg, err := server.SetCruiseSpeed(ctx, &protoReq)
|
|
return msg, metadata, err
|
|
}
|
|
|
|
var filter_Api_SetCruiseTime_0 = &utilities.DoubleArray{Encoding: map[string]int{"deviceId": 0, "channelId": 1}, Base: []int{1, 1, 2, 0, 0}, Check: []int{0, 1, 1, 2, 3}}
|
|
|
|
func request_Api_SetCruiseTime_0(ctx context.Context, marshaler runtime.Marshaler, client ApiClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
|
|
var (
|
|
protoReq CruiseTimeRequest
|
|
metadata runtime.ServerMetadata
|
|
err error
|
|
)
|
|
io.Copy(io.Discard, req.Body)
|
|
val, ok := pathParams["deviceId"]
|
|
if !ok {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "deviceId")
|
|
}
|
|
protoReq.DeviceId, err = runtime.String(val)
|
|
if err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "deviceId", err)
|
|
}
|
|
val, ok = pathParams["channelId"]
|
|
if !ok {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "channelId")
|
|
}
|
|
protoReq.ChannelId, err = runtime.String(val)
|
|
if err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "channelId", err)
|
|
}
|
|
if err := req.ParseForm(); err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
|
|
}
|
|
if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Api_SetCruiseTime_0); err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
|
|
}
|
|
msg, err := client.SetCruiseTime(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
|
|
return msg, metadata, err
|
|
}
|
|
|
|
func local_request_Api_SetCruiseTime_0(ctx context.Context, marshaler runtime.Marshaler, server ApiServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
|
|
var (
|
|
protoReq CruiseTimeRequest
|
|
metadata runtime.ServerMetadata
|
|
err error
|
|
)
|
|
val, ok := pathParams["deviceId"]
|
|
if !ok {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "deviceId")
|
|
}
|
|
protoReq.DeviceId, err = runtime.String(val)
|
|
if err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "deviceId", err)
|
|
}
|
|
val, ok = pathParams["channelId"]
|
|
if !ok {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "channelId")
|
|
}
|
|
protoReq.ChannelId, err = runtime.String(val)
|
|
if err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "channelId", err)
|
|
}
|
|
if err := req.ParseForm(); err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
|
|
}
|
|
if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Api_SetCruiseTime_0); err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
|
|
}
|
|
msg, err := server.SetCruiseTime(ctx, &protoReq)
|
|
return msg, metadata, err
|
|
}
|
|
|
|
var filter_Api_StartCruise_0 = &utilities.DoubleArray{Encoding: map[string]int{"deviceId": 0, "channelId": 1}, Base: []int{1, 1, 2, 0, 0}, Check: []int{0, 1, 1, 2, 3}}
|
|
|
|
func request_Api_StartCruise_0(ctx context.Context, marshaler runtime.Marshaler, client ApiClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
|
|
var (
|
|
protoReq CruiseRequest
|
|
metadata runtime.ServerMetadata
|
|
err error
|
|
)
|
|
io.Copy(io.Discard, req.Body)
|
|
val, ok := pathParams["deviceId"]
|
|
if !ok {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "deviceId")
|
|
}
|
|
protoReq.DeviceId, err = runtime.String(val)
|
|
if err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "deviceId", err)
|
|
}
|
|
val, ok = pathParams["channelId"]
|
|
if !ok {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "channelId")
|
|
}
|
|
protoReq.ChannelId, err = runtime.String(val)
|
|
if err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "channelId", err)
|
|
}
|
|
if err := req.ParseForm(); err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
|
|
}
|
|
if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Api_StartCruise_0); err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
|
|
}
|
|
msg, err := client.StartCruise(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
|
|
return msg, metadata, err
|
|
}
|
|
|
|
func local_request_Api_StartCruise_0(ctx context.Context, marshaler runtime.Marshaler, server ApiServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
|
|
var (
|
|
protoReq CruiseRequest
|
|
metadata runtime.ServerMetadata
|
|
err error
|
|
)
|
|
val, ok := pathParams["deviceId"]
|
|
if !ok {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "deviceId")
|
|
}
|
|
protoReq.DeviceId, err = runtime.String(val)
|
|
if err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "deviceId", err)
|
|
}
|
|
val, ok = pathParams["channelId"]
|
|
if !ok {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "channelId")
|
|
}
|
|
protoReq.ChannelId, err = runtime.String(val)
|
|
if err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "channelId", err)
|
|
}
|
|
if err := req.ParseForm(); err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
|
|
}
|
|
if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Api_StartCruise_0); err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
|
|
}
|
|
msg, err := server.StartCruise(ctx, &protoReq)
|
|
return msg, metadata, err
|
|
}
|
|
|
|
var filter_Api_StopCruise_0 = &utilities.DoubleArray{Encoding: map[string]int{"deviceId": 0, "channelId": 1}, Base: []int{1, 1, 2, 0, 0}, Check: []int{0, 1, 1, 2, 3}}
|
|
|
|
func request_Api_StopCruise_0(ctx context.Context, marshaler runtime.Marshaler, client ApiClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
|
|
var (
|
|
protoReq CruiseRequest
|
|
metadata runtime.ServerMetadata
|
|
err error
|
|
)
|
|
io.Copy(io.Discard, req.Body)
|
|
val, ok := pathParams["deviceId"]
|
|
if !ok {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "deviceId")
|
|
}
|
|
protoReq.DeviceId, err = runtime.String(val)
|
|
if err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "deviceId", err)
|
|
}
|
|
val, ok = pathParams["channelId"]
|
|
if !ok {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "channelId")
|
|
}
|
|
protoReq.ChannelId, err = runtime.String(val)
|
|
if err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "channelId", err)
|
|
}
|
|
if err := req.ParseForm(); err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
|
|
}
|
|
if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Api_StopCruise_0); err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
|
|
}
|
|
msg, err := client.StopCruise(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
|
|
return msg, metadata, err
|
|
}
|
|
|
|
func local_request_Api_StopCruise_0(ctx context.Context, marshaler runtime.Marshaler, server ApiServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
|
|
var (
|
|
protoReq CruiseRequest
|
|
metadata runtime.ServerMetadata
|
|
err error
|
|
)
|
|
val, ok := pathParams["deviceId"]
|
|
if !ok {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "deviceId")
|
|
}
|
|
protoReq.DeviceId, err = runtime.String(val)
|
|
if err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "deviceId", err)
|
|
}
|
|
val, ok = pathParams["channelId"]
|
|
if !ok {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "channelId")
|
|
}
|
|
protoReq.ChannelId, err = runtime.String(val)
|
|
if err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "channelId", err)
|
|
}
|
|
if err := req.ParseForm(); err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
|
|
}
|
|
if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Api_StopCruise_0); err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
|
|
}
|
|
msg, err := server.StopCruise(ctx, &protoReq)
|
|
return msg, metadata, err
|
|
}
|
|
|
|
var filter_Api_StartScan_0 = &utilities.DoubleArray{Encoding: map[string]int{"deviceId": 0, "channelId": 1}, Base: []int{1, 1, 2, 0, 0}, Check: []int{0, 1, 1, 2, 3}}
|
|
|
|
func request_Api_StartScan_0(ctx context.Context, marshaler runtime.Marshaler, client ApiClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
|
|
var (
|
|
protoReq ScanRequest
|
|
metadata runtime.ServerMetadata
|
|
err error
|
|
)
|
|
io.Copy(io.Discard, req.Body)
|
|
val, ok := pathParams["deviceId"]
|
|
if !ok {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "deviceId")
|
|
}
|
|
protoReq.DeviceId, err = runtime.String(val)
|
|
if err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "deviceId", err)
|
|
}
|
|
val, ok = pathParams["channelId"]
|
|
if !ok {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "channelId")
|
|
}
|
|
protoReq.ChannelId, err = runtime.String(val)
|
|
if err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "channelId", err)
|
|
}
|
|
if err := req.ParseForm(); err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
|
|
}
|
|
if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Api_StartScan_0); err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
|
|
}
|
|
msg, err := client.StartScan(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
|
|
return msg, metadata, err
|
|
}
|
|
|
|
func local_request_Api_StartScan_0(ctx context.Context, marshaler runtime.Marshaler, server ApiServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
|
|
var (
|
|
protoReq ScanRequest
|
|
metadata runtime.ServerMetadata
|
|
err error
|
|
)
|
|
val, ok := pathParams["deviceId"]
|
|
if !ok {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "deviceId")
|
|
}
|
|
protoReq.DeviceId, err = runtime.String(val)
|
|
if err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "deviceId", err)
|
|
}
|
|
val, ok = pathParams["channelId"]
|
|
if !ok {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "channelId")
|
|
}
|
|
protoReq.ChannelId, err = runtime.String(val)
|
|
if err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "channelId", err)
|
|
}
|
|
if err := req.ParseForm(); err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
|
|
}
|
|
if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Api_StartScan_0); err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
|
|
}
|
|
msg, err := server.StartScan(ctx, &protoReq)
|
|
return msg, metadata, err
|
|
}
|
|
|
|
var filter_Api_StopScan_0 = &utilities.DoubleArray{Encoding: map[string]int{"deviceId": 0, "channelId": 1}, Base: []int{1, 1, 2, 0, 0}, Check: []int{0, 1, 1, 2, 3}}
|
|
|
|
func request_Api_StopScan_0(ctx context.Context, marshaler runtime.Marshaler, client ApiClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
|
|
var (
|
|
protoReq ScanRequest
|
|
metadata runtime.ServerMetadata
|
|
err error
|
|
)
|
|
io.Copy(io.Discard, req.Body)
|
|
val, ok := pathParams["deviceId"]
|
|
if !ok {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "deviceId")
|
|
}
|
|
protoReq.DeviceId, err = runtime.String(val)
|
|
if err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "deviceId", err)
|
|
}
|
|
val, ok = pathParams["channelId"]
|
|
if !ok {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "channelId")
|
|
}
|
|
protoReq.ChannelId, err = runtime.String(val)
|
|
if err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "channelId", err)
|
|
}
|
|
if err := req.ParseForm(); err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
|
|
}
|
|
if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Api_StopScan_0); err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
|
|
}
|
|
msg, err := client.StopScan(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
|
|
return msg, metadata, err
|
|
}
|
|
|
|
func local_request_Api_StopScan_0(ctx context.Context, marshaler runtime.Marshaler, server ApiServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
|
|
var (
|
|
protoReq ScanRequest
|
|
metadata runtime.ServerMetadata
|
|
err error
|
|
)
|
|
val, ok := pathParams["deviceId"]
|
|
if !ok {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "deviceId")
|
|
}
|
|
protoReq.DeviceId, err = runtime.String(val)
|
|
if err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "deviceId", err)
|
|
}
|
|
val, ok = pathParams["channelId"]
|
|
if !ok {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "channelId")
|
|
}
|
|
protoReq.ChannelId, err = runtime.String(val)
|
|
if err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "channelId", err)
|
|
}
|
|
if err := req.ParseForm(); err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
|
|
}
|
|
if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Api_StopScan_0); err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
|
|
}
|
|
msg, err := server.StopScan(ctx, &protoReq)
|
|
return msg, metadata, err
|
|
}
|
|
|
|
var filter_Api_SetScanLeft_0 = &utilities.DoubleArray{Encoding: map[string]int{"deviceId": 0, "channelId": 1}, Base: []int{1, 1, 2, 0, 0}, Check: []int{0, 1, 1, 2, 3}}
|
|
|
|
func request_Api_SetScanLeft_0(ctx context.Context, marshaler runtime.Marshaler, client ApiClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
|
|
var (
|
|
protoReq ScanRequest
|
|
metadata runtime.ServerMetadata
|
|
err error
|
|
)
|
|
io.Copy(io.Discard, req.Body)
|
|
val, ok := pathParams["deviceId"]
|
|
if !ok {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "deviceId")
|
|
}
|
|
protoReq.DeviceId, err = runtime.String(val)
|
|
if err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "deviceId", err)
|
|
}
|
|
val, ok = pathParams["channelId"]
|
|
if !ok {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "channelId")
|
|
}
|
|
protoReq.ChannelId, err = runtime.String(val)
|
|
if err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "channelId", err)
|
|
}
|
|
if err := req.ParseForm(); err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
|
|
}
|
|
if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Api_SetScanLeft_0); err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
|
|
}
|
|
msg, err := client.SetScanLeft(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
|
|
return msg, metadata, err
|
|
}
|
|
|
|
func local_request_Api_SetScanLeft_0(ctx context.Context, marshaler runtime.Marshaler, server ApiServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
|
|
var (
|
|
protoReq ScanRequest
|
|
metadata runtime.ServerMetadata
|
|
err error
|
|
)
|
|
val, ok := pathParams["deviceId"]
|
|
if !ok {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "deviceId")
|
|
}
|
|
protoReq.DeviceId, err = runtime.String(val)
|
|
if err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "deviceId", err)
|
|
}
|
|
val, ok = pathParams["channelId"]
|
|
if !ok {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "channelId")
|
|
}
|
|
protoReq.ChannelId, err = runtime.String(val)
|
|
if err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "channelId", err)
|
|
}
|
|
if err := req.ParseForm(); err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
|
|
}
|
|
if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Api_SetScanLeft_0); err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
|
|
}
|
|
msg, err := server.SetScanLeft(ctx, &protoReq)
|
|
return msg, metadata, err
|
|
}
|
|
|
|
var filter_Api_SetScanRight_0 = &utilities.DoubleArray{Encoding: map[string]int{"deviceId": 0, "channelId": 1}, Base: []int{1, 1, 2, 0, 0}, Check: []int{0, 1, 1, 2, 3}}
|
|
|
|
func request_Api_SetScanRight_0(ctx context.Context, marshaler runtime.Marshaler, client ApiClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
|
|
var (
|
|
protoReq ScanRequest
|
|
metadata runtime.ServerMetadata
|
|
err error
|
|
)
|
|
io.Copy(io.Discard, req.Body)
|
|
val, ok := pathParams["deviceId"]
|
|
if !ok {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "deviceId")
|
|
}
|
|
protoReq.DeviceId, err = runtime.String(val)
|
|
if err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "deviceId", err)
|
|
}
|
|
val, ok = pathParams["channelId"]
|
|
if !ok {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "channelId")
|
|
}
|
|
protoReq.ChannelId, err = runtime.String(val)
|
|
if err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "channelId", err)
|
|
}
|
|
if err := req.ParseForm(); err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
|
|
}
|
|
if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Api_SetScanRight_0); err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
|
|
}
|
|
msg, err := client.SetScanRight(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
|
|
return msg, metadata, err
|
|
}
|
|
|
|
func local_request_Api_SetScanRight_0(ctx context.Context, marshaler runtime.Marshaler, server ApiServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
|
|
var (
|
|
protoReq ScanRequest
|
|
metadata runtime.ServerMetadata
|
|
err error
|
|
)
|
|
val, ok := pathParams["deviceId"]
|
|
if !ok {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "deviceId")
|
|
}
|
|
protoReq.DeviceId, err = runtime.String(val)
|
|
if err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "deviceId", err)
|
|
}
|
|
val, ok = pathParams["channelId"]
|
|
if !ok {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "channelId")
|
|
}
|
|
protoReq.ChannelId, err = runtime.String(val)
|
|
if err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "channelId", err)
|
|
}
|
|
if err := req.ParseForm(); err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
|
|
}
|
|
if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Api_SetScanRight_0); err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
|
|
}
|
|
msg, err := server.SetScanRight(ctx, &protoReq)
|
|
return msg, metadata, err
|
|
}
|
|
|
|
var filter_Api_SetScanSpeed_0 = &utilities.DoubleArray{Encoding: map[string]int{"deviceId": 0, "channelId": 1}, Base: []int{1, 1, 2, 0, 0}, Check: []int{0, 1, 1, 2, 3}}
|
|
|
|
func request_Api_SetScanSpeed_0(ctx context.Context, marshaler runtime.Marshaler, client ApiClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
|
|
var (
|
|
protoReq ScanSpeedRequest
|
|
metadata runtime.ServerMetadata
|
|
err error
|
|
)
|
|
io.Copy(io.Discard, req.Body)
|
|
val, ok := pathParams["deviceId"]
|
|
if !ok {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "deviceId")
|
|
}
|
|
protoReq.DeviceId, err = runtime.String(val)
|
|
if err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "deviceId", err)
|
|
}
|
|
val, ok = pathParams["channelId"]
|
|
if !ok {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "channelId")
|
|
}
|
|
protoReq.ChannelId, err = runtime.String(val)
|
|
if err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "channelId", err)
|
|
}
|
|
if err := req.ParseForm(); err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
|
|
}
|
|
if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Api_SetScanSpeed_0); err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
|
|
}
|
|
msg, err := client.SetScanSpeed(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
|
|
return msg, metadata, err
|
|
}
|
|
|
|
func local_request_Api_SetScanSpeed_0(ctx context.Context, marshaler runtime.Marshaler, server ApiServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
|
|
var (
|
|
protoReq ScanSpeedRequest
|
|
metadata runtime.ServerMetadata
|
|
err error
|
|
)
|
|
val, ok := pathParams["deviceId"]
|
|
if !ok {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "deviceId")
|
|
}
|
|
protoReq.DeviceId, err = runtime.String(val)
|
|
if err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "deviceId", err)
|
|
}
|
|
val, ok = pathParams["channelId"]
|
|
if !ok {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "channelId")
|
|
}
|
|
protoReq.ChannelId, err = runtime.String(val)
|
|
if err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "channelId", err)
|
|
}
|
|
if err := req.ParseForm(); err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
|
|
}
|
|
if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Api_SetScanSpeed_0); err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
|
|
}
|
|
msg, err := server.SetScanSpeed(ctx, &protoReq)
|
|
return msg, metadata, err
|
|
}
|
|
|
|
var filter_Api_WiperControl_0 = &utilities.DoubleArray{Encoding: map[string]int{"deviceId": 0, "channelId": 1}, Base: []int{1, 1, 2, 0, 0}, Check: []int{0, 1, 1, 2, 3}}
|
|
|
|
func request_Api_WiperControl_0(ctx context.Context, marshaler runtime.Marshaler, client ApiClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
|
|
var (
|
|
protoReq WiperControlRequest
|
|
metadata runtime.ServerMetadata
|
|
err error
|
|
)
|
|
io.Copy(io.Discard, req.Body)
|
|
val, ok := pathParams["deviceId"]
|
|
if !ok {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "deviceId")
|
|
}
|
|
protoReq.DeviceId, err = runtime.String(val)
|
|
if err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "deviceId", err)
|
|
}
|
|
val, ok = pathParams["channelId"]
|
|
if !ok {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "channelId")
|
|
}
|
|
protoReq.ChannelId, err = runtime.String(val)
|
|
if err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "channelId", err)
|
|
}
|
|
if err := req.ParseForm(); err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
|
|
}
|
|
if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Api_WiperControl_0); err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
|
|
}
|
|
msg, err := client.WiperControl(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
|
|
return msg, metadata, err
|
|
}
|
|
|
|
func local_request_Api_WiperControl_0(ctx context.Context, marshaler runtime.Marshaler, server ApiServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
|
|
var (
|
|
protoReq WiperControlRequest
|
|
metadata runtime.ServerMetadata
|
|
err error
|
|
)
|
|
val, ok := pathParams["deviceId"]
|
|
if !ok {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "deviceId")
|
|
}
|
|
protoReq.DeviceId, err = runtime.String(val)
|
|
if err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "deviceId", err)
|
|
}
|
|
val, ok = pathParams["channelId"]
|
|
if !ok {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "channelId")
|
|
}
|
|
protoReq.ChannelId, err = runtime.String(val)
|
|
if err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "channelId", err)
|
|
}
|
|
if err := req.ParseForm(); err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
|
|
}
|
|
if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Api_WiperControl_0); err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
|
|
}
|
|
msg, err := server.WiperControl(ctx, &protoReq)
|
|
return msg, metadata, err
|
|
}
|
|
|
|
var filter_Api_AuxiliaryControl_0 = &utilities.DoubleArray{Encoding: map[string]int{"deviceId": 0, "channelId": 1}, Base: []int{1, 1, 2, 0, 0}, Check: []int{0, 1, 1, 2, 3}}
|
|
|
|
func request_Api_AuxiliaryControl_0(ctx context.Context, marshaler runtime.Marshaler, client ApiClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
|
|
var (
|
|
protoReq AuxiliaryControlRequest
|
|
metadata runtime.ServerMetadata
|
|
err error
|
|
)
|
|
io.Copy(io.Discard, req.Body)
|
|
val, ok := pathParams["deviceId"]
|
|
if !ok {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "deviceId")
|
|
}
|
|
protoReq.DeviceId, err = runtime.String(val)
|
|
if err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "deviceId", err)
|
|
}
|
|
val, ok = pathParams["channelId"]
|
|
if !ok {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "channelId")
|
|
}
|
|
protoReq.ChannelId, err = runtime.String(val)
|
|
if err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "channelId", err)
|
|
}
|
|
if err := req.ParseForm(); err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
|
|
}
|
|
if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Api_AuxiliaryControl_0); err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
|
|
}
|
|
msg, err := client.AuxiliaryControl(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
|
|
return msg, metadata, err
|
|
}
|
|
|
|
func local_request_Api_AuxiliaryControl_0(ctx context.Context, marshaler runtime.Marshaler, server ApiServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
|
|
var (
|
|
protoReq AuxiliaryControlRequest
|
|
metadata runtime.ServerMetadata
|
|
err error
|
|
)
|
|
val, ok := pathParams["deviceId"]
|
|
if !ok {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "deviceId")
|
|
}
|
|
protoReq.DeviceId, err = runtime.String(val)
|
|
if err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "deviceId", err)
|
|
}
|
|
val, ok = pathParams["channelId"]
|
|
if !ok {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "channelId")
|
|
}
|
|
protoReq.ChannelId, err = runtime.String(val)
|
|
if err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "channelId", err)
|
|
}
|
|
if err := req.ParseForm(); err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
|
|
}
|
|
if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Api_AuxiliaryControl_0); err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
|
|
}
|
|
msg, err := server.AuxiliaryControl(ctx, &protoReq)
|
|
return msg, metadata, err
|
|
}
|
|
|
|
var filter_Api_TestSip_0 = &utilities.DoubleArray{Encoding: map[string]int{}, Base: []int(nil), Check: []int(nil)}
|
|
|
|
func request_Api_TestSip_0(ctx context.Context, marshaler runtime.Marshaler, client ApiClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
|
|
var (
|
|
protoReq TestSipRequest
|
|
metadata runtime.ServerMetadata
|
|
)
|
|
io.Copy(io.Discard, req.Body)
|
|
if err := req.ParseForm(); err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
|
|
}
|
|
if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Api_TestSip_0); err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
|
|
}
|
|
msg, err := client.TestSip(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
|
|
return msg, metadata, err
|
|
}
|
|
|
|
func local_request_Api_TestSip_0(ctx context.Context, marshaler runtime.Marshaler, server ApiServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
|
|
var (
|
|
protoReq TestSipRequest
|
|
metadata runtime.ServerMetadata
|
|
)
|
|
if err := req.ParseForm(); err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
|
|
}
|
|
if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Api_TestSip_0); err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
|
|
}
|
|
msg, err := server.TestSip(ctx, &protoReq)
|
|
return msg, metadata, err
|
|
}
|
|
|
|
var filter_Api_SearchAlarms_0 = &utilities.DoubleArray{Encoding: map[string]int{"deviceId": 0}, Base: []int{1, 1, 0}, Check: []int{0, 1, 2}}
|
|
|
|
func request_Api_SearchAlarms_0(ctx context.Context, marshaler runtime.Marshaler, client ApiClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
|
|
var (
|
|
protoReq SearchAlarmsRequest
|
|
metadata runtime.ServerMetadata
|
|
err error
|
|
)
|
|
io.Copy(io.Discard, req.Body)
|
|
val, ok := pathParams["deviceId"]
|
|
if !ok {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "deviceId")
|
|
}
|
|
protoReq.DeviceId, err = runtime.String(val)
|
|
if err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "deviceId", err)
|
|
}
|
|
if err := req.ParseForm(); err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
|
|
}
|
|
if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Api_SearchAlarms_0); err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
|
|
}
|
|
msg, err := client.SearchAlarms(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
|
|
return msg, metadata, err
|
|
}
|
|
|
|
func local_request_Api_SearchAlarms_0(ctx context.Context, marshaler runtime.Marshaler, server ApiServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
|
|
var (
|
|
protoReq SearchAlarmsRequest
|
|
metadata runtime.ServerMetadata
|
|
err error
|
|
)
|
|
val, ok := pathParams["deviceId"]
|
|
if !ok {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "deviceId")
|
|
}
|
|
protoReq.DeviceId, err = runtime.String(val)
|
|
if err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "deviceId", err)
|
|
}
|
|
if err := req.ParseForm(); err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
|
|
}
|
|
if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Api_SearchAlarms_0); err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
|
|
}
|
|
msg, err := server.SearchAlarms(ctx, &protoReq)
|
|
return msg, metadata, err
|
|
}
|
|
|
|
func request_Api_AddPlatformChannel_0(ctx context.Context, marshaler runtime.Marshaler, client ApiClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
|
|
var (
|
|
protoReq AddPlatformChannelRequest
|
|
metadata runtime.ServerMetadata
|
|
)
|
|
if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && !errors.Is(err, io.EOF) {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
|
|
}
|
|
msg, err := client.AddPlatformChannel(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
|
|
return msg, metadata, err
|
|
}
|
|
|
|
func local_request_Api_AddPlatformChannel_0(ctx context.Context, marshaler runtime.Marshaler, server ApiServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
|
|
var (
|
|
protoReq AddPlatformChannelRequest
|
|
metadata runtime.ServerMetadata
|
|
)
|
|
if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && !errors.Is(err, io.EOF) {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
|
|
}
|
|
msg, err := server.AddPlatformChannel(ctx, &protoReq)
|
|
return msg, metadata, err
|
|
}
|
|
|
|
func request_Api_Recording_0(ctx context.Context, marshaler runtime.Marshaler, client ApiClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
|
|
var (
|
|
protoReq RecordingRequest
|
|
metadata runtime.ServerMetadata
|
|
err error
|
|
)
|
|
io.Copy(io.Discard, req.Body)
|
|
val, ok := pathParams["cmdType"]
|
|
if !ok {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "cmdType")
|
|
}
|
|
protoReq.CmdType, err = runtime.String(val)
|
|
if err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "cmdType", err)
|
|
}
|
|
val, ok = pathParams["deviceId"]
|
|
if !ok {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "deviceId")
|
|
}
|
|
protoReq.DeviceId, err = runtime.String(val)
|
|
if err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "deviceId", err)
|
|
}
|
|
val, ok = pathParams["channelId"]
|
|
if !ok {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "channelId")
|
|
}
|
|
protoReq.ChannelId, err = runtime.String(val)
|
|
if err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "channelId", err)
|
|
}
|
|
msg, err := client.Recording(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
|
|
return msg, metadata, err
|
|
}
|
|
|
|
func local_request_Api_Recording_0(ctx context.Context, marshaler runtime.Marshaler, server ApiServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
|
|
var (
|
|
protoReq RecordingRequest
|
|
metadata runtime.ServerMetadata
|
|
err error
|
|
)
|
|
val, ok := pathParams["cmdType"]
|
|
if !ok {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "cmdType")
|
|
}
|
|
protoReq.CmdType, err = runtime.String(val)
|
|
if err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "cmdType", err)
|
|
}
|
|
val, ok = pathParams["deviceId"]
|
|
if !ok {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "deviceId")
|
|
}
|
|
protoReq.DeviceId, err = runtime.String(val)
|
|
if err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "deviceId", err)
|
|
}
|
|
val, ok = pathParams["channelId"]
|
|
if !ok {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "channelId")
|
|
}
|
|
protoReq.ChannelId, err = runtime.String(val)
|
|
if err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "channelId", err)
|
|
}
|
|
msg, err := server.Recording(ctx, &protoReq)
|
|
return msg, metadata, err
|
|
}
|
|
|
|
func request_Api_UploadJpeg_0(ctx context.Context, marshaler runtime.Marshaler, client ApiClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
|
|
var (
|
|
protoReq UploadJpegRequest
|
|
metadata runtime.ServerMetadata
|
|
)
|
|
if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && !errors.Is(err, io.EOF) {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
|
|
}
|
|
msg, err := client.UploadJpeg(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
|
|
return msg, metadata, err
|
|
}
|
|
|
|
func local_request_Api_UploadJpeg_0(ctx context.Context, marshaler runtime.Marshaler, server ApiServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
|
|
var (
|
|
protoReq UploadJpegRequest
|
|
metadata runtime.ServerMetadata
|
|
)
|
|
if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && !errors.Is(err, io.EOF) {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
|
|
}
|
|
msg, err := server.UploadJpeg(ctx, &protoReq)
|
|
return msg, metadata, err
|
|
}
|
|
|
|
func request_Api_UpdateChannel_0(ctx context.Context, marshaler runtime.Marshaler, client ApiClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
|
|
var (
|
|
protoReq UpdateChannelRequest
|
|
metadata runtime.ServerMetadata
|
|
err error
|
|
)
|
|
if err := marshaler.NewDecoder(req.Body).Decode(&protoReq.Channel); err != nil && !errors.Is(err, io.EOF) {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
|
|
}
|
|
val, ok := pathParams["id"]
|
|
if !ok {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "id")
|
|
}
|
|
protoReq.Id, err = runtime.String(val)
|
|
if err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "id", err)
|
|
}
|
|
msg, err := client.UpdateChannel(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
|
|
return msg, metadata, err
|
|
}
|
|
|
|
func local_request_Api_UpdateChannel_0(ctx context.Context, marshaler runtime.Marshaler, server ApiServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
|
|
var (
|
|
protoReq UpdateChannelRequest
|
|
metadata runtime.ServerMetadata
|
|
err error
|
|
)
|
|
if err := marshaler.NewDecoder(req.Body).Decode(&protoReq.Channel); err != nil && !errors.Is(err, io.EOF) {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
|
|
}
|
|
val, ok := pathParams["id"]
|
|
if !ok {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "id")
|
|
}
|
|
protoReq.Id, err = runtime.String(val)
|
|
if err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "id", err)
|
|
}
|
|
msg, err := server.UpdateChannel(ctx, &protoReq)
|
|
return msg, metadata, err
|
|
}
|
|
|
|
var filter_Api_PlaybackPause_0 = &utilities.DoubleArray{Encoding: map[string]int{}, Base: []int(nil), Check: []int(nil)}
|
|
|
|
func request_Api_PlaybackPause_0(ctx context.Context, marshaler runtime.Marshaler, client ApiClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
|
|
var (
|
|
protoReq PlaybackPauseRequest
|
|
metadata runtime.ServerMetadata
|
|
)
|
|
io.Copy(io.Discard, req.Body)
|
|
if err := req.ParseForm(); err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
|
|
}
|
|
if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Api_PlaybackPause_0); err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
|
|
}
|
|
msg, err := client.PlaybackPause(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
|
|
return msg, metadata, err
|
|
}
|
|
|
|
func local_request_Api_PlaybackPause_0(ctx context.Context, marshaler runtime.Marshaler, server ApiServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
|
|
var (
|
|
protoReq PlaybackPauseRequest
|
|
metadata runtime.ServerMetadata
|
|
)
|
|
if err := req.ParseForm(); err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
|
|
}
|
|
if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Api_PlaybackPause_0); err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
|
|
}
|
|
msg, err := server.PlaybackPause(ctx, &protoReq)
|
|
return msg, metadata, err
|
|
}
|
|
|
|
var filter_Api_PlaybackResume_0 = &utilities.DoubleArray{Encoding: map[string]int{}, Base: []int(nil), Check: []int(nil)}
|
|
|
|
func request_Api_PlaybackResume_0(ctx context.Context, marshaler runtime.Marshaler, client ApiClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
|
|
var (
|
|
protoReq PlaybackResumeRequest
|
|
metadata runtime.ServerMetadata
|
|
)
|
|
io.Copy(io.Discard, req.Body)
|
|
if err := req.ParseForm(); err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
|
|
}
|
|
if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Api_PlaybackResume_0); err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
|
|
}
|
|
msg, err := client.PlaybackResume(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
|
|
return msg, metadata, err
|
|
}
|
|
|
|
func local_request_Api_PlaybackResume_0(ctx context.Context, marshaler runtime.Marshaler, server ApiServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
|
|
var (
|
|
protoReq PlaybackResumeRequest
|
|
metadata runtime.ServerMetadata
|
|
)
|
|
if err := req.ParseForm(); err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
|
|
}
|
|
if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Api_PlaybackResume_0); err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
|
|
}
|
|
msg, err := server.PlaybackResume(ctx, &protoReq)
|
|
return msg, metadata, err
|
|
}
|
|
|
|
var filter_Api_PlaybackSeek_0 = &utilities.DoubleArray{Encoding: map[string]int{}, Base: []int(nil), Check: []int(nil)}
|
|
|
|
func request_Api_PlaybackSeek_0(ctx context.Context, marshaler runtime.Marshaler, client ApiClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
|
|
var (
|
|
protoReq PlaybackSeekRequest
|
|
metadata runtime.ServerMetadata
|
|
)
|
|
io.Copy(io.Discard, req.Body)
|
|
if err := req.ParseForm(); err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
|
|
}
|
|
if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Api_PlaybackSeek_0); err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
|
|
}
|
|
msg, err := client.PlaybackSeek(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
|
|
return msg, metadata, err
|
|
}
|
|
|
|
func local_request_Api_PlaybackSeek_0(ctx context.Context, marshaler runtime.Marshaler, server ApiServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
|
|
var (
|
|
protoReq PlaybackSeekRequest
|
|
metadata runtime.ServerMetadata
|
|
)
|
|
if err := req.ParseForm(); err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
|
|
}
|
|
if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Api_PlaybackSeek_0); err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
|
|
}
|
|
msg, err := server.PlaybackSeek(ctx, &protoReq)
|
|
return msg, metadata, err
|
|
}
|
|
|
|
var filter_Api_PlaybackSpeed_0 = &utilities.DoubleArray{Encoding: map[string]int{}, Base: []int(nil), Check: []int(nil)}
|
|
|
|
func request_Api_PlaybackSpeed_0(ctx context.Context, marshaler runtime.Marshaler, client ApiClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
|
|
var (
|
|
protoReq PlaybackSpeedRequest
|
|
metadata runtime.ServerMetadata
|
|
)
|
|
io.Copy(io.Discard, req.Body)
|
|
if err := req.ParseForm(); err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
|
|
}
|
|
if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Api_PlaybackSpeed_0); err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
|
|
}
|
|
msg, err := client.PlaybackSpeed(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
|
|
return msg, metadata, err
|
|
}
|
|
|
|
func local_request_Api_PlaybackSpeed_0(ctx context.Context, marshaler runtime.Marshaler, server ApiServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
|
|
var (
|
|
protoReq PlaybackSpeedRequest
|
|
metadata runtime.ServerMetadata
|
|
)
|
|
if err := req.ParseForm(); err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
|
|
}
|
|
if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Api_PlaybackSpeed_0); err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
|
|
}
|
|
msg, err := server.PlaybackSpeed(ctx, &protoReq)
|
|
return msg, metadata, err
|
|
}
|
|
|
|
func request_Api_GetGroups_0(ctx context.Context, marshaler runtime.Marshaler, client ApiClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
|
|
var (
|
|
protoReq GetGroupsRequest
|
|
metadata runtime.ServerMetadata
|
|
err error
|
|
)
|
|
io.Copy(io.Discard, req.Body)
|
|
val, ok := pathParams["pid"]
|
|
if !ok {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "pid")
|
|
}
|
|
protoReq.Pid, err = runtime.Int32(val)
|
|
if err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "pid", err)
|
|
}
|
|
msg, err := client.GetGroups(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
|
|
return msg, metadata, err
|
|
}
|
|
|
|
func local_request_Api_GetGroups_0(ctx context.Context, marshaler runtime.Marshaler, server ApiServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
|
|
var (
|
|
protoReq GetGroupsRequest
|
|
metadata runtime.ServerMetadata
|
|
err error
|
|
)
|
|
val, ok := pathParams["pid"]
|
|
if !ok {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "pid")
|
|
}
|
|
protoReq.Pid, err = runtime.Int32(val)
|
|
if err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "pid", err)
|
|
}
|
|
msg, err := server.GetGroups(ctx, &protoReq)
|
|
return msg, metadata, err
|
|
}
|
|
|
|
func request_Api_AddGroup_0(ctx context.Context, marshaler runtime.Marshaler, client ApiClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
|
|
var (
|
|
protoReq Group
|
|
metadata runtime.ServerMetadata
|
|
)
|
|
if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && !errors.Is(err, io.EOF) {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
|
|
}
|
|
msg, err := client.AddGroup(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
|
|
return msg, metadata, err
|
|
}
|
|
|
|
func local_request_Api_AddGroup_0(ctx context.Context, marshaler runtime.Marshaler, server ApiServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
|
|
var (
|
|
protoReq Group
|
|
metadata runtime.ServerMetadata
|
|
)
|
|
if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && !errors.Is(err, io.EOF) {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
|
|
}
|
|
msg, err := server.AddGroup(ctx, &protoReq)
|
|
return msg, metadata, err
|
|
}
|
|
|
|
func request_Api_UpdateGroup_0(ctx context.Context, marshaler runtime.Marshaler, client ApiClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
|
|
var (
|
|
protoReq Group
|
|
metadata runtime.ServerMetadata
|
|
)
|
|
if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && !errors.Is(err, io.EOF) {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
|
|
}
|
|
msg, err := client.UpdateGroup(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
|
|
return msg, metadata, err
|
|
}
|
|
|
|
func local_request_Api_UpdateGroup_0(ctx context.Context, marshaler runtime.Marshaler, server ApiServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
|
|
var (
|
|
protoReq Group
|
|
metadata runtime.ServerMetadata
|
|
)
|
|
if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && !errors.Is(err, io.EOF) {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
|
|
}
|
|
msg, err := server.UpdateGroup(ctx, &protoReq)
|
|
return msg, metadata, err
|
|
}
|
|
|
|
func request_Api_DeleteGroup_0(ctx context.Context, marshaler runtime.Marshaler, client ApiClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
|
|
var (
|
|
protoReq DeleteGroupRequest
|
|
metadata runtime.ServerMetadata
|
|
err error
|
|
)
|
|
io.Copy(io.Discard, req.Body)
|
|
val, ok := pathParams["id"]
|
|
if !ok {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "id")
|
|
}
|
|
protoReq.Id, err = runtime.Int32(val)
|
|
if err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "id", err)
|
|
}
|
|
msg, err := client.DeleteGroup(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
|
|
return msg, metadata, err
|
|
}
|
|
|
|
func local_request_Api_DeleteGroup_0(ctx context.Context, marshaler runtime.Marshaler, server ApiServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
|
|
var (
|
|
protoReq DeleteGroupRequest
|
|
metadata runtime.ServerMetadata
|
|
err error
|
|
)
|
|
val, ok := pathParams["id"]
|
|
if !ok {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "id")
|
|
}
|
|
protoReq.Id, err = runtime.Int32(val)
|
|
if err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "id", err)
|
|
}
|
|
msg, err := server.DeleteGroup(ctx, &protoReq)
|
|
return msg, metadata, err
|
|
}
|
|
|
|
func request_Api_AddGroupChannel_0(ctx context.Context, marshaler runtime.Marshaler, client ApiClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
|
|
var (
|
|
protoReq AddGroupChannelRequest
|
|
metadata runtime.ServerMetadata
|
|
err error
|
|
)
|
|
if err := marshaler.NewDecoder(req.Body).Decode(&protoReq.Channels); err != nil && !errors.Is(err, io.EOF) {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
|
|
}
|
|
val, ok := pathParams["groupId"]
|
|
if !ok {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "groupId")
|
|
}
|
|
protoReq.GroupId, err = runtime.Int32(val)
|
|
if err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "groupId", err)
|
|
}
|
|
msg, err := client.AddGroupChannel(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
|
|
return msg, metadata, err
|
|
}
|
|
|
|
func local_request_Api_AddGroupChannel_0(ctx context.Context, marshaler runtime.Marshaler, server ApiServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
|
|
var (
|
|
protoReq AddGroupChannelRequest
|
|
metadata runtime.ServerMetadata
|
|
err error
|
|
)
|
|
if err := marshaler.NewDecoder(req.Body).Decode(&protoReq.Channels); err != nil && !errors.Is(err, io.EOF) {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
|
|
}
|
|
val, ok := pathParams["groupId"]
|
|
if !ok {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "groupId")
|
|
}
|
|
protoReq.GroupId, err = runtime.Int32(val)
|
|
if err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "groupId", err)
|
|
}
|
|
msg, err := server.AddGroupChannel(ctx, &protoReq)
|
|
return msg, metadata, err
|
|
}
|
|
|
|
func request_Api_DeleteGroupChannel_0(ctx context.Context, marshaler runtime.Marshaler, client ApiClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
|
|
var (
|
|
protoReq DeleteGroupChannelRequest
|
|
metadata runtime.ServerMetadata
|
|
err error
|
|
)
|
|
if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && !errors.Is(err, io.EOF) {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
|
|
}
|
|
val, ok := pathParams["groupId"]
|
|
if !ok {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "groupId")
|
|
}
|
|
protoReq.GroupId, err = runtime.Int32(val)
|
|
if err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "groupId", err)
|
|
}
|
|
msg, err := client.DeleteGroupChannel(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
|
|
return msg, metadata, err
|
|
}
|
|
|
|
func local_request_Api_DeleteGroupChannel_0(ctx context.Context, marshaler runtime.Marshaler, server ApiServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
|
|
var (
|
|
protoReq DeleteGroupChannelRequest
|
|
metadata runtime.ServerMetadata
|
|
err error
|
|
)
|
|
if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && !errors.Is(err, io.EOF) {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
|
|
}
|
|
val, ok := pathParams["groupId"]
|
|
if !ok {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "groupId")
|
|
}
|
|
protoReq.GroupId, err = runtime.Int32(val)
|
|
if err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "groupId", err)
|
|
}
|
|
msg, err := server.DeleteGroupChannel(ctx, &protoReq)
|
|
return msg, metadata, err
|
|
}
|
|
|
|
var filter_Api_GetGroupChannels_0 = &utilities.DoubleArray{Encoding: map[string]int{"groupId": 0}, Base: []int{1, 1, 0}, Check: []int{0, 1, 2}}
|
|
|
|
func request_Api_GetGroupChannels_0(ctx context.Context, marshaler runtime.Marshaler, client ApiClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
|
|
var (
|
|
protoReq GetGroupChannelsRequest
|
|
metadata runtime.ServerMetadata
|
|
err error
|
|
)
|
|
io.Copy(io.Discard, req.Body)
|
|
val, ok := pathParams["groupId"]
|
|
if !ok {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "groupId")
|
|
}
|
|
protoReq.GroupId, err = runtime.Int32(val)
|
|
if err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "groupId", err)
|
|
}
|
|
if err := req.ParseForm(); err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
|
|
}
|
|
if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Api_GetGroupChannels_0); err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
|
|
}
|
|
msg, err := client.GetGroupChannels(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
|
|
return msg, metadata, err
|
|
}
|
|
|
|
func local_request_Api_GetGroupChannels_0(ctx context.Context, marshaler runtime.Marshaler, server ApiServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
|
|
var (
|
|
protoReq GetGroupChannelsRequest
|
|
metadata runtime.ServerMetadata
|
|
err error
|
|
)
|
|
val, ok := pathParams["groupId"]
|
|
if !ok {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "groupId")
|
|
}
|
|
protoReq.GroupId, err = runtime.Int32(val)
|
|
if err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "groupId", err)
|
|
}
|
|
if err := req.ParseForm(); err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
|
|
}
|
|
if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_Api_GetGroupChannels_0); err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
|
|
}
|
|
msg, err := server.GetGroupChannels(ctx, &protoReq)
|
|
return msg, metadata, err
|
|
}
|
|
|
|
func request_Api_RemoveDevice_0(ctx context.Context, marshaler runtime.Marshaler, client ApiClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
|
|
var (
|
|
protoReq RemoveDeviceRequest
|
|
metadata runtime.ServerMetadata
|
|
err error
|
|
)
|
|
io.Copy(io.Discard, req.Body)
|
|
val, ok := pathParams["id"]
|
|
if !ok {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "id")
|
|
}
|
|
protoReq.Id, err = runtime.String(val)
|
|
if err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "id", err)
|
|
}
|
|
msg, err := client.RemoveDevice(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
|
|
return msg, metadata, err
|
|
}
|
|
|
|
func local_request_Api_RemoveDevice_0(ctx context.Context, marshaler runtime.Marshaler, server ApiServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
|
|
var (
|
|
protoReq RemoveDeviceRequest
|
|
metadata runtime.ServerMetadata
|
|
err error
|
|
)
|
|
val, ok := pathParams["id"]
|
|
if !ok {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "id")
|
|
}
|
|
protoReq.Id, err = runtime.String(val)
|
|
if err != nil {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "id", err)
|
|
}
|
|
msg, err := server.RemoveDevice(ctx, &protoReq)
|
|
return msg, metadata, err
|
|
}
|
|
|
|
func request_Api_ReceiveAlarm_0(ctx context.Context, marshaler runtime.Marshaler, client ApiClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
|
|
var (
|
|
protoReq AlarmInfoRequest
|
|
metadata runtime.ServerMetadata
|
|
)
|
|
if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && !errors.Is(err, io.EOF) {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
|
|
}
|
|
msg, err := client.ReceiveAlarm(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
|
|
return msg, metadata, err
|
|
}
|
|
|
|
func local_request_Api_ReceiveAlarm_0(ctx context.Context, marshaler runtime.Marshaler, server ApiServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
|
|
var (
|
|
protoReq AlarmInfoRequest
|
|
metadata runtime.ServerMetadata
|
|
)
|
|
if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && !errors.Is(err, io.EOF) {
|
|
return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)
|
|
}
|
|
msg, err := server.ReceiveAlarm(ctx, &protoReq)
|
|
return msg, metadata, err
|
|
}
|
|
|
|
// RegisterApiHandlerServer registers the http handlers for service Api to "mux".
|
|
// UnaryRPC :call ApiServer directly.
|
|
// StreamingRPC :currently unsupported pending https://github.com/grpc/grpc-go/issues/906.
|
|
// Note that using this registration option will cause many gRPC library features to stop working. Consider using RegisterApiHandlerFromEndpoint instead.
|
|
// GRPC interceptors will not work for this type of registration. To use interceptors, you must use the "runtime.WithMiddlewares" option in the "runtime.NewServeMux" call.
|
|
func RegisterApiHandlerServer(ctx context.Context, mux *runtime.ServeMux, server ApiServer) error {
|
|
mux.Handle(http.MethodGet, pattern_Api_List_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
|
|
ctx, cancel := context.WithCancel(req.Context())
|
|
defer cancel()
|
|
var stream runtime.ServerTransportStream
|
|
ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
|
|
inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
|
|
annotatedContext, err := runtime.AnnotateIncomingContext(ctx, mux, req, "/gb28181pro.Api/List", runtime.WithHTTPPathPattern("/gb28181/api/list"))
|
|
if err != nil {
|
|
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
resp, md, err := local_request_Api_List_0(annotatedContext, inboundMarshaler, server, req, pathParams)
|
|
md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
|
|
annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
|
|
if err != nil {
|
|
runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
forward_Api_List_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
|
|
})
|
|
mux.Handle(http.MethodGet, pattern_Api_GetDevice_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
|
|
ctx, cancel := context.WithCancel(req.Context())
|
|
defer cancel()
|
|
var stream runtime.ServerTransportStream
|
|
ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
|
|
inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
|
|
annotatedContext, err := runtime.AnnotateIncomingContext(ctx, mux, req, "/gb28181pro.Api/GetDevice", runtime.WithHTTPPathPattern("/gb28181/api/devices/{deviceId}"))
|
|
if err != nil {
|
|
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
resp, md, err := local_request_Api_GetDevice_0(annotatedContext, inboundMarshaler, server, req, pathParams)
|
|
md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
|
|
annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
|
|
if err != nil {
|
|
runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
forward_Api_GetDevice_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
|
|
})
|
|
mux.Handle(http.MethodGet, pattern_Api_GetDevices_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
|
|
ctx, cancel := context.WithCancel(req.Context())
|
|
defer cancel()
|
|
var stream runtime.ServerTransportStream
|
|
ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
|
|
inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
|
|
annotatedContext, err := runtime.AnnotateIncomingContext(ctx, mux, req, "/gb28181pro.Api/GetDevices", runtime.WithHTTPPathPattern("/gb28181/api/devices"))
|
|
if err != nil {
|
|
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
resp, md, err := local_request_Api_GetDevices_0(annotatedContext, inboundMarshaler, server, req, pathParams)
|
|
md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
|
|
annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
|
|
if err != nil {
|
|
runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
forward_Api_GetDevices_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
|
|
})
|
|
mux.Handle(http.MethodGet, pattern_Api_GetChannels_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
|
|
ctx, cancel := context.WithCancel(req.Context())
|
|
defer cancel()
|
|
var stream runtime.ServerTransportStream
|
|
ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
|
|
inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
|
|
annotatedContext, err := runtime.AnnotateIncomingContext(ctx, mux, req, "/gb28181pro.Api/GetChannels", runtime.WithHTTPPathPattern("/gb28181/api/devices/{deviceId}/channels"))
|
|
if err != nil {
|
|
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
resp, md, err := local_request_Api_GetChannels_0(annotatedContext, inboundMarshaler, server, req, pathParams)
|
|
md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
|
|
annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
|
|
if err != nil {
|
|
runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
forward_Api_GetChannels_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
|
|
})
|
|
mux.Handle(http.MethodGet, pattern_Api_SyncDevice_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
|
|
ctx, cancel := context.WithCancel(req.Context())
|
|
defer cancel()
|
|
var stream runtime.ServerTransportStream
|
|
ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
|
|
inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
|
|
annotatedContext, err := runtime.AnnotateIncomingContext(ctx, mux, req, "/gb28181pro.Api/SyncDevice", runtime.WithHTTPPathPattern("/gb28181/api/devices/{deviceId}/sync"))
|
|
if err != nil {
|
|
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
resp, md, err := local_request_Api_SyncDevice_0(annotatedContext, inboundMarshaler, server, req, pathParams)
|
|
md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
|
|
annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
|
|
if err != nil {
|
|
runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
forward_Api_SyncDevice_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
|
|
})
|
|
mux.Handle(http.MethodDelete, pattern_Api_DeleteDevice_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
|
|
ctx, cancel := context.WithCancel(req.Context())
|
|
defer cancel()
|
|
var stream runtime.ServerTransportStream
|
|
ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
|
|
inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
|
|
annotatedContext, err := runtime.AnnotateIncomingContext(ctx, mux, req, "/gb28181pro.Api/DeleteDevice", runtime.WithHTTPPathPattern("/gb28181/api/devices/{deviceId}/delete"))
|
|
if err != nil {
|
|
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
resp, md, err := local_request_Api_DeleteDevice_0(annotatedContext, inboundMarshaler, server, req, pathParams)
|
|
md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
|
|
annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
|
|
if err != nil {
|
|
runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
forward_Api_DeleteDevice_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
|
|
})
|
|
mux.Handle(http.MethodGet, pattern_Api_GetSubChannels_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
|
|
ctx, cancel := context.WithCancel(req.Context())
|
|
defer cancel()
|
|
var stream runtime.ServerTransportStream
|
|
ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
|
|
inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
|
|
annotatedContext, err := runtime.AnnotateIncomingContext(ctx, mux, req, "/gb28181pro.Api/GetSubChannels", runtime.WithHTTPPathPattern("/gb28181/api/sub_channels/{deviceId}/{channelId}/channels"))
|
|
if err != nil {
|
|
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
resp, md, err := local_request_Api_GetSubChannels_0(annotatedContext, inboundMarshaler, server, req, pathParams)
|
|
md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
|
|
annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
|
|
if err != nil {
|
|
runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
forward_Api_GetSubChannels_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
|
|
})
|
|
mux.Handle(http.MethodPost, pattern_Api_ChangeAudio_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
|
|
ctx, cancel := context.WithCancel(req.Context())
|
|
defer cancel()
|
|
var stream runtime.ServerTransportStream
|
|
ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
|
|
inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
|
|
annotatedContext, err := runtime.AnnotateIncomingContext(ctx, mux, req, "/gb28181pro.Api/ChangeAudio", runtime.WithHTTPPathPattern("/gb28181/api/channel/audio"))
|
|
if err != nil {
|
|
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
resp, md, err := local_request_Api_ChangeAudio_0(annotatedContext, inboundMarshaler, server, req, pathParams)
|
|
md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
|
|
annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
|
|
if err != nil {
|
|
runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
forward_Api_ChangeAudio_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
|
|
})
|
|
mux.Handle(http.MethodPost, pattern_Api_UpdateChannelStreamIdentification_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
|
|
ctx, cancel := context.WithCancel(req.Context())
|
|
defer cancel()
|
|
var stream runtime.ServerTransportStream
|
|
ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
|
|
inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
|
|
annotatedContext, err := runtime.AnnotateIncomingContext(ctx, mux, req, "/gb28181pro.Api/UpdateChannelStreamIdentification", runtime.WithHTTPPathPattern("/gb28181/api/channel/stream/identification/update"))
|
|
if err != nil {
|
|
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
resp, md, err := local_request_Api_UpdateChannelStreamIdentification_0(annotatedContext, inboundMarshaler, server, req, pathParams)
|
|
md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
|
|
annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
|
|
if err != nil {
|
|
runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
forward_Api_UpdateChannelStreamIdentification_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
|
|
})
|
|
mux.Handle(http.MethodPost, pattern_Api_UpdateTransport_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
|
|
ctx, cancel := context.WithCancel(req.Context())
|
|
defer cancel()
|
|
var stream runtime.ServerTransportStream
|
|
ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
|
|
inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
|
|
annotatedContext, err := runtime.AnnotateIncomingContext(ctx, mux, req, "/gb28181pro.Api/UpdateTransport", runtime.WithHTTPPathPattern("/gb28181/api/transport/{deviceId}/{streamMode}"))
|
|
if err != nil {
|
|
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
resp, md, err := local_request_Api_UpdateTransport_0(annotatedContext, inboundMarshaler, server, req, pathParams)
|
|
md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
|
|
annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
|
|
if err != nil {
|
|
runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
forward_Api_UpdateTransport_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
|
|
})
|
|
mux.Handle(http.MethodPost, pattern_Api_AddDevice_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
|
|
ctx, cancel := context.WithCancel(req.Context())
|
|
defer cancel()
|
|
var stream runtime.ServerTransportStream
|
|
ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
|
|
inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
|
|
annotatedContext, err := runtime.AnnotateIncomingContext(ctx, mux, req, "/gb28181pro.Api/AddDevice", runtime.WithHTTPPathPattern("/gb28181/api/device/add"))
|
|
if err != nil {
|
|
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
resp, md, err := local_request_Api_AddDevice_0(annotatedContext, inboundMarshaler, server, req, pathParams)
|
|
md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
|
|
annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
|
|
if err != nil {
|
|
runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
forward_Api_AddDevice_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
|
|
})
|
|
mux.Handle(http.MethodPost, pattern_Api_UpdateDevice_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
|
|
ctx, cancel := context.WithCancel(req.Context())
|
|
defer cancel()
|
|
var stream runtime.ServerTransportStream
|
|
ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
|
|
inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
|
|
annotatedContext, err := runtime.AnnotateIncomingContext(ctx, mux, req, "/gb28181pro.Api/UpdateDevice", runtime.WithHTTPPathPattern("/gb28181/api/device/update"))
|
|
if err != nil {
|
|
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
resp, md, err := local_request_Api_UpdateDevice_0(annotatedContext, inboundMarshaler, server, req, pathParams)
|
|
md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
|
|
annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
|
|
if err != nil {
|
|
runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
forward_Api_UpdateDevice_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
|
|
})
|
|
mux.Handle(http.MethodGet, pattern_Api_GetDeviceStatus_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
|
|
ctx, cancel := context.WithCancel(req.Context())
|
|
defer cancel()
|
|
var stream runtime.ServerTransportStream
|
|
ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
|
|
inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
|
|
annotatedContext, err := runtime.AnnotateIncomingContext(ctx, mux, req, "/gb28181pro.Api/GetDeviceStatus", runtime.WithHTTPPathPattern("/gb28181/api/devices/{deviceId}/status"))
|
|
if err != nil {
|
|
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
resp, md, err := local_request_Api_GetDeviceStatus_0(annotatedContext, inboundMarshaler, server, req, pathParams)
|
|
md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
|
|
annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
|
|
if err != nil {
|
|
runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
forward_Api_GetDeviceStatus_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
|
|
})
|
|
mux.Handle(http.MethodGet, pattern_Api_GetDeviceAlarm_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
|
|
ctx, cancel := context.WithCancel(req.Context())
|
|
defer cancel()
|
|
var stream runtime.ServerTransportStream
|
|
ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
|
|
inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
|
|
annotatedContext, err := runtime.AnnotateIncomingContext(ctx, mux, req, "/gb28181pro.Api/GetDeviceAlarm", runtime.WithHTTPPathPattern("/gb28181/api/alarm/{deviceId}"))
|
|
if err != nil {
|
|
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
resp, md, err := local_request_Api_GetDeviceAlarm_0(annotatedContext, inboundMarshaler, server, req, pathParams)
|
|
md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
|
|
annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
|
|
if err != nil {
|
|
runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
forward_Api_GetDeviceAlarm_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
|
|
})
|
|
mux.Handle(http.MethodGet, pattern_Api_GetSyncStatus_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
|
|
ctx, cancel := context.WithCancel(req.Context())
|
|
defer cancel()
|
|
var stream runtime.ServerTransportStream
|
|
ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
|
|
inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
|
|
annotatedContext, err := runtime.AnnotateIncomingContext(ctx, mux, req, "/gb28181pro.Api/GetSyncStatus", runtime.WithHTTPPathPattern("/gb28181/api/{deviceId}/sync_status"))
|
|
if err != nil {
|
|
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
resp, md, err := local_request_Api_GetSyncStatus_0(annotatedContext, inboundMarshaler, server, req, pathParams)
|
|
md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
|
|
annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
|
|
if err != nil {
|
|
runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
forward_Api_GetSyncStatus_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
|
|
})
|
|
mux.Handle(http.MethodGet, pattern_Api_GetSubscribeInfo_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
|
|
ctx, cancel := context.WithCancel(req.Context())
|
|
defer cancel()
|
|
var stream runtime.ServerTransportStream
|
|
ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
|
|
inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
|
|
annotatedContext, err := runtime.AnnotateIncomingContext(ctx, mux, req, "/gb28181pro.Api/GetSubscribeInfo", runtime.WithHTTPPathPattern("/gb28181/api/{deviceId}/subscribe_info"))
|
|
if err != nil {
|
|
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
resp, md, err := local_request_Api_GetSubscribeInfo_0(annotatedContext, inboundMarshaler, server, req, pathParams)
|
|
md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
|
|
annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
|
|
if err != nil {
|
|
runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
forward_Api_GetSubscribeInfo_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
|
|
})
|
|
mux.Handle(http.MethodGet, pattern_Api_GetSnap_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
|
|
ctx, cancel := context.WithCancel(req.Context())
|
|
defer cancel()
|
|
var stream runtime.ServerTransportStream
|
|
ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
|
|
inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
|
|
annotatedContext, err := runtime.AnnotateIncomingContext(ctx, mux, req, "/gb28181pro.Api/GetSnap", runtime.WithHTTPPathPattern("/gb28181/api/snap/{deviceId}/{channelId}"))
|
|
if err != nil {
|
|
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
resp, md, err := local_request_Api_GetSnap_0(annotatedContext, inboundMarshaler, server, req, pathParams)
|
|
md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
|
|
annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
|
|
if err != nil {
|
|
runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
forward_Api_GetSnap_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
|
|
})
|
|
mux.Handle(http.MethodPost, pattern_Api_StopConvert_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
|
|
ctx, cancel := context.WithCancel(req.Context())
|
|
defer cancel()
|
|
var stream runtime.ServerTransportStream
|
|
ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
|
|
inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
|
|
annotatedContext, err := runtime.AnnotateIncomingContext(ctx, mux, req, "/gb28181pro.Api/StopConvert", runtime.WithHTTPPathPattern("/gb28181/api/play/convertStop/{key}"))
|
|
if err != nil {
|
|
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
resp, md, err := local_request_Api_StopConvert_0(annotatedContext, inboundMarshaler, server, req, pathParams)
|
|
md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
|
|
annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
|
|
if err != nil {
|
|
runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
forward_Api_StopConvert_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
|
|
})
|
|
mux.Handle(http.MethodPost, pattern_Api_StartBroadcast_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
|
|
ctx, cancel := context.WithCancel(req.Context())
|
|
defer cancel()
|
|
var stream runtime.ServerTransportStream
|
|
ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
|
|
inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
|
|
annotatedContext, err := runtime.AnnotateIncomingContext(ctx, mux, req, "/gb28181pro.Api/StartBroadcast", runtime.WithHTTPPathPattern("/gb28181/api/play/broadcast/{deviceId}/{channelId}"))
|
|
if err != nil {
|
|
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
resp, md, err := local_request_Api_StartBroadcast_0(annotatedContext, inboundMarshaler, server, req, pathParams)
|
|
md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
|
|
annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
|
|
if err != nil {
|
|
runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
forward_Api_StartBroadcast_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
|
|
})
|
|
mux.Handle(http.MethodPost, pattern_Api_StopBroadcast_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
|
|
ctx, cancel := context.WithCancel(req.Context())
|
|
defer cancel()
|
|
var stream runtime.ServerTransportStream
|
|
ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
|
|
inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
|
|
annotatedContext, err := runtime.AnnotateIncomingContext(ctx, mux, req, "/gb28181pro.Api/StopBroadcast", runtime.WithHTTPPathPattern("/gb28181/api/play/broadcast/stop/{deviceId}/{channelId}"))
|
|
if err != nil {
|
|
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
resp, md, err := local_request_Api_StopBroadcast_0(annotatedContext, inboundMarshaler, server, req, pathParams)
|
|
md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
|
|
annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
|
|
if err != nil {
|
|
runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
forward_Api_StopBroadcast_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
|
|
})
|
|
mux.Handle(http.MethodGet, pattern_Api_GetAllSSRC_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
|
|
ctx, cancel := context.WithCancel(req.Context())
|
|
defer cancel()
|
|
var stream runtime.ServerTransportStream
|
|
ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
|
|
inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
|
|
annotatedContext, err := runtime.AnnotateIncomingContext(ctx, mux, req, "/gb28181pro.Api/GetAllSSRC", runtime.WithHTTPPathPattern("/gb28181/api/play/ssrc"))
|
|
if err != nil {
|
|
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
resp, md, err := local_request_Api_GetAllSSRC_0(annotatedContext, inboundMarshaler, server, req, pathParams)
|
|
md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
|
|
annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
|
|
if err != nil {
|
|
runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
forward_Api_GetAllSSRC_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
|
|
})
|
|
mux.Handle(http.MethodGet, pattern_Api_GetRawChannel_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
|
|
ctx, cancel := context.WithCancel(req.Context())
|
|
defer cancel()
|
|
var stream runtime.ServerTransportStream
|
|
ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
|
|
inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
|
|
annotatedContext, err := runtime.AnnotateIncomingContext(ctx, mux, req, "/gb28181pro.Api/GetRawChannel", runtime.WithHTTPPathPattern("/gb28181/api/channel/raw"))
|
|
if err != nil {
|
|
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
resp, md, err := local_request_Api_GetRawChannel_0(annotatedContext, inboundMarshaler, server, req, pathParams)
|
|
md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
|
|
annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
|
|
if err != nil {
|
|
runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
forward_Api_GetRawChannel_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
|
|
})
|
|
mux.Handle(http.MethodPost, pattern_Api_AddPlatform_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
|
|
ctx, cancel := context.WithCancel(req.Context())
|
|
defer cancel()
|
|
var stream runtime.ServerTransportStream
|
|
ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
|
|
inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
|
|
annotatedContext, err := runtime.AnnotateIncomingContext(ctx, mux, req, "/gb28181pro.Api/AddPlatform", runtime.WithHTTPPathPattern("/gb28181/api/platform/add"))
|
|
if err != nil {
|
|
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
resp, md, err := local_request_Api_AddPlatform_0(annotatedContext, inboundMarshaler, server, req, pathParams)
|
|
md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
|
|
annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
|
|
if err != nil {
|
|
runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
forward_Api_AddPlatform_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
|
|
})
|
|
mux.Handle(http.MethodGet, pattern_Api_GetPlatform_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
|
|
ctx, cancel := context.WithCancel(req.Context())
|
|
defer cancel()
|
|
var stream runtime.ServerTransportStream
|
|
ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
|
|
inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
|
|
annotatedContext, err := runtime.AnnotateIncomingContext(ctx, mux, req, "/gb28181pro.Api/GetPlatform", runtime.WithHTTPPathPattern("/gb28181/api/platform/{id}"))
|
|
if err != nil {
|
|
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
resp, md, err := local_request_Api_GetPlatform_0(annotatedContext, inboundMarshaler, server, req, pathParams)
|
|
md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
|
|
annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
|
|
if err != nil {
|
|
runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
forward_Api_GetPlatform_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
|
|
})
|
|
mux.Handle(http.MethodPost, pattern_Api_UpdatePlatform_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
|
|
ctx, cancel := context.WithCancel(req.Context())
|
|
defer cancel()
|
|
var stream runtime.ServerTransportStream
|
|
ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
|
|
inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
|
|
annotatedContext, err := runtime.AnnotateIncomingContext(ctx, mux, req, "/gb28181pro.Api/UpdatePlatform", runtime.WithHTTPPathPattern("/gb28181/api/platform/update"))
|
|
if err != nil {
|
|
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
resp, md, err := local_request_Api_UpdatePlatform_0(annotatedContext, inboundMarshaler, server, req, pathParams)
|
|
md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
|
|
annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
|
|
if err != nil {
|
|
runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
forward_Api_UpdatePlatform_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
|
|
})
|
|
mux.Handle(http.MethodDelete, pattern_Api_DeletePlatform_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
|
|
ctx, cancel := context.WithCancel(req.Context())
|
|
defer cancel()
|
|
var stream runtime.ServerTransportStream
|
|
ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
|
|
inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
|
|
annotatedContext, err := runtime.AnnotateIncomingContext(ctx, mux, req, "/gb28181pro.Api/DeletePlatform", runtime.WithHTTPPathPattern("/gb28181/api/platform/{id}"))
|
|
if err != nil {
|
|
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
resp, md, err := local_request_Api_DeletePlatform_0(annotatedContext, inboundMarshaler, server, req, pathParams)
|
|
md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
|
|
annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
|
|
if err != nil {
|
|
runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
forward_Api_DeletePlatform_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
|
|
})
|
|
mux.Handle(http.MethodGet, pattern_Api_ListPlatforms_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
|
|
ctx, cancel := context.WithCancel(req.Context())
|
|
defer cancel()
|
|
var stream runtime.ServerTransportStream
|
|
ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
|
|
inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
|
|
annotatedContext, err := runtime.AnnotateIncomingContext(ctx, mux, req, "/gb28181pro.Api/ListPlatforms", runtime.WithHTTPPathPattern("/gb28181/api/platform/list"))
|
|
if err != nil {
|
|
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
resp, md, err := local_request_Api_ListPlatforms_0(annotatedContext, inboundMarshaler, server, req, pathParams)
|
|
md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
|
|
annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
|
|
if err != nil {
|
|
runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
forward_Api_ListPlatforms_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
|
|
})
|
|
mux.Handle(http.MethodGet, pattern_Api_QueryRecord_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
|
|
ctx, cancel := context.WithCancel(req.Context())
|
|
defer cancel()
|
|
var stream runtime.ServerTransportStream
|
|
ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
|
|
inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
|
|
annotatedContext, err := runtime.AnnotateIncomingContext(ctx, mux, req, "/gb28181pro.Api/QueryRecord", runtime.WithHTTPPathPattern("/gb28181/api/records/{deviceId}/{channelId}"))
|
|
if err != nil {
|
|
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
resp, md, err := local_request_Api_QueryRecord_0(annotatedContext, inboundMarshaler, server, req, pathParams)
|
|
md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
|
|
annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
|
|
if err != nil {
|
|
runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
forward_Api_QueryRecord_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
|
|
})
|
|
mux.Handle(http.MethodGet, pattern_Api_PtzControl_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
|
|
ctx, cancel := context.WithCancel(req.Context())
|
|
defer cancel()
|
|
var stream runtime.ServerTransportStream
|
|
ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
|
|
inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
|
|
annotatedContext, err := runtime.AnnotateIncomingContext(ctx, mux, req, "/gb28181pro.Api/PtzControl", runtime.WithHTTPPathPattern("/gb28181/api/ptz/{deviceId}/{channelId}"))
|
|
if err != nil {
|
|
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
resp, md, err := local_request_Api_PtzControl_0(annotatedContext, inboundMarshaler, server, req, pathParams)
|
|
md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
|
|
annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
|
|
if err != nil {
|
|
runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
forward_Api_PtzControl_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
|
|
})
|
|
mux.Handle(http.MethodGet, pattern_Api_IrisControl_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
|
|
ctx, cancel := context.WithCancel(req.Context())
|
|
defer cancel()
|
|
var stream runtime.ServerTransportStream
|
|
ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
|
|
inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
|
|
annotatedContext, err := runtime.AnnotateIncomingContext(ctx, mux, req, "/gb28181pro.Api/IrisControl", runtime.WithHTTPPathPattern("/gb28181/api/fi/iris/{deviceId}/{channelId}"))
|
|
if err != nil {
|
|
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
resp, md, err := local_request_Api_IrisControl_0(annotatedContext, inboundMarshaler, server, req, pathParams)
|
|
md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
|
|
annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
|
|
if err != nil {
|
|
runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
forward_Api_IrisControl_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
|
|
})
|
|
mux.Handle(http.MethodGet, pattern_Api_FocusControl_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
|
|
ctx, cancel := context.WithCancel(req.Context())
|
|
defer cancel()
|
|
var stream runtime.ServerTransportStream
|
|
ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
|
|
inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
|
|
annotatedContext, err := runtime.AnnotateIncomingContext(ctx, mux, req, "/gb28181pro.Api/FocusControl", runtime.WithHTTPPathPattern("/gb28181/api/fi/focus/{deviceId}/{channelId}"))
|
|
if err != nil {
|
|
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
resp, md, err := local_request_Api_FocusControl_0(annotatedContext, inboundMarshaler, server, req, pathParams)
|
|
md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
|
|
annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
|
|
if err != nil {
|
|
runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
forward_Api_FocusControl_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
|
|
})
|
|
mux.Handle(http.MethodGet, pattern_Api_QueryPreset_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
|
|
ctx, cancel := context.WithCancel(req.Context())
|
|
defer cancel()
|
|
var stream runtime.ServerTransportStream
|
|
ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
|
|
inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
|
|
annotatedContext, err := runtime.AnnotateIncomingContext(ctx, mux, req, "/gb28181pro.Api/QueryPreset", runtime.WithHTTPPathPattern("/gb28181/api/preset/query/{deviceId}/{channelId}"))
|
|
if err != nil {
|
|
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
resp, md, err := local_request_Api_QueryPreset_0(annotatedContext, inboundMarshaler, server, req, pathParams)
|
|
md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
|
|
annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
|
|
if err != nil {
|
|
runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
forward_Api_QueryPreset_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
|
|
})
|
|
mux.Handle(http.MethodGet, pattern_Api_AddPreset_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
|
|
ctx, cancel := context.WithCancel(req.Context())
|
|
defer cancel()
|
|
var stream runtime.ServerTransportStream
|
|
ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
|
|
inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
|
|
annotatedContext, err := runtime.AnnotateIncomingContext(ctx, mux, req, "/gb28181pro.Api/AddPreset", runtime.WithHTTPPathPattern("/gb28181/api/preset/{deviceId}/{channelId}"))
|
|
if err != nil {
|
|
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
resp, md, err := local_request_Api_AddPreset_0(annotatedContext, inboundMarshaler, server, req, pathParams)
|
|
md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
|
|
annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
|
|
if err != nil {
|
|
runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
forward_Api_AddPreset_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
|
|
})
|
|
mux.Handle(http.MethodGet, pattern_Api_CallPreset_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
|
|
ctx, cancel := context.WithCancel(req.Context())
|
|
defer cancel()
|
|
var stream runtime.ServerTransportStream
|
|
ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
|
|
inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
|
|
annotatedContext, err := runtime.AnnotateIncomingContext(ctx, mux, req, "/gb28181pro.Api/CallPreset", runtime.WithHTTPPathPattern("/gb28181/api/preset/call/{deviceId}/{channelId}"))
|
|
if err != nil {
|
|
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
resp, md, err := local_request_Api_CallPreset_0(annotatedContext, inboundMarshaler, server, req, pathParams)
|
|
md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
|
|
annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
|
|
if err != nil {
|
|
runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
forward_Api_CallPreset_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
|
|
})
|
|
mux.Handle(http.MethodGet, pattern_Api_DeletePreset_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
|
|
ctx, cancel := context.WithCancel(req.Context())
|
|
defer cancel()
|
|
var stream runtime.ServerTransportStream
|
|
ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
|
|
inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
|
|
annotatedContext, err := runtime.AnnotateIncomingContext(ctx, mux, req, "/gb28181pro.Api/DeletePreset", runtime.WithHTTPPathPattern("/gb28181/api/preset/delete/{deviceId}/{channelId}"))
|
|
if err != nil {
|
|
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
resp, md, err := local_request_Api_DeletePreset_0(annotatedContext, inboundMarshaler, server, req, pathParams)
|
|
md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
|
|
annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
|
|
if err != nil {
|
|
runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
forward_Api_DeletePreset_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
|
|
})
|
|
mux.Handle(http.MethodGet, pattern_Api_AddCruisePoint_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
|
|
ctx, cancel := context.WithCancel(req.Context())
|
|
defer cancel()
|
|
var stream runtime.ServerTransportStream
|
|
ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
|
|
inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
|
|
annotatedContext, err := runtime.AnnotateIncomingContext(ctx, mux, req, "/gb28181pro.Api/AddCruisePoint", runtime.WithHTTPPathPattern("/gb28181/api/cruise/point/add/{deviceId}/{channelId}"))
|
|
if err != nil {
|
|
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
resp, md, err := local_request_Api_AddCruisePoint_0(annotatedContext, inboundMarshaler, server, req, pathParams)
|
|
md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
|
|
annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
|
|
if err != nil {
|
|
runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
forward_Api_AddCruisePoint_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
|
|
})
|
|
mux.Handle(http.MethodGet, pattern_Api_DeleteCruisePoint_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
|
|
ctx, cancel := context.WithCancel(req.Context())
|
|
defer cancel()
|
|
var stream runtime.ServerTransportStream
|
|
ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
|
|
inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
|
|
annotatedContext, err := runtime.AnnotateIncomingContext(ctx, mux, req, "/gb28181pro.Api/DeleteCruisePoint", runtime.WithHTTPPathPattern("/gb28181/api/cruise/point/delete/{deviceId}/{channelId}"))
|
|
if err != nil {
|
|
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
resp, md, err := local_request_Api_DeleteCruisePoint_0(annotatedContext, inboundMarshaler, server, req, pathParams)
|
|
md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
|
|
annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
|
|
if err != nil {
|
|
runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
forward_Api_DeleteCruisePoint_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
|
|
})
|
|
mux.Handle(http.MethodGet, pattern_Api_SetCruiseSpeed_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
|
|
ctx, cancel := context.WithCancel(req.Context())
|
|
defer cancel()
|
|
var stream runtime.ServerTransportStream
|
|
ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
|
|
inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
|
|
annotatedContext, err := runtime.AnnotateIncomingContext(ctx, mux, req, "/gb28181pro.Api/SetCruiseSpeed", runtime.WithHTTPPathPattern("/gb28181/api/cruise/speed/{deviceId}/{channelId}"))
|
|
if err != nil {
|
|
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
resp, md, err := local_request_Api_SetCruiseSpeed_0(annotatedContext, inboundMarshaler, server, req, pathParams)
|
|
md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
|
|
annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
|
|
if err != nil {
|
|
runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
forward_Api_SetCruiseSpeed_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
|
|
})
|
|
mux.Handle(http.MethodGet, pattern_Api_SetCruiseTime_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
|
|
ctx, cancel := context.WithCancel(req.Context())
|
|
defer cancel()
|
|
var stream runtime.ServerTransportStream
|
|
ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
|
|
inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
|
|
annotatedContext, err := runtime.AnnotateIncomingContext(ctx, mux, req, "/gb28181pro.Api/SetCruiseTime", runtime.WithHTTPPathPattern("/gb28181/api/cruise/time/{deviceId}/{channelId}"))
|
|
if err != nil {
|
|
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
resp, md, err := local_request_Api_SetCruiseTime_0(annotatedContext, inboundMarshaler, server, req, pathParams)
|
|
md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
|
|
annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
|
|
if err != nil {
|
|
runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
forward_Api_SetCruiseTime_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
|
|
})
|
|
mux.Handle(http.MethodGet, pattern_Api_StartCruise_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
|
|
ctx, cancel := context.WithCancel(req.Context())
|
|
defer cancel()
|
|
var stream runtime.ServerTransportStream
|
|
ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
|
|
inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
|
|
annotatedContext, err := runtime.AnnotateIncomingContext(ctx, mux, req, "/gb28181pro.Api/StartCruise", runtime.WithHTTPPathPattern("/gb28181/api/cruise/start/{deviceId}/{channelId}"))
|
|
if err != nil {
|
|
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
resp, md, err := local_request_Api_StartCruise_0(annotatedContext, inboundMarshaler, server, req, pathParams)
|
|
md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
|
|
annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
|
|
if err != nil {
|
|
runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
forward_Api_StartCruise_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
|
|
})
|
|
mux.Handle(http.MethodGet, pattern_Api_StopCruise_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
|
|
ctx, cancel := context.WithCancel(req.Context())
|
|
defer cancel()
|
|
var stream runtime.ServerTransportStream
|
|
ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
|
|
inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
|
|
annotatedContext, err := runtime.AnnotateIncomingContext(ctx, mux, req, "/gb28181pro.Api/StopCruise", runtime.WithHTTPPathPattern("/gb28181/api/cruise/stop/{deviceId}/{channelId}"))
|
|
if err != nil {
|
|
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
resp, md, err := local_request_Api_StopCruise_0(annotatedContext, inboundMarshaler, server, req, pathParams)
|
|
md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
|
|
annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
|
|
if err != nil {
|
|
runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
forward_Api_StopCruise_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
|
|
})
|
|
mux.Handle(http.MethodGet, pattern_Api_StartScan_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
|
|
ctx, cancel := context.WithCancel(req.Context())
|
|
defer cancel()
|
|
var stream runtime.ServerTransportStream
|
|
ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
|
|
inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
|
|
annotatedContext, err := runtime.AnnotateIncomingContext(ctx, mux, req, "/gb28181pro.Api/StartScan", runtime.WithHTTPPathPattern("/gb28181/api/scan/start/{deviceId}/{channelId}"))
|
|
if err != nil {
|
|
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
resp, md, err := local_request_Api_StartScan_0(annotatedContext, inboundMarshaler, server, req, pathParams)
|
|
md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
|
|
annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
|
|
if err != nil {
|
|
runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
forward_Api_StartScan_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
|
|
})
|
|
mux.Handle(http.MethodGet, pattern_Api_StopScan_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
|
|
ctx, cancel := context.WithCancel(req.Context())
|
|
defer cancel()
|
|
var stream runtime.ServerTransportStream
|
|
ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
|
|
inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
|
|
annotatedContext, err := runtime.AnnotateIncomingContext(ctx, mux, req, "/gb28181pro.Api/StopScan", runtime.WithHTTPPathPattern("/gb28181/api/scan/stop/{deviceId}/{channelId}"))
|
|
if err != nil {
|
|
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
resp, md, err := local_request_Api_StopScan_0(annotatedContext, inboundMarshaler, server, req, pathParams)
|
|
md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
|
|
annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
|
|
if err != nil {
|
|
runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
forward_Api_StopScan_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
|
|
})
|
|
mux.Handle(http.MethodGet, pattern_Api_SetScanLeft_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
|
|
ctx, cancel := context.WithCancel(req.Context())
|
|
defer cancel()
|
|
var stream runtime.ServerTransportStream
|
|
ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
|
|
inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
|
|
annotatedContext, err := runtime.AnnotateIncomingContext(ctx, mux, req, "/gb28181pro.Api/SetScanLeft", runtime.WithHTTPPathPattern("/gb28181/api/scan/set/left/{deviceId}/{channelId}"))
|
|
if err != nil {
|
|
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
resp, md, err := local_request_Api_SetScanLeft_0(annotatedContext, inboundMarshaler, server, req, pathParams)
|
|
md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
|
|
annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
|
|
if err != nil {
|
|
runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
forward_Api_SetScanLeft_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
|
|
})
|
|
mux.Handle(http.MethodGet, pattern_Api_SetScanRight_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
|
|
ctx, cancel := context.WithCancel(req.Context())
|
|
defer cancel()
|
|
var stream runtime.ServerTransportStream
|
|
ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
|
|
inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
|
|
annotatedContext, err := runtime.AnnotateIncomingContext(ctx, mux, req, "/gb28181pro.Api/SetScanRight", runtime.WithHTTPPathPattern("/gb28181/api/scan/set/right/{deviceId}/{channelId}"))
|
|
if err != nil {
|
|
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
resp, md, err := local_request_Api_SetScanRight_0(annotatedContext, inboundMarshaler, server, req, pathParams)
|
|
md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
|
|
annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
|
|
if err != nil {
|
|
runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
forward_Api_SetScanRight_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
|
|
})
|
|
mux.Handle(http.MethodGet, pattern_Api_SetScanSpeed_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
|
|
ctx, cancel := context.WithCancel(req.Context())
|
|
defer cancel()
|
|
var stream runtime.ServerTransportStream
|
|
ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
|
|
inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
|
|
annotatedContext, err := runtime.AnnotateIncomingContext(ctx, mux, req, "/gb28181pro.Api/SetScanSpeed", runtime.WithHTTPPathPattern("/gb28181/api/scan/set/speed/{deviceId}/{channelId}"))
|
|
if err != nil {
|
|
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
resp, md, err := local_request_Api_SetScanSpeed_0(annotatedContext, inboundMarshaler, server, req, pathParams)
|
|
md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
|
|
annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
|
|
if err != nil {
|
|
runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
forward_Api_SetScanSpeed_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
|
|
})
|
|
mux.Handle(http.MethodGet, pattern_Api_WiperControl_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
|
|
ctx, cancel := context.WithCancel(req.Context())
|
|
defer cancel()
|
|
var stream runtime.ServerTransportStream
|
|
ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
|
|
inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
|
|
annotatedContext, err := runtime.AnnotateIncomingContext(ctx, mux, req, "/gb28181pro.Api/WiperControl", runtime.WithHTTPPathPattern("/gb28181/api/wiper/{deviceId}/{channelId}"))
|
|
if err != nil {
|
|
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
resp, md, err := local_request_Api_WiperControl_0(annotatedContext, inboundMarshaler, server, req, pathParams)
|
|
md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
|
|
annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
|
|
if err != nil {
|
|
runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
forward_Api_WiperControl_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
|
|
})
|
|
mux.Handle(http.MethodGet, pattern_Api_AuxiliaryControl_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
|
|
ctx, cancel := context.WithCancel(req.Context())
|
|
defer cancel()
|
|
var stream runtime.ServerTransportStream
|
|
ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
|
|
inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
|
|
annotatedContext, err := runtime.AnnotateIncomingContext(ctx, mux, req, "/gb28181pro.Api/AuxiliaryControl", runtime.WithHTTPPathPattern("/gb28181/api/auxiliary/{deviceId}/{channelId}"))
|
|
if err != nil {
|
|
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
resp, md, err := local_request_Api_AuxiliaryControl_0(annotatedContext, inboundMarshaler, server, req, pathParams)
|
|
md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
|
|
annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
|
|
if err != nil {
|
|
runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
forward_Api_AuxiliaryControl_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
|
|
})
|
|
mux.Handle(http.MethodGet, pattern_Api_TestSip_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
|
|
ctx, cancel := context.WithCancel(req.Context())
|
|
defer cancel()
|
|
var stream runtime.ServerTransportStream
|
|
ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
|
|
inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
|
|
annotatedContext, err := runtime.AnnotateIncomingContext(ctx, mux, req, "/gb28181pro.Api/TestSip", runtime.WithHTTPPathPattern("/gb28181/api/testsip"))
|
|
if err != nil {
|
|
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
resp, md, err := local_request_Api_TestSip_0(annotatedContext, inboundMarshaler, server, req, pathParams)
|
|
md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
|
|
annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
|
|
if err != nil {
|
|
runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
forward_Api_TestSip_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
|
|
})
|
|
mux.Handle(http.MethodGet, pattern_Api_SearchAlarms_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
|
|
ctx, cancel := context.WithCancel(req.Context())
|
|
defer cancel()
|
|
var stream runtime.ServerTransportStream
|
|
ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
|
|
inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
|
|
annotatedContext, err := runtime.AnnotateIncomingContext(ctx, mux, req, "/gb28181pro.Api/SearchAlarms", runtime.WithHTTPPathPattern("/gb28181/api/alarms/{deviceId}"))
|
|
if err != nil {
|
|
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
resp, md, err := local_request_Api_SearchAlarms_0(annotatedContext, inboundMarshaler, server, req, pathParams)
|
|
md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
|
|
annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
|
|
if err != nil {
|
|
runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
forward_Api_SearchAlarms_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
|
|
})
|
|
mux.Handle(http.MethodPost, pattern_Api_AddPlatformChannel_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
|
|
ctx, cancel := context.WithCancel(req.Context())
|
|
defer cancel()
|
|
var stream runtime.ServerTransportStream
|
|
ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
|
|
inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
|
|
annotatedContext, err := runtime.AnnotateIncomingContext(ctx, mux, req, "/gb28181pro.Api/AddPlatformChannel", runtime.WithHTTPPathPattern("/gb28181/api/platform/channel/add"))
|
|
if err != nil {
|
|
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
resp, md, err := local_request_Api_AddPlatformChannel_0(annotatedContext, inboundMarshaler, server, req, pathParams)
|
|
md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
|
|
annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
|
|
if err != nil {
|
|
runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
forward_Api_AddPlatformChannel_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
|
|
})
|
|
mux.Handle(http.MethodGet, pattern_Api_Recording_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
|
|
ctx, cancel := context.WithCancel(req.Context())
|
|
defer cancel()
|
|
var stream runtime.ServerTransportStream
|
|
ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
|
|
inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
|
|
annotatedContext, err := runtime.AnnotateIncomingContext(ctx, mux, req, "/gb28181pro.Api/Recording", runtime.WithHTTPPathPattern("/gb28181/api/recording/{cmdType}/{deviceId}/{channelId}"))
|
|
if err != nil {
|
|
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
resp, md, err := local_request_Api_Recording_0(annotatedContext, inboundMarshaler, server, req, pathParams)
|
|
md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
|
|
annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
|
|
if err != nil {
|
|
runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
forward_Api_Recording_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
|
|
})
|
|
mux.Handle(http.MethodPost, pattern_Api_UploadJpeg_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
|
|
ctx, cancel := context.WithCancel(req.Context())
|
|
defer cancel()
|
|
var stream runtime.ServerTransportStream
|
|
ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
|
|
inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
|
|
annotatedContext, err := runtime.AnnotateIncomingContext(ctx, mux, req, "/gb28181pro.Api/UploadJpeg", runtime.WithHTTPPathPattern("/gb28181/api/snap/upload"))
|
|
if err != nil {
|
|
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
resp, md, err := local_request_Api_UploadJpeg_0(annotatedContext, inboundMarshaler, server, req, pathParams)
|
|
md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
|
|
annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
|
|
if err != nil {
|
|
runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
forward_Api_UploadJpeg_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
|
|
})
|
|
mux.Handle(http.MethodPost, pattern_Api_UpdateChannel_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
|
|
ctx, cancel := context.WithCancel(req.Context())
|
|
defer cancel()
|
|
var stream runtime.ServerTransportStream
|
|
ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
|
|
inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
|
|
annotatedContext, err := runtime.AnnotateIncomingContext(ctx, mux, req, "/gb28181pro.Api/UpdateChannel", runtime.WithHTTPPathPattern("/gb28181/api/channel/update/{id}"))
|
|
if err != nil {
|
|
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
resp, md, err := local_request_Api_UpdateChannel_0(annotatedContext, inboundMarshaler, server, req, pathParams)
|
|
md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
|
|
annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
|
|
if err != nil {
|
|
runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
forward_Api_UpdateChannel_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
|
|
})
|
|
mux.Handle(http.MethodGet, pattern_Api_PlaybackPause_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
|
|
ctx, cancel := context.WithCancel(req.Context())
|
|
defer cancel()
|
|
var stream runtime.ServerTransportStream
|
|
ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
|
|
inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
|
|
annotatedContext, err := runtime.AnnotateIncomingContext(ctx, mux, req, "/gb28181pro.Api/PlaybackPause", runtime.WithHTTPPathPattern("/gb28181/api/playback/pause"))
|
|
if err != nil {
|
|
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
resp, md, err := local_request_Api_PlaybackPause_0(annotatedContext, inboundMarshaler, server, req, pathParams)
|
|
md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
|
|
annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
|
|
if err != nil {
|
|
runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
forward_Api_PlaybackPause_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
|
|
})
|
|
mux.Handle(http.MethodGet, pattern_Api_PlaybackResume_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
|
|
ctx, cancel := context.WithCancel(req.Context())
|
|
defer cancel()
|
|
var stream runtime.ServerTransportStream
|
|
ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
|
|
inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
|
|
annotatedContext, err := runtime.AnnotateIncomingContext(ctx, mux, req, "/gb28181pro.Api/PlaybackResume", runtime.WithHTTPPathPattern("/gb28181/api/playback/resume"))
|
|
if err != nil {
|
|
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
resp, md, err := local_request_Api_PlaybackResume_0(annotatedContext, inboundMarshaler, server, req, pathParams)
|
|
md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
|
|
annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
|
|
if err != nil {
|
|
runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
forward_Api_PlaybackResume_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
|
|
})
|
|
mux.Handle(http.MethodGet, pattern_Api_PlaybackSeek_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
|
|
ctx, cancel := context.WithCancel(req.Context())
|
|
defer cancel()
|
|
var stream runtime.ServerTransportStream
|
|
ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
|
|
inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
|
|
annotatedContext, err := runtime.AnnotateIncomingContext(ctx, mux, req, "/gb28181pro.Api/PlaybackSeek", runtime.WithHTTPPathPattern("/gb28181/api/playback/seek"))
|
|
if err != nil {
|
|
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
resp, md, err := local_request_Api_PlaybackSeek_0(annotatedContext, inboundMarshaler, server, req, pathParams)
|
|
md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
|
|
annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
|
|
if err != nil {
|
|
runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
forward_Api_PlaybackSeek_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
|
|
})
|
|
mux.Handle(http.MethodGet, pattern_Api_PlaybackSpeed_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
|
|
ctx, cancel := context.WithCancel(req.Context())
|
|
defer cancel()
|
|
var stream runtime.ServerTransportStream
|
|
ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
|
|
inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
|
|
annotatedContext, err := runtime.AnnotateIncomingContext(ctx, mux, req, "/gb28181pro.Api/PlaybackSpeed", runtime.WithHTTPPathPattern("/gb28181/api/playback/speed"))
|
|
if err != nil {
|
|
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
resp, md, err := local_request_Api_PlaybackSpeed_0(annotatedContext, inboundMarshaler, server, req, pathParams)
|
|
md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
|
|
annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
|
|
if err != nil {
|
|
runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
forward_Api_PlaybackSpeed_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
|
|
})
|
|
mux.Handle(http.MethodGet, pattern_Api_GetGroups_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
|
|
ctx, cancel := context.WithCancel(req.Context())
|
|
defer cancel()
|
|
var stream runtime.ServerTransportStream
|
|
ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
|
|
inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
|
|
annotatedContext, err := runtime.AnnotateIncomingContext(ctx, mux, req, "/gb28181pro.Api/GetGroups", runtime.WithHTTPPathPattern("/gb28181/api/groups/{pid}"))
|
|
if err != nil {
|
|
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
resp, md, err := local_request_Api_GetGroups_0(annotatedContext, inboundMarshaler, server, req, pathParams)
|
|
md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
|
|
annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
|
|
if err != nil {
|
|
runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
forward_Api_GetGroups_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
|
|
})
|
|
mux.Handle(http.MethodPost, pattern_Api_AddGroup_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
|
|
ctx, cancel := context.WithCancel(req.Context())
|
|
defer cancel()
|
|
var stream runtime.ServerTransportStream
|
|
ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
|
|
inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
|
|
annotatedContext, err := runtime.AnnotateIncomingContext(ctx, mux, req, "/gb28181pro.Api/AddGroup", runtime.WithHTTPPathPattern("/gb28181/api/groups/add"))
|
|
if err != nil {
|
|
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
resp, md, err := local_request_Api_AddGroup_0(annotatedContext, inboundMarshaler, server, req, pathParams)
|
|
md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
|
|
annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
|
|
if err != nil {
|
|
runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
forward_Api_AddGroup_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
|
|
})
|
|
mux.Handle(http.MethodPost, pattern_Api_UpdateGroup_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
|
|
ctx, cancel := context.WithCancel(req.Context())
|
|
defer cancel()
|
|
var stream runtime.ServerTransportStream
|
|
ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
|
|
inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
|
|
annotatedContext, err := runtime.AnnotateIncomingContext(ctx, mux, req, "/gb28181pro.Api/UpdateGroup", runtime.WithHTTPPathPattern("/gb28181/api/groups/update"))
|
|
if err != nil {
|
|
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
resp, md, err := local_request_Api_UpdateGroup_0(annotatedContext, inboundMarshaler, server, req, pathParams)
|
|
md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
|
|
annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
|
|
if err != nil {
|
|
runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
forward_Api_UpdateGroup_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
|
|
})
|
|
mux.Handle(http.MethodPost, pattern_Api_DeleteGroup_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
|
|
ctx, cancel := context.WithCancel(req.Context())
|
|
defer cancel()
|
|
var stream runtime.ServerTransportStream
|
|
ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
|
|
inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
|
|
annotatedContext, err := runtime.AnnotateIncomingContext(ctx, mux, req, "/gb28181pro.Api/DeleteGroup", runtime.WithHTTPPathPattern("/gb28181/api/groups/delete/{id}"))
|
|
if err != nil {
|
|
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
resp, md, err := local_request_Api_DeleteGroup_0(annotatedContext, inboundMarshaler, server, req, pathParams)
|
|
md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
|
|
annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
|
|
if err != nil {
|
|
runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
forward_Api_DeleteGroup_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
|
|
})
|
|
mux.Handle(http.MethodPost, pattern_Api_AddGroupChannel_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
|
|
ctx, cancel := context.WithCancel(req.Context())
|
|
defer cancel()
|
|
var stream runtime.ServerTransportStream
|
|
ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
|
|
inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
|
|
annotatedContext, err := runtime.AnnotateIncomingContext(ctx, mux, req, "/gb28181pro.Api/AddGroupChannel", runtime.WithHTTPPathPattern("/gb28181/api/groups/channel/add/{groupId}"))
|
|
if err != nil {
|
|
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
resp, md, err := local_request_Api_AddGroupChannel_0(annotatedContext, inboundMarshaler, server, req, pathParams)
|
|
md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
|
|
annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
|
|
if err != nil {
|
|
runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
forward_Api_AddGroupChannel_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
|
|
})
|
|
mux.Handle(http.MethodPost, pattern_Api_DeleteGroupChannel_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
|
|
ctx, cancel := context.WithCancel(req.Context())
|
|
defer cancel()
|
|
var stream runtime.ServerTransportStream
|
|
ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
|
|
inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
|
|
annotatedContext, err := runtime.AnnotateIncomingContext(ctx, mux, req, "/gb28181pro.Api/DeleteGroupChannel", runtime.WithHTTPPathPattern("/gb28181/api/groups/channel/delete/{groupId}"))
|
|
if err != nil {
|
|
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
resp, md, err := local_request_Api_DeleteGroupChannel_0(annotatedContext, inboundMarshaler, server, req, pathParams)
|
|
md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
|
|
annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
|
|
if err != nil {
|
|
runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
forward_Api_DeleteGroupChannel_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
|
|
})
|
|
mux.Handle(http.MethodGet, pattern_Api_GetGroupChannels_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
|
|
ctx, cancel := context.WithCancel(req.Context())
|
|
defer cancel()
|
|
var stream runtime.ServerTransportStream
|
|
ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
|
|
inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
|
|
annotatedContext, err := runtime.AnnotateIncomingContext(ctx, mux, req, "/gb28181pro.Api/GetGroupChannels", runtime.WithHTTPPathPattern("/gb28181/api/groups/{groupId}/channels"))
|
|
if err != nil {
|
|
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
resp, md, err := local_request_Api_GetGroupChannels_0(annotatedContext, inboundMarshaler, server, req, pathParams)
|
|
md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
|
|
annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
|
|
if err != nil {
|
|
runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
forward_Api_GetGroupChannels_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
|
|
})
|
|
mux.Handle(http.MethodPost, pattern_Api_RemoveDevice_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
|
|
ctx, cancel := context.WithCancel(req.Context())
|
|
defer cancel()
|
|
var stream runtime.ServerTransportStream
|
|
ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
|
|
inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
|
|
annotatedContext, err := runtime.AnnotateIncomingContext(ctx, mux, req, "/gb28181pro.Api/RemoveDevice", runtime.WithHTTPPathPattern("/gb28181/api/device/remove/{id}"))
|
|
if err != nil {
|
|
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
resp, md, err := local_request_Api_RemoveDevice_0(annotatedContext, inboundMarshaler, server, req, pathParams)
|
|
md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
|
|
annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
|
|
if err != nil {
|
|
runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
forward_Api_RemoveDevice_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
|
|
})
|
|
mux.Handle(http.MethodPost, pattern_Api_ReceiveAlarm_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
|
|
ctx, cancel := context.WithCancel(req.Context())
|
|
defer cancel()
|
|
var stream runtime.ServerTransportStream
|
|
ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)
|
|
inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
|
|
annotatedContext, err := runtime.AnnotateIncomingContext(ctx, mux, req, "/gb28181pro.Api/ReceiveAlarm", runtime.WithHTTPPathPattern("/gb28181/api/alarm/receive"))
|
|
if err != nil {
|
|
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
resp, md, err := local_request_Api_ReceiveAlarm_0(annotatedContext, inboundMarshaler, server, req, pathParams)
|
|
md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())
|
|
annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
|
|
if err != nil {
|
|
runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
forward_Api_ReceiveAlarm_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
|
|
})
|
|
|
|
return nil
|
|
}
|
|
|
|
// RegisterApiHandlerFromEndpoint is same as RegisterApiHandler but
|
|
// automatically dials to "endpoint" and closes the connection when "ctx" gets done.
|
|
func RegisterApiHandlerFromEndpoint(ctx context.Context, mux *runtime.ServeMux, endpoint string, opts []grpc.DialOption) (err error) {
|
|
conn, err := grpc.NewClient(endpoint, opts...)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
defer func() {
|
|
if err != nil {
|
|
if cerr := conn.Close(); cerr != nil {
|
|
grpclog.Errorf("Failed to close conn to %s: %v", endpoint, cerr)
|
|
}
|
|
return
|
|
}
|
|
go func() {
|
|
<-ctx.Done()
|
|
if cerr := conn.Close(); cerr != nil {
|
|
grpclog.Errorf("Failed to close conn to %s: %v", endpoint, cerr)
|
|
}
|
|
}()
|
|
}()
|
|
return RegisterApiHandler(ctx, mux, conn)
|
|
}
|
|
|
|
// RegisterApiHandler registers the http handlers for service Api to "mux".
|
|
// The handlers forward requests to the grpc endpoint over "conn".
|
|
func RegisterApiHandler(ctx context.Context, mux *runtime.ServeMux, conn *grpc.ClientConn) error {
|
|
return RegisterApiHandlerClient(ctx, mux, NewApiClient(conn))
|
|
}
|
|
|
|
// RegisterApiHandlerClient registers the http handlers for service Api
|
|
// to "mux". The handlers forward requests to the grpc endpoint over the given implementation of "ApiClient".
|
|
// Note: the gRPC framework executes interceptors within the gRPC handler. If the passed in "ApiClient"
|
|
// doesn't go through the normal gRPC flow (creating a gRPC client etc.) then it will be up to the passed in
|
|
// "ApiClient" to call the correct interceptors. This client ignores the HTTP middlewares.
|
|
func RegisterApiHandlerClient(ctx context.Context, mux *runtime.ServeMux, client ApiClient) error {
|
|
mux.Handle(http.MethodGet, pattern_Api_List_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
|
|
ctx, cancel := context.WithCancel(req.Context())
|
|
defer cancel()
|
|
inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
|
|
annotatedContext, err := runtime.AnnotateContext(ctx, mux, req, "/gb28181pro.Api/List", runtime.WithHTTPPathPattern("/gb28181/api/list"))
|
|
if err != nil {
|
|
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
resp, md, err := request_Api_List_0(annotatedContext, inboundMarshaler, client, req, pathParams)
|
|
annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
|
|
if err != nil {
|
|
runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
forward_Api_List_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
|
|
})
|
|
mux.Handle(http.MethodGet, pattern_Api_GetDevice_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
|
|
ctx, cancel := context.WithCancel(req.Context())
|
|
defer cancel()
|
|
inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
|
|
annotatedContext, err := runtime.AnnotateContext(ctx, mux, req, "/gb28181pro.Api/GetDevice", runtime.WithHTTPPathPattern("/gb28181/api/devices/{deviceId}"))
|
|
if err != nil {
|
|
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
resp, md, err := request_Api_GetDevice_0(annotatedContext, inboundMarshaler, client, req, pathParams)
|
|
annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
|
|
if err != nil {
|
|
runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
forward_Api_GetDevice_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
|
|
})
|
|
mux.Handle(http.MethodGet, pattern_Api_GetDevices_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
|
|
ctx, cancel := context.WithCancel(req.Context())
|
|
defer cancel()
|
|
inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
|
|
annotatedContext, err := runtime.AnnotateContext(ctx, mux, req, "/gb28181pro.Api/GetDevices", runtime.WithHTTPPathPattern("/gb28181/api/devices"))
|
|
if err != nil {
|
|
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
resp, md, err := request_Api_GetDevices_0(annotatedContext, inboundMarshaler, client, req, pathParams)
|
|
annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
|
|
if err != nil {
|
|
runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
forward_Api_GetDevices_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
|
|
})
|
|
mux.Handle(http.MethodGet, pattern_Api_GetChannels_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
|
|
ctx, cancel := context.WithCancel(req.Context())
|
|
defer cancel()
|
|
inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
|
|
annotatedContext, err := runtime.AnnotateContext(ctx, mux, req, "/gb28181pro.Api/GetChannels", runtime.WithHTTPPathPattern("/gb28181/api/devices/{deviceId}/channels"))
|
|
if err != nil {
|
|
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
resp, md, err := request_Api_GetChannels_0(annotatedContext, inboundMarshaler, client, req, pathParams)
|
|
annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
|
|
if err != nil {
|
|
runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
forward_Api_GetChannels_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
|
|
})
|
|
mux.Handle(http.MethodGet, pattern_Api_SyncDevice_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
|
|
ctx, cancel := context.WithCancel(req.Context())
|
|
defer cancel()
|
|
inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
|
|
annotatedContext, err := runtime.AnnotateContext(ctx, mux, req, "/gb28181pro.Api/SyncDevice", runtime.WithHTTPPathPattern("/gb28181/api/devices/{deviceId}/sync"))
|
|
if err != nil {
|
|
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
resp, md, err := request_Api_SyncDevice_0(annotatedContext, inboundMarshaler, client, req, pathParams)
|
|
annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
|
|
if err != nil {
|
|
runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
forward_Api_SyncDevice_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
|
|
})
|
|
mux.Handle(http.MethodDelete, pattern_Api_DeleteDevice_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
|
|
ctx, cancel := context.WithCancel(req.Context())
|
|
defer cancel()
|
|
inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
|
|
annotatedContext, err := runtime.AnnotateContext(ctx, mux, req, "/gb28181pro.Api/DeleteDevice", runtime.WithHTTPPathPattern("/gb28181/api/devices/{deviceId}/delete"))
|
|
if err != nil {
|
|
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
resp, md, err := request_Api_DeleteDevice_0(annotatedContext, inboundMarshaler, client, req, pathParams)
|
|
annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
|
|
if err != nil {
|
|
runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
forward_Api_DeleteDevice_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
|
|
})
|
|
mux.Handle(http.MethodGet, pattern_Api_GetSubChannels_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
|
|
ctx, cancel := context.WithCancel(req.Context())
|
|
defer cancel()
|
|
inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
|
|
annotatedContext, err := runtime.AnnotateContext(ctx, mux, req, "/gb28181pro.Api/GetSubChannels", runtime.WithHTTPPathPattern("/gb28181/api/sub_channels/{deviceId}/{channelId}/channels"))
|
|
if err != nil {
|
|
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
resp, md, err := request_Api_GetSubChannels_0(annotatedContext, inboundMarshaler, client, req, pathParams)
|
|
annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
|
|
if err != nil {
|
|
runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
forward_Api_GetSubChannels_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
|
|
})
|
|
mux.Handle(http.MethodPost, pattern_Api_ChangeAudio_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
|
|
ctx, cancel := context.WithCancel(req.Context())
|
|
defer cancel()
|
|
inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
|
|
annotatedContext, err := runtime.AnnotateContext(ctx, mux, req, "/gb28181pro.Api/ChangeAudio", runtime.WithHTTPPathPattern("/gb28181/api/channel/audio"))
|
|
if err != nil {
|
|
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
resp, md, err := request_Api_ChangeAudio_0(annotatedContext, inboundMarshaler, client, req, pathParams)
|
|
annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
|
|
if err != nil {
|
|
runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
forward_Api_ChangeAudio_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
|
|
})
|
|
mux.Handle(http.MethodPost, pattern_Api_UpdateChannelStreamIdentification_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
|
|
ctx, cancel := context.WithCancel(req.Context())
|
|
defer cancel()
|
|
inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
|
|
annotatedContext, err := runtime.AnnotateContext(ctx, mux, req, "/gb28181pro.Api/UpdateChannelStreamIdentification", runtime.WithHTTPPathPattern("/gb28181/api/channel/stream/identification/update"))
|
|
if err != nil {
|
|
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
resp, md, err := request_Api_UpdateChannelStreamIdentification_0(annotatedContext, inboundMarshaler, client, req, pathParams)
|
|
annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
|
|
if err != nil {
|
|
runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
forward_Api_UpdateChannelStreamIdentification_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
|
|
})
|
|
mux.Handle(http.MethodPost, pattern_Api_UpdateTransport_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
|
|
ctx, cancel := context.WithCancel(req.Context())
|
|
defer cancel()
|
|
inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
|
|
annotatedContext, err := runtime.AnnotateContext(ctx, mux, req, "/gb28181pro.Api/UpdateTransport", runtime.WithHTTPPathPattern("/gb28181/api/transport/{deviceId}/{streamMode}"))
|
|
if err != nil {
|
|
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
resp, md, err := request_Api_UpdateTransport_0(annotatedContext, inboundMarshaler, client, req, pathParams)
|
|
annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
|
|
if err != nil {
|
|
runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
forward_Api_UpdateTransport_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
|
|
})
|
|
mux.Handle(http.MethodPost, pattern_Api_AddDevice_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
|
|
ctx, cancel := context.WithCancel(req.Context())
|
|
defer cancel()
|
|
inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
|
|
annotatedContext, err := runtime.AnnotateContext(ctx, mux, req, "/gb28181pro.Api/AddDevice", runtime.WithHTTPPathPattern("/gb28181/api/device/add"))
|
|
if err != nil {
|
|
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
resp, md, err := request_Api_AddDevice_0(annotatedContext, inboundMarshaler, client, req, pathParams)
|
|
annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
|
|
if err != nil {
|
|
runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
forward_Api_AddDevice_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
|
|
})
|
|
mux.Handle(http.MethodPost, pattern_Api_UpdateDevice_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
|
|
ctx, cancel := context.WithCancel(req.Context())
|
|
defer cancel()
|
|
inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
|
|
annotatedContext, err := runtime.AnnotateContext(ctx, mux, req, "/gb28181pro.Api/UpdateDevice", runtime.WithHTTPPathPattern("/gb28181/api/device/update"))
|
|
if err != nil {
|
|
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
resp, md, err := request_Api_UpdateDevice_0(annotatedContext, inboundMarshaler, client, req, pathParams)
|
|
annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
|
|
if err != nil {
|
|
runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
forward_Api_UpdateDevice_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
|
|
})
|
|
mux.Handle(http.MethodGet, pattern_Api_GetDeviceStatus_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
|
|
ctx, cancel := context.WithCancel(req.Context())
|
|
defer cancel()
|
|
inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
|
|
annotatedContext, err := runtime.AnnotateContext(ctx, mux, req, "/gb28181pro.Api/GetDeviceStatus", runtime.WithHTTPPathPattern("/gb28181/api/devices/{deviceId}/status"))
|
|
if err != nil {
|
|
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
resp, md, err := request_Api_GetDeviceStatus_0(annotatedContext, inboundMarshaler, client, req, pathParams)
|
|
annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
|
|
if err != nil {
|
|
runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
forward_Api_GetDeviceStatus_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
|
|
})
|
|
mux.Handle(http.MethodGet, pattern_Api_GetDeviceAlarm_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
|
|
ctx, cancel := context.WithCancel(req.Context())
|
|
defer cancel()
|
|
inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
|
|
annotatedContext, err := runtime.AnnotateContext(ctx, mux, req, "/gb28181pro.Api/GetDeviceAlarm", runtime.WithHTTPPathPattern("/gb28181/api/alarm/{deviceId}"))
|
|
if err != nil {
|
|
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
resp, md, err := request_Api_GetDeviceAlarm_0(annotatedContext, inboundMarshaler, client, req, pathParams)
|
|
annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
|
|
if err != nil {
|
|
runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
forward_Api_GetDeviceAlarm_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
|
|
})
|
|
mux.Handle(http.MethodGet, pattern_Api_GetSyncStatus_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
|
|
ctx, cancel := context.WithCancel(req.Context())
|
|
defer cancel()
|
|
inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
|
|
annotatedContext, err := runtime.AnnotateContext(ctx, mux, req, "/gb28181pro.Api/GetSyncStatus", runtime.WithHTTPPathPattern("/gb28181/api/{deviceId}/sync_status"))
|
|
if err != nil {
|
|
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
resp, md, err := request_Api_GetSyncStatus_0(annotatedContext, inboundMarshaler, client, req, pathParams)
|
|
annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
|
|
if err != nil {
|
|
runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
forward_Api_GetSyncStatus_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
|
|
})
|
|
mux.Handle(http.MethodGet, pattern_Api_GetSubscribeInfo_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
|
|
ctx, cancel := context.WithCancel(req.Context())
|
|
defer cancel()
|
|
inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
|
|
annotatedContext, err := runtime.AnnotateContext(ctx, mux, req, "/gb28181pro.Api/GetSubscribeInfo", runtime.WithHTTPPathPattern("/gb28181/api/{deviceId}/subscribe_info"))
|
|
if err != nil {
|
|
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
resp, md, err := request_Api_GetSubscribeInfo_0(annotatedContext, inboundMarshaler, client, req, pathParams)
|
|
annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
|
|
if err != nil {
|
|
runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
forward_Api_GetSubscribeInfo_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
|
|
})
|
|
mux.Handle(http.MethodGet, pattern_Api_GetSnap_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
|
|
ctx, cancel := context.WithCancel(req.Context())
|
|
defer cancel()
|
|
inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
|
|
annotatedContext, err := runtime.AnnotateContext(ctx, mux, req, "/gb28181pro.Api/GetSnap", runtime.WithHTTPPathPattern("/gb28181/api/snap/{deviceId}/{channelId}"))
|
|
if err != nil {
|
|
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
resp, md, err := request_Api_GetSnap_0(annotatedContext, inboundMarshaler, client, req, pathParams)
|
|
annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
|
|
if err != nil {
|
|
runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
forward_Api_GetSnap_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
|
|
})
|
|
mux.Handle(http.MethodPost, pattern_Api_StopConvert_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
|
|
ctx, cancel := context.WithCancel(req.Context())
|
|
defer cancel()
|
|
inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
|
|
annotatedContext, err := runtime.AnnotateContext(ctx, mux, req, "/gb28181pro.Api/StopConvert", runtime.WithHTTPPathPattern("/gb28181/api/play/convertStop/{key}"))
|
|
if err != nil {
|
|
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
resp, md, err := request_Api_StopConvert_0(annotatedContext, inboundMarshaler, client, req, pathParams)
|
|
annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
|
|
if err != nil {
|
|
runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
forward_Api_StopConvert_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
|
|
})
|
|
mux.Handle(http.MethodPost, pattern_Api_StartBroadcast_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
|
|
ctx, cancel := context.WithCancel(req.Context())
|
|
defer cancel()
|
|
inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
|
|
annotatedContext, err := runtime.AnnotateContext(ctx, mux, req, "/gb28181pro.Api/StartBroadcast", runtime.WithHTTPPathPattern("/gb28181/api/play/broadcast/{deviceId}/{channelId}"))
|
|
if err != nil {
|
|
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
resp, md, err := request_Api_StartBroadcast_0(annotatedContext, inboundMarshaler, client, req, pathParams)
|
|
annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
|
|
if err != nil {
|
|
runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
forward_Api_StartBroadcast_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
|
|
})
|
|
mux.Handle(http.MethodPost, pattern_Api_StopBroadcast_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
|
|
ctx, cancel := context.WithCancel(req.Context())
|
|
defer cancel()
|
|
inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
|
|
annotatedContext, err := runtime.AnnotateContext(ctx, mux, req, "/gb28181pro.Api/StopBroadcast", runtime.WithHTTPPathPattern("/gb28181/api/play/broadcast/stop/{deviceId}/{channelId}"))
|
|
if err != nil {
|
|
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
resp, md, err := request_Api_StopBroadcast_0(annotatedContext, inboundMarshaler, client, req, pathParams)
|
|
annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
|
|
if err != nil {
|
|
runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
forward_Api_StopBroadcast_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
|
|
})
|
|
mux.Handle(http.MethodGet, pattern_Api_GetAllSSRC_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
|
|
ctx, cancel := context.WithCancel(req.Context())
|
|
defer cancel()
|
|
inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
|
|
annotatedContext, err := runtime.AnnotateContext(ctx, mux, req, "/gb28181pro.Api/GetAllSSRC", runtime.WithHTTPPathPattern("/gb28181/api/play/ssrc"))
|
|
if err != nil {
|
|
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
resp, md, err := request_Api_GetAllSSRC_0(annotatedContext, inboundMarshaler, client, req, pathParams)
|
|
annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
|
|
if err != nil {
|
|
runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
forward_Api_GetAllSSRC_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
|
|
})
|
|
mux.Handle(http.MethodGet, pattern_Api_GetRawChannel_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
|
|
ctx, cancel := context.WithCancel(req.Context())
|
|
defer cancel()
|
|
inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
|
|
annotatedContext, err := runtime.AnnotateContext(ctx, mux, req, "/gb28181pro.Api/GetRawChannel", runtime.WithHTTPPathPattern("/gb28181/api/channel/raw"))
|
|
if err != nil {
|
|
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
resp, md, err := request_Api_GetRawChannel_0(annotatedContext, inboundMarshaler, client, req, pathParams)
|
|
annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
|
|
if err != nil {
|
|
runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
forward_Api_GetRawChannel_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
|
|
})
|
|
mux.Handle(http.MethodPost, pattern_Api_AddPlatform_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
|
|
ctx, cancel := context.WithCancel(req.Context())
|
|
defer cancel()
|
|
inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
|
|
annotatedContext, err := runtime.AnnotateContext(ctx, mux, req, "/gb28181pro.Api/AddPlatform", runtime.WithHTTPPathPattern("/gb28181/api/platform/add"))
|
|
if err != nil {
|
|
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
resp, md, err := request_Api_AddPlatform_0(annotatedContext, inboundMarshaler, client, req, pathParams)
|
|
annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
|
|
if err != nil {
|
|
runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
forward_Api_AddPlatform_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
|
|
})
|
|
mux.Handle(http.MethodGet, pattern_Api_GetPlatform_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
|
|
ctx, cancel := context.WithCancel(req.Context())
|
|
defer cancel()
|
|
inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
|
|
annotatedContext, err := runtime.AnnotateContext(ctx, mux, req, "/gb28181pro.Api/GetPlatform", runtime.WithHTTPPathPattern("/gb28181/api/platform/{id}"))
|
|
if err != nil {
|
|
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
resp, md, err := request_Api_GetPlatform_0(annotatedContext, inboundMarshaler, client, req, pathParams)
|
|
annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
|
|
if err != nil {
|
|
runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
forward_Api_GetPlatform_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
|
|
})
|
|
mux.Handle(http.MethodPost, pattern_Api_UpdatePlatform_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
|
|
ctx, cancel := context.WithCancel(req.Context())
|
|
defer cancel()
|
|
inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
|
|
annotatedContext, err := runtime.AnnotateContext(ctx, mux, req, "/gb28181pro.Api/UpdatePlatform", runtime.WithHTTPPathPattern("/gb28181/api/platform/update"))
|
|
if err != nil {
|
|
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
resp, md, err := request_Api_UpdatePlatform_0(annotatedContext, inboundMarshaler, client, req, pathParams)
|
|
annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
|
|
if err != nil {
|
|
runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
forward_Api_UpdatePlatform_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
|
|
})
|
|
mux.Handle(http.MethodDelete, pattern_Api_DeletePlatform_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
|
|
ctx, cancel := context.WithCancel(req.Context())
|
|
defer cancel()
|
|
inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
|
|
annotatedContext, err := runtime.AnnotateContext(ctx, mux, req, "/gb28181pro.Api/DeletePlatform", runtime.WithHTTPPathPattern("/gb28181/api/platform/{id}"))
|
|
if err != nil {
|
|
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
resp, md, err := request_Api_DeletePlatform_0(annotatedContext, inboundMarshaler, client, req, pathParams)
|
|
annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
|
|
if err != nil {
|
|
runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
forward_Api_DeletePlatform_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
|
|
})
|
|
mux.Handle(http.MethodGet, pattern_Api_ListPlatforms_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
|
|
ctx, cancel := context.WithCancel(req.Context())
|
|
defer cancel()
|
|
inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
|
|
annotatedContext, err := runtime.AnnotateContext(ctx, mux, req, "/gb28181pro.Api/ListPlatforms", runtime.WithHTTPPathPattern("/gb28181/api/platform/list"))
|
|
if err != nil {
|
|
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
resp, md, err := request_Api_ListPlatforms_0(annotatedContext, inboundMarshaler, client, req, pathParams)
|
|
annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
|
|
if err != nil {
|
|
runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
forward_Api_ListPlatforms_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
|
|
})
|
|
mux.Handle(http.MethodGet, pattern_Api_QueryRecord_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
|
|
ctx, cancel := context.WithCancel(req.Context())
|
|
defer cancel()
|
|
inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
|
|
annotatedContext, err := runtime.AnnotateContext(ctx, mux, req, "/gb28181pro.Api/QueryRecord", runtime.WithHTTPPathPattern("/gb28181/api/records/{deviceId}/{channelId}"))
|
|
if err != nil {
|
|
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
resp, md, err := request_Api_QueryRecord_0(annotatedContext, inboundMarshaler, client, req, pathParams)
|
|
annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
|
|
if err != nil {
|
|
runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
forward_Api_QueryRecord_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
|
|
})
|
|
mux.Handle(http.MethodGet, pattern_Api_PtzControl_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
|
|
ctx, cancel := context.WithCancel(req.Context())
|
|
defer cancel()
|
|
inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
|
|
annotatedContext, err := runtime.AnnotateContext(ctx, mux, req, "/gb28181pro.Api/PtzControl", runtime.WithHTTPPathPattern("/gb28181/api/ptz/{deviceId}/{channelId}"))
|
|
if err != nil {
|
|
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
resp, md, err := request_Api_PtzControl_0(annotatedContext, inboundMarshaler, client, req, pathParams)
|
|
annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
|
|
if err != nil {
|
|
runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
forward_Api_PtzControl_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
|
|
})
|
|
mux.Handle(http.MethodGet, pattern_Api_IrisControl_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
|
|
ctx, cancel := context.WithCancel(req.Context())
|
|
defer cancel()
|
|
inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
|
|
annotatedContext, err := runtime.AnnotateContext(ctx, mux, req, "/gb28181pro.Api/IrisControl", runtime.WithHTTPPathPattern("/gb28181/api/fi/iris/{deviceId}/{channelId}"))
|
|
if err != nil {
|
|
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
resp, md, err := request_Api_IrisControl_0(annotatedContext, inboundMarshaler, client, req, pathParams)
|
|
annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
|
|
if err != nil {
|
|
runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
forward_Api_IrisControl_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
|
|
})
|
|
mux.Handle(http.MethodGet, pattern_Api_FocusControl_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
|
|
ctx, cancel := context.WithCancel(req.Context())
|
|
defer cancel()
|
|
inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
|
|
annotatedContext, err := runtime.AnnotateContext(ctx, mux, req, "/gb28181pro.Api/FocusControl", runtime.WithHTTPPathPattern("/gb28181/api/fi/focus/{deviceId}/{channelId}"))
|
|
if err != nil {
|
|
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
resp, md, err := request_Api_FocusControl_0(annotatedContext, inboundMarshaler, client, req, pathParams)
|
|
annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
|
|
if err != nil {
|
|
runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
forward_Api_FocusControl_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
|
|
})
|
|
mux.Handle(http.MethodGet, pattern_Api_QueryPreset_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
|
|
ctx, cancel := context.WithCancel(req.Context())
|
|
defer cancel()
|
|
inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
|
|
annotatedContext, err := runtime.AnnotateContext(ctx, mux, req, "/gb28181pro.Api/QueryPreset", runtime.WithHTTPPathPattern("/gb28181/api/preset/query/{deviceId}/{channelId}"))
|
|
if err != nil {
|
|
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
resp, md, err := request_Api_QueryPreset_0(annotatedContext, inboundMarshaler, client, req, pathParams)
|
|
annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
|
|
if err != nil {
|
|
runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
forward_Api_QueryPreset_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
|
|
})
|
|
mux.Handle(http.MethodGet, pattern_Api_AddPreset_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
|
|
ctx, cancel := context.WithCancel(req.Context())
|
|
defer cancel()
|
|
inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
|
|
annotatedContext, err := runtime.AnnotateContext(ctx, mux, req, "/gb28181pro.Api/AddPreset", runtime.WithHTTPPathPattern("/gb28181/api/preset/{deviceId}/{channelId}"))
|
|
if err != nil {
|
|
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
resp, md, err := request_Api_AddPreset_0(annotatedContext, inboundMarshaler, client, req, pathParams)
|
|
annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
|
|
if err != nil {
|
|
runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
forward_Api_AddPreset_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
|
|
})
|
|
mux.Handle(http.MethodGet, pattern_Api_CallPreset_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
|
|
ctx, cancel := context.WithCancel(req.Context())
|
|
defer cancel()
|
|
inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
|
|
annotatedContext, err := runtime.AnnotateContext(ctx, mux, req, "/gb28181pro.Api/CallPreset", runtime.WithHTTPPathPattern("/gb28181/api/preset/call/{deviceId}/{channelId}"))
|
|
if err != nil {
|
|
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
resp, md, err := request_Api_CallPreset_0(annotatedContext, inboundMarshaler, client, req, pathParams)
|
|
annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
|
|
if err != nil {
|
|
runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
forward_Api_CallPreset_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
|
|
})
|
|
mux.Handle(http.MethodGet, pattern_Api_DeletePreset_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
|
|
ctx, cancel := context.WithCancel(req.Context())
|
|
defer cancel()
|
|
inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
|
|
annotatedContext, err := runtime.AnnotateContext(ctx, mux, req, "/gb28181pro.Api/DeletePreset", runtime.WithHTTPPathPattern("/gb28181/api/preset/delete/{deviceId}/{channelId}"))
|
|
if err != nil {
|
|
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
resp, md, err := request_Api_DeletePreset_0(annotatedContext, inboundMarshaler, client, req, pathParams)
|
|
annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
|
|
if err != nil {
|
|
runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
forward_Api_DeletePreset_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
|
|
})
|
|
mux.Handle(http.MethodGet, pattern_Api_AddCruisePoint_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
|
|
ctx, cancel := context.WithCancel(req.Context())
|
|
defer cancel()
|
|
inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
|
|
annotatedContext, err := runtime.AnnotateContext(ctx, mux, req, "/gb28181pro.Api/AddCruisePoint", runtime.WithHTTPPathPattern("/gb28181/api/cruise/point/add/{deviceId}/{channelId}"))
|
|
if err != nil {
|
|
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
resp, md, err := request_Api_AddCruisePoint_0(annotatedContext, inboundMarshaler, client, req, pathParams)
|
|
annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
|
|
if err != nil {
|
|
runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
forward_Api_AddCruisePoint_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
|
|
})
|
|
mux.Handle(http.MethodGet, pattern_Api_DeleteCruisePoint_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
|
|
ctx, cancel := context.WithCancel(req.Context())
|
|
defer cancel()
|
|
inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
|
|
annotatedContext, err := runtime.AnnotateContext(ctx, mux, req, "/gb28181pro.Api/DeleteCruisePoint", runtime.WithHTTPPathPattern("/gb28181/api/cruise/point/delete/{deviceId}/{channelId}"))
|
|
if err != nil {
|
|
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
resp, md, err := request_Api_DeleteCruisePoint_0(annotatedContext, inboundMarshaler, client, req, pathParams)
|
|
annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
|
|
if err != nil {
|
|
runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
forward_Api_DeleteCruisePoint_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
|
|
})
|
|
mux.Handle(http.MethodGet, pattern_Api_SetCruiseSpeed_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
|
|
ctx, cancel := context.WithCancel(req.Context())
|
|
defer cancel()
|
|
inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
|
|
annotatedContext, err := runtime.AnnotateContext(ctx, mux, req, "/gb28181pro.Api/SetCruiseSpeed", runtime.WithHTTPPathPattern("/gb28181/api/cruise/speed/{deviceId}/{channelId}"))
|
|
if err != nil {
|
|
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
resp, md, err := request_Api_SetCruiseSpeed_0(annotatedContext, inboundMarshaler, client, req, pathParams)
|
|
annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
|
|
if err != nil {
|
|
runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
forward_Api_SetCruiseSpeed_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
|
|
})
|
|
mux.Handle(http.MethodGet, pattern_Api_SetCruiseTime_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
|
|
ctx, cancel := context.WithCancel(req.Context())
|
|
defer cancel()
|
|
inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
|
|
annotatedContext, err := runtime.AnnotateContext(ctx, mux, req, "/gb28181pro.Api/SetCruiseTime", runtime.WithHTTPPathPattern("/gb28181/api/cruise/time/{deviceId}/{channelId}"))
|
|
if err != nil {
|
|
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
resp, md, err := request_Api_SetCruiseTime_0(annotatedContext, inboundMarshaler, client, req, pathParams)
|
|
annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
|
|
if err != nil {
|
|
runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
forward_Api_SetCruiseTime_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
|
|
})
|
|
mux.Handle(http.MethodGet, pattern_Api_StartCruise_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
|
|
ctx, cancel := context.WithCancel(req.Context())
|
|
defer cancel()
|
|
inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
|
|
annotatedContext, err := runtime.AnnotateContext(ctx, mux, req, "/gb28181pro.Api/StartCruise", runtime.WithHTTPPathPattern("/gb28181/api/cruise/start/{deviceId}/{channelId}"))
|
|
if err != nil {
|
|
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
resp, md, err := request_Api_StartCruise_0(annotatedContext, inboundMarshaler, client, req, pathParams)
|
|
annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
|
|
if err != nil {
|
|
runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
forward_Api_StartCruise_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
|
|
})
|
|
mux.Handle(http.MethodGet, pattern_Api_StopCruise_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
|
|
ctx, cancel := context.WithCancel(req.Context())
|
|
defer cancel()
|
|
inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
|
|
annotatedContext, err := runtime.AnnotateContext(ctx, mux, req, "/gb28181pro.Api/StopCruise", runtime.WithHTTPPathPattern("/gb28181/api/cruise/stop/{deviceId}/{channelId}"))
|
|
if err != nil {
|
|
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
resp, md, err := request_Api_StopCruise_0(annotatedContext, inboundMarshaler, client, req, pathParams)
|
|
annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
|
|
if err != nil {
|
|
runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
forward_Api_StopCruise_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
|
|
})
|
|
mux.Handle(http.MethodGet, pattern_Api_StartScan_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
|
|
ctx, cancel := context.WithCancel(req.Context())
|
|
defer cancel()
|
|
inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
|
|
annotatedContext, err := runtime.AnnotateContext(ctx, mux, req, "/gb28181pro.Api/StartScan", runtime.WithHTTPPathPattern("/gb28181/api/scan/start/{deviceId}/{channelId}"))
|
|
if err != nil {
|
|
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
resp, md, err := request_Api_StartScan_0(annotatedContext, inboundMarshaler, client, req, pathParams)
|
|
annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
|
|
if err != nil {
|
|
runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
forward_Api_StartScan_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
|
|
})
|
|
mux.Handle(http.MethodGet, pattern_Api_StopScan_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
|
|
ctx, cancel := context.WithCancel(req.Context())
|
|
defer cancel()
|
|
inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
|
|
annotatedContext, err := runtime.AnnotateContext(ctx, mux, req, "/gb28181pro.Api/StopScan", runtime.WithHTTPPathPattern("/gb28181/api/scan/stop/{deviceId}/{channelId}"))
|
|
if err != nil {
|
|
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
resp, md, err := request_Api_StopScan_0(annotatedContext, inboundMarshaler, client, req, pathParams)
|
|
annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
|
|
if err != nil {
|
|
runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
forward_Api_StopScan_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
|
|
})
|
|
mux.Handle(http.MethodGet, pattern_Api_SetScanLeft_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
|
|
ctx, cancel := context.WithCancel(req.Context())
|
|
defer cancel()
|
|
inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
|
|
annotatedContext, err := runtime.AnnotateContext(ctx, mux, req, "/gb28181pro.Api/SetScanLeft", runtime.WithHTTPPathPattern("/gb28181/api/scan/set/left/{deviceId}/{channelId}"))
|
|
if err != nil {
|
|
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
resp, md, err := request_Api_SetScanLeft_0(annotatedContext, inboundMarshaler, client, req, pathParams)
|
|
annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
|
|
if err != nil {
|
|
runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
forward_Api_SetScanLeft_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
|
|
})
|
|
mux.Handle(http.MethodGet, pattern_Api_SetScanRight_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
|
|
ctx, cancel := context.WithCancel(req.Context())
|
|
defer cancel()
|
|
inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
|
|
annotatedContext, err := runtime.AnnotateContext(ctx, mux, req, "/gb28181pro.Api/SetScanRight", runtime.WithHTTPPathPattern("/gb28181/api/scan/set/right/{deviceId}/{channelId}"))
|
|
if err != nil {
|
|
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
resp, md, err := request_Api_SetScanRight_0(annotatedContext, inboundMarshaler, client, req, pathParams)
|
|
annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
|
|
if err != nil {
|
|
runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
forward_Api_SetScanRight_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
|
|
})
|
|
mux.Handle(http.MethodGet, pattern_Api_SetScanSpeed_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
|
|
ctx, cancel := context.WithCancel(req.Context())
|
|
defer cancel()
|
|
inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
|
|
annotatedContext, err := runtime.AnnotateContext(ctx, mux, req, "/gb28181pro.Api/SetScanSpeed", runtime.WithHTTPPathPattern("/gb28181/api/scan/set/speed/{deviceId}/{channelId}"))
|
|
if err != nil {
|
|
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
resp, md, err := request_Api_SetScanSpeed_0(annotatedContext, inboundMarshaler, client, req, pathParams)
|
|
annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
|
|
if err != nil {
|
|
runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
forward_Api_SetScanSpeed_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
|
|
})
|
|
mux.Handle(http.MethodGet, pattern_Api_WiperControl_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
|
|
ctx, cancel := context.WithCancel(req.Context())
|
|
defer cancel()
|
|
inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
|
|
annotatedContext, err := runtime.AnnotateContext(ctx, mux, req, "/gb28181pro.Api/WiperControl", runtime.WithHTTPPathPattern("/gb28181/api/wiper/{deviceId}/{channelId}"))
|
|
if err != nil {
|
|
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
resp, md, err := request_Api_WiperControl_0(annotatedContext, inboundMarshaler, client, req, pathParams)
|
|
annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
|
|
if err != nil {
|
|
runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
forward_Api_WiperControl_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
|
|
})
|
|
mux.Handle(http.MethodGet, pattern_Api_AuxiliaryControl_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
|
|
ctx, cancel := context.WithCancel(req.Context())
|
|
defer cancel()
|
|
inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
|
|
annotatedContext, err := runtime.AnnotateContext(ctx, mux, req, "/gb28181pro.Api/AuxiliaryControl", runtime.WithHTTPPathPattern("/gb28181/api/auxiliary/{deviceId}/{channelId}"))
|
|
if err != nil {
|
|
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
resp, md, err := request_Api_AuxiliaryControl_0(annotatedContext, inboundMarshaler, client, req, pathParams)
|
|
annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
|
|
if err != nil {
|
|
runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
forward_Api_AuxiliaryControl_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
|
|
})
|
|
mux.Handle(http.MethodGet, pattern_Api_TestSip_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
|
|
ctx, cancel := context.WithCancel(req.Context())
|
|
defer cancel()
|
|
inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
|
|
annotatedContext, err := runtime.AnnotateContext(ctx, mux, req, "/gb28181pro.Api/TestSip", runtime.WithHTTPPathPattern("/gb28181/api/testsip"))
|
|
if err != nil {
|
|
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
resp, md, err := request_Api_TestSip_0(annotatedContext, inboundMarshaler, client, req, pathParams)
|
|
annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
|
|
if err != nil {
|
|
runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
forward_Api_TestSip_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
|
|
})
|
|
mux.Handle(http.MethodGet, pattern_Api_SearchAlarms_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
|
|
ctx, cancel := context.WithCancel(req.Context())
|
|
defer cancel()
|
|
inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
|
|
annotatedContext, err := runtime.AnnotateContext(ctx, mux, req, "/gb28181pro.Api/SearchAlarms", runtime.WithHTTPPathPattern("/gb28181/api/alarms/{deviceId}"))
|
|
if err != nil {
|
|
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
resp, md, err := request_Api_SearchAlarms_0(annotatedContext, inboundMarshaler, client, req, pathParams)
|
|
annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
|
|
if err != nil {
|
|
runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
forward_Api_SearchAlarms_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
|
|
})
|
|
mux.Handle(http.MethodPost, pattern_Api_AddPlatformChannel_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
|
|
ctx, cancel := context.WithCancel(req.Context())
|
|
defer cancel()
|
|
inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
|
|
annotatedContext, err := runtime.AnnotateContext(ctx, mux, req, "/gb28181pro.Api/AddPlatformChannel", runtime.WithHTTPPathPattern("/gb28181/api/platform/channel/add"))
|
|
if err != nil {
|
|
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
resp, md, err := request_Api_AddPlatformChannel_0(annotatedContext, inboundMarshaler, client, req, pathParams)
|
|
annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
|
|
if err != nil {
|
|
runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
forward_Api_AddPlatformChannel_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
|
|
})
|
|
mux.Handle(http.MethodGet, pattern_Api_Recording_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
|
|
ctx, cancel := context.WithCancel(req.Context())
|
|
defer cancel()
|
|
inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
|
|
annotatedContext, err := runtime.AnnotateContext(ctx, mux, req, "/gb28181pro.Api/Recording", runtime.WithHTTPPathPattern("/gb28181/api/recording/{cmdType}/{deviceId}/{channelId}"))
|
|
if err != nil {
|
|
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
resp, md, err := request_Api_Recording_0(annotatedContext, inboundMarshaler, client, req, pathParams)
|
|
annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
|
|
if err != nil {
|
|
runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
forward_Api_Recording_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
|
|
})
|
|
mux.Handle(http.MethodPost, pattern_Api_UploadJpeg_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
|
|
ctx, cancel := context.WithCancel(req.Context())
|
|
defer cancel()
|
|
inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
|
|
annotatedContext, err := runtime.AnnotateContext(ctx, mux, req, "/gb28181pro.Api/UploadJpeg", runtime.WithHTTPPathPattern("/gb28181/api/snap/upload"))
|
|
if err != nil {
|
|
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
resp, md, err := request_Api_UploadJpeg_0(annotatedContext, inboundMarshaler, client, req, pathParams)
|
|
annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
|
|
if err != nil {
|
|
runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
forward_Api_UploadJpeg_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
|
|
})
|
|
mux.Handle(http.MethodPost, pattern_Api_UpdateChannel_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
|
|
ctx, cancel := context.WithCancel(req.Context())
|
|
defer cancel()
|
|
inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
|
|
annotatedContext, err := runtime.AnnotateContext(ctx, mux, req, "/gb28181pro.Api/UpdateChannel", runtime.WithHTTPPathPattern("/gb28181/api/channel/update/{id}"))
|
|
if err != nil {
|
|
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
resp, md, err := request_Api_UpdateChannel_0(annotatedContext, inboundMarshaler, client, req, pathParams)
|
|
annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
|
|
if err != nil {
|
|
runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
forward_Api_UpdateChannel_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
|
|
})
|
|
mux.Handle(http.MethodGet, pattern_Api_PlaybackPause_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
|
|
ctx, cancel := context.WithCancel(req.Context())
|
|
defer cancel()
|
|
inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
|
|
annotatedContext, err := runtime.AnnotateContext(ctx, mux, req, "/gb28181pro.Api/PlaybackPause", runtime.WithHTTPPathPattern("/gb28181/api/playback/pause"))
|
|
if err != nil {
|
|
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
resp, md, err := request_Api_PlaybackPause_0(annotatedContext, inboundMarshaler, client, req, pathParams)
|
|
annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
|
|
if err != nil {
|
|
runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
forward_Api_PlaybackPause_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
|
|
})
|
|
mux.Handle(http.MethodGet, pattern_Api_PlaybackResume_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
|
|
ctx, cancel := context.WithCancel(req.Context())
|
|
defer cancel()
|
|
inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
|
|
annotatedContext, err := runtime.AnnotateContext(ctx, mux, req, "/gb28181pro.Api/PlaybackResume", runtime.WithHTTPPathPattern("/gb28181/api/playback/resume"))
|
|
if err != nil {
|
|
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
resp, md, err := request_Api_PlaybackResume_0(annotatedContext, inboundMarshaler, client, req, pathParams)
|
|
annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
|
|
if err != nil {
|
|
runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
forward_Api_PlaybackResume_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
|
|
})
|
|
mux.Handle(http.MethodGet, pattern_Api_PlaybackSeek_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
|
|
ctx, cancel := context.WithCancel(req.Context())
|
|
defer cancel()
|
|
inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
|
|
annotatedContext, err := runtime.AnnotateContext(ctx, mux, req, "/gb28181pro.Api/PlaybackSeek", runtime.WithHTTPPathPattern("/gb28181/api/playback/seek"))
|
|
if err != nil {
|
|
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
resp, md, err := request_Api_PlaybackSeek_0(annotatedContext, inboundMarshaler, client, req, pathParams)
|
|
annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
|
|
if err != nil {
|
|
runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
forward_Api_PlaybackSeek_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
|
|
})
|
|
mux.Handle(http.MethodGet, pattern_Api_PlaybackSpeed_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
|
|
ctx, cancel := context.WithCancel(req.Context())
|
|
defer cancel()
|
|
inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
|
|
annotatedContext, err := runtime.AnnotateContext(ctx, mux, req, "/gb28181pro.Api/PlaybackSpeed", runtime.WithHTTPPathPattern("/gb28181/api/playback/speed"))
|
|
if err != nil {
|
|
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
resp, md, err := request_Api_PlaybackSpeed_0(annotatedContext, inboundMarshaler, client, req, pathParams)
|
|
annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
|
|
if err != nil {
|
|
runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
forward_Api_PlaybackSpeed_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
|
|
})
|
|
mux.Handle(http.MethodGet, pattern_Api_GetGroups_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
|
|
ctx, cancel := context.WithCancel(req.Context())
|
|
defer cancel()
|
|
inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
|
|
annotatedContext, err := runtime.AnnotateContext(ctx, mux, req, "/gb28181pro.Api/GetGroups", runtime.WithHTTPPathPattern("/gb28181/api/groups/{pid}"))
|
|
if err != nil {
|
|
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
resp, md, err := request_Api_GetGroups_0(annotatedContext, inboundMarshaler, client, req, pathParams)
|
|
annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
|
|
if err != nil {
|
|
runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
forward_Api_GetGroups_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
|
|
})
|
|
mux.Handle(http.MethodPost, pattern_Api_AddGroup_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
|
|
ctx, cancel := context.WithCancel(req.Context())
|
|
defer cancel()
|
|
inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
|
|
annotatedContext, err := runtime.AnnotateContext(ctx, mux, req, "/gb28181pro.Api/AddGroup", runtime.WithHTTPPathPattern("/gb28181/api/groups/add"))
|
|
if err != nil {
|
|
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
resp, md, err := request_Api_AddGroup_0(annotatedContext, inboundMarshaler, client, req, pathParams)
|
|
annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
|
|
if err != nil {
|
|
runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
forward_Api_AddGroup_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
|
|
})
|
|
mux.Handle(http.MethodPost, pattern_Api_UpdateGroup_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
|
|
ctx, cancel := context.WithCancel(req.Context())
|
|
defer cancel()
|
|
inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
|
|
annotatedContext, err := runtime.AnnotateContext(ctx, mux, req, "/gb28181pro.Api/UpdateGroup", runtime.WithHTTPPathPattern("/gb28181/api/groups/update"))
|
|
if err != nil {
|
|
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
resp, md, err := request_Api_UpdateGroup_0(annotatedContext, inboundMarshaler, client, req, pathParams)
|
|
annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
|
|
if err != nil {
|
|
runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
forward_Api_UpdateGroup_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
|
|
})
|
|
mux.Handle(http.MethodPost, pattern_Api_DeleteGroup_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
|
|
ctx, cancel := context.WithCancel(req.Context())
|
|
defer cancel()
|
|
inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
|
|
annotatedContext, err := runtime.AnnotateContext(ctx, mux, req, "/gb28181pro.Api/DeleteGroup", runtime.WithHTTPPathPattern("/gb28181/api/groups/delete/{id}"))
|
|
if err != nil {
|
|
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
resp, md, err := request_Api_DeleteGroup_0(annotatedContext, inboundMarshaler, client, req, pathParams)
|
|
annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
|
|
if err != nil {
|
|
runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
forward_Api_DeleteGroup_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
|
|
})
|
|
mux.Handle(http.MethodPost, pattern_Api_AddGroupChannel_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
|
|
ctx, cancel := context.WithCancel(req.Context())
|
|
defer cancel()
|
|
inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
|
|
annotatedContext, err := runtime.AnnotateContext(ctx, mux, req, "/gb28181pro.Api/AddGroupChannel", runtime.WithHTTPPathPattern("/gb28181/api/groups/channel/add/{groupId}"))
|
|
if err != nil {
|
|
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
resp, md, err := request_Api_AddGroupChannel_0(annotatedContext, inboundMarshaler, client, req, pathParams)
|
|
annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
|
|
if err != nil {
|
|
runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
forward_Api_AddGroupChannel_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
|
|
})
|
|
mux.Handle(http.MethodPost, pattern_Api_DeleteGroupChannel_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
|
|
ctx, cancel := context.WithCancel(req.Context())
|
|
defer cancel()
|
|
inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
|
|
annotatedContext, err := runtime.AnnotateContext(ctx, mux, req, "/gb28181pro.Api/DeleteGroupChannel", runtime.WithHTTPPathPattern("/gb28181/api/groups/channel/delete/{groupId}"))
|
|
if err != nil {
|
|
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
resp, md, err := request_Api_DeleteGroupChannel_0(annotatedContext, inboundMarshaler, client, req, pathParams)
|
|
annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
|
|
if err != nil {
|
|
runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
forward_Api_DeleteGroupChannel_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
|
|
})
|
|
mux.Handle(http.MethodGet, pattern_Api_GetGroupChannels_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
|
|
ctx, cancel := context.WithCancel(req.Context())
|
|
defer cancel()
|
|
inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
|
|
annotatedContext, err := runtime.AnnotateContext(ctx, mux, req, "/gb28181pro.Api/GetGroupChannels", runtime.WithHTTPPathPattern("/gb28181/api/groups/{groupId}/channels"))
|
|
if err != nil {
|
|
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
resp, md, err := request_Api_GetGroupChannels_0(annotatedContext, inboundMarshaler, client, req, pathParams)
|
|
annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
|
|
if err != nil {
|
|
runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
forward_Api_GetGroupChannels_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
|
|
})
|
|
mux.Handle(http.MethodPost, pattern_Api_RemoveDevice_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
|
|
ctx, cancel := context.WithCancel(req.Context())
|
|
defer cancel()
|
|
inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
|
|
annotatedContext, err := runtime.AnnotateContext(ctx, mux, req, "/gb28181pro.Api/RemoveDevice", runtime.WithHTTPPathPattern("/gb28181/api/device/remove/{id}"))
|
|
if err != nil {
|
|
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
resp, md, err := request_Api_RemoveDevice_0(annotatedContext, inboundMarshaler, client, req, pathParams)
|
|
annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
|
|
if err != nil {
|
|
runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
forward_Api_RemoveDevice_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
|
|
})
|
|
mux.Handle(http.MethodPost, pattern_Api_ReceiveAlarm_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
|
|
ctx, cancel := context.WithCancel(req.Context())
|
|
defer cancel()
|
|
inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
|
|
annotatedContext, err := runtime.AnnotateContext(ctx, mux, req, "/gb28181pro.Api/ReceiveAlarm", runtime.WithHTTPPathPattern("/gb28181/api/alarm/receive"))
|
|
if err != nil {
|
|
runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
resp, md, err := request_Api_ReceiveAlarm_0(annotatedContext, inboundMarshaler, client, req, pathParams)
|
|
annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)
|
|
if err != nil {
|
|
runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)
|
|
return
|
|
}
|
|
forward_Api_ReceiveAlarm_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
|
|
})
|
|
return nil
|
|
}
|
|
|
|
var (
|
|
pattern_Api_List_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"gb28181", "api", "list"}, ""))
|
|
pattern_Api_GetDevice_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 1, 0, 4, 1, 5, 3}, []string{"gb28181", "api", "devices", "deviceId"}, ""))
|
|
pattern_Api_GetDevices_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"gb28181", "api", "devices"}, ""))
|
|
pattern_Api_GetChannels_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 1, 0, 4, 1, 5, 3, 2, 4}, []string{"gb28181", "api", "devices", "deviceId", "channels"}, ""))
|
|
pattern_Api_SyncDevice_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 1, 0, 4, 1, 5, 3, 2, 4}, []string{"gb28181", "api", "devices", "deviceId", "sync"}, ""))
|
|
pattern_Api_DeleteDevice_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 1, 0, 4, 1, 5, 3, 2, 4}, []string{"gb28181", "api", "devices", "deviceId", "delete"}, ""))
|
|
pattern_Api_GetSubChannels_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 1, 0, 4, 1, 5, 3, 1, 0, 4, 1, 5, 4, 2, 5}, []string{"gb28181", "api", "sub_channels", "deviceId", "channelId", "channels"}, ""))
|
|
pattern_Api_ChangeAudio_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"gb28181", "api", "channel", "audio"}, ""))
|
|
pattern_Api_UpdateChannelStreamIdentification_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 2, 4, 2, 5}, []string{"gb28181", "api", "channel", "stream", "identification", "update"}, ""))
|
|
pattern_Api_UpdateTransport_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 1, 0, 4, 1, 5, 3, 1, 0, 4, 1, 5, 4}, []string{"gb28181", "api", "transport", "deviceId", "streamMode"}, ""))
|
|
pattern_Api_AddDevice_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"gb28181", "api", "device", "add"}, ""))
|
|
pattern_Api_UpdateDevice_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"gb28181", "api", "device", "update"}, ""))
|
|
pattern_Api_GetDeviceStatus_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 1, 0, 4, 1, 5, 3, 2, 4}, []string{"gb28181", "api", "devices", "deviceId", "status"}, ""))
|
|
pattern_Api_GetDeviceAlarm_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 1, 0, 4, 1, 5, 3}, []string{"gb28181", "api", "alarm", "deviceId"}, ""))
|
|
pattern_Api_GetSyncStatus_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 1, 0, 4, 1, 5, 2, 2, 3}, []string{"gb28181", "api", "deviceId", "sync_status"}, ""))
|
|
pattern_Api_GetSubscribeInfo_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 1, 0, 4, 1, 5, 2, 2, 3}, []string{"gb28181", "api", "deviceId", "subscribe_info"}, ""))
|
|
pattern_Api_GetSnap_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 1, 0, 4, 1, 5, 3, 1, 0, 4, 1, 5, 4}, []string{"gb28181", "api", "snap", "deviceId", "channelId"}, ""))
|
|
pattern_Api_StopConvert_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 1, 0, 4, 1, 5, 4}, []string{"gb28181", "api", "play", "convertStop", "key"}, ""))
|
|
pattern_Api_StartBroadcast_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 1, 0, 4, 1, 5, 4, 1, 0, 4, 1, 5, 5}, []string{"gb28181", "api", "play", "broadcast", "deviceId", "channelId"}, ""))
|
|
pattern_Api_StopBroadcast_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 2, 4, 1, 0, 4, 1, 5, 5, 1, 0, 4, 1, 5, 6}, []string{"gb28181", "api", "play", "broadcast", "stop", "deviceId", "channelId"}, ""))
|
|
pattern_Api_GetAllSSRC_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"gb28181", "api", "play", "ssrc"}, ""))
|
|
pattern_Api_GetRawChannel_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"gb28181", "api", "channel", "raw"}, ""))
|
|
pattern_Api_AddPlatform_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"gb28181", "api", "platform", "add"}, ""))
|
|
pattern_Api_GetPlatform_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 1, 0, 4, 1, 5, 3}, []string{"gb28181", "api", "platform", "id"}, ""))
|
|
pattern_Api_UpdatePlatform_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"gb28181", "api", "platform", "update"}, ""))
|
|
pattern_Api_DeletePlatform_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 1, 0, 4, 1, 5, 3}, []string{"gb28181", "api", "platform", "id"}, ""))
|
|
pattern_Api_ListPlatforms_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"gb28181", "api", "platform", "list"}, ""))
|
|
pattern_Api_QueryRecord_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 1, 0, 4, 1, 5, 3, 1, 0, 4, 1, 5, 4}, []string{"gb28181", "api", "records", "deviceId", "channelId"}, ""))
|
|
pattern_Api_PtzControl_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 1, 0, 4, 1, 5, 3, 1, 0, 4, 1, 5, 4}, []string{"gb28181", "api", "ptz", "deviceId", "channelId"}, ""))
|
|
pattern_Api_IrisControl_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 1, 0, 4, 1, 5, 4, 1, 0, 4, 1, 5, 5}, []string{"gb28181", "api", "fi", "iris", "deviceId", "channelId"}, ""))
|
|
pattern_Api_FocusControl_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 1, 0, 4, 1, 5, 4, 1, 0, 4, 1, 5, 5}, []string{"gb28181", "api", "fi", "focus", "deviceId", "channelId"}, ""))
|
|
pattern_Api_QueryPreset_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 1, 0, 4, 1, 5, 4, 1, 0, 4, 1, 5, 5}, []string{"gb28181", "api", "preset", "query", "deviceId", "channelId"}, ""))
|
|
pattern_Api_AddPreset_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 1, 0, 4, 1, 5, 3, 1, 0, 4, 1, 5, 4}, []string{"gb28181", "api", "preset", "deviceId", "channelId"}, ""))
|
|
pattern_Api_CallPreset_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 1, 0, 4, 1, 5, 4, 1, 0, 4, 1, 5, 5}, []string{"gb28181", "api", "preset", "call", "deviceId", "channelId"}, ""))
|
|
pattern_Api_DeletePreset_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 1, 0, 4, 1, 5, 4, 1, 0, 4, 1, 5, 5}, []string{"gb28181", "api", "preset", "delete", "deviceId", "channelId"}, ""))
|
|
pattern_Api_AddCruisePoint_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 2, 4, 1, 0, 4, 1, 5, 5, 1, 0, 4, 1, 5, 6}, []string{"gb28181", "api", "cruise", "point", "add", "deviceId", "channelId"}, ""))
|
|
pattern_Api_DeleteCruisePoint_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 2, 4, 1, 0, 4, 1, 5, 5, 1, 0, 4, 1, 5, 6}, []string{"gb28181", "api", "cruise", "point", "delete", "deviceId", "channelId"}, ""))
|
|
pattern_Api_SetCruiseSpeed_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 1, 0, 4, 1, 5, 4, 1, 0, 4, 1, 5, 5}, []string{"gb28181", "api", "cruise", "speed", "deviceId", "channelId"}, ""))
|
|
pattern_Api_SetCruiseTime_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 1, 0, 4, 1, 5, 4, 1, 0, 4, 1, 5, 5}, []string{"gb28181", "api", "cruise", "time", "deviceId", "channelId"}, ""))
|
|
pattern_Api_StartCruise_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 1, 0, 4, 1, 5, 4, 1, 0, 4, 1, 5, 5}, []string{"gb28181", "api", "cruise", "start", "deviceId", "channelId"}, ""))
|
|
pattern_Api_StopCruise_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 1, 0, 4, 1, 5, 4, 1, 0, 4, 1, 5, 5}, []string{"gb28181", "api", "cruise", "stop", "deviceId", "channelId"}, ""))
|
|
pattern_Api_StartScan_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 1, 0, 4, 1, 5, 4, 1, 0, 4, 1, 5, 5}, []string{"gb28181", "api", "scan", "start", "deviceId", "channelId"}, ""))
|
|
pattern_Api_StopScan_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 1, 0, 4, 1, 5, 4, 1, 0, 4, 1, 5, 5}, []string{"gb28181", "api", "scan", "stop", "deviceId", "channelId"}, ""))
|
|
pattern_Api_SetScanLeft_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 2, 4, 1, 0, 4, 1, 5, 5, 1, 0, 4, 1, 5, 6}, []string{"gb28181", "api", "scan", "set", "left", "deviceId", "channelId"}, ""))
|
|
pattern_Api_SetScanRight_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 2, 4, 1, 0, 4, 1, 5, 5, 1, 0, 4, 1, 5, 6}, []string{"gb28181", "api", "scan", "set", "right", "deviceId", "channelId"}, ""))
|
|
pattern_Api_SetScanSpeed_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 2, 4, 1, 0, 4, 1, 5, 5, 1, 0, 4, 1, 5, 6}, []string{"gb28181", "api", "scan", "set", "speed", "deviceId", "channelId"}, ""))
|
|
pattern_Api_WiperControl_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 1, 0, 4, 1, 5, 3, 1, 0, 4, 1, 5, 4}, []string{"gb28181", "api", "wiper", "deviceId", "channelId"}, ""))
|
|
pattern_Api_AuxiliaryControl_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 1, 0, 4, 1, 5, 3, 1, 0, 4, 1, 5, 4}, []string{"gb28181", "api", "auxiliary", "deviceId", "channelId"}, ""))
|
|
pattern_Api_TestSip_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"gb28181", "api", "testsip"}, ""))
|
|
pattern_Api_SearchAlarms_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 1, 0, 4, 1, 5, 3}, []string{"gb28181", "api", "alarms", "deviceId"}, ""))
|
|
pattern_Api_AddPlatformChannel_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 2, 4}, []string{"gb28181", "api", "platform", "channel", "add"}, ""))
|
|
pattern_Api_Recording_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 1, 0, 4, 1, 5, 3, 1, 0, 4, 1, 5, 4, 1, 0, 4, 1, 5, 5}, []string{"gb28181", "api", "recording", "cmdType", "deviceId", "channelId"}, ""))
|
|
pattern_Api_UploadJpeg_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"gb28181", "api", "snap", "upload"}, ""))
|
|
pattern_Api_UpdateChannel_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 1, 0, 4, 1, 5, 4}, []string{"gb28181", "api", "channel", "update", "id"}, ""))
|
|
pattern_Api_PlaybackPause_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"gb28181", "api", "playback", "pause"}, ""))
|
|
pattern_Api_PlaybackResume_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"gb28181", "api", "playback", "resume"}, ""))
|
|
pattern_Api_PlaybackSeek_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"gb28181", "api", "playback", "seek"}, ""))
|
|
pattern_Api_PlaybackSpeed_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"gb28181", "api", "playback", "speed"}, ""))
|
|
pattern_Api_GetGroups_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 1, 0, 4, 1, 5, 3}, []string{"gb28181", "api", "groups", "pid"}, ""))
|
|
pattern_Api_AddGroup_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"gb28181", "api", "groups", "add"}, ""))
|
|
pattern_Api_UpdateGroup_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"gb28181", "api", "groups", "update"}, ""))
|
|
pattern_Api_DeleteGroup_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 1, 0, 4, 1, 5, 4}, []string{"gb28181", "api", "groups", "delete", "id"}, ""))
|
|
pattern_Api_AddGroupChannel_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 2, 4, 1, 0, 4, 1, 5, 5}, []string{"gb28181", "api", "groups", "channel", "add", "groupId"}, ""))
|
|
pattern_Api_DeleteGroupChannel_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 2, 4, 1, 0, 4, 1, 5, 5}, []string{"gb28181", "api", "groups", "channel", "delete", "groupId"}, ""))
|
|
pattern_Api_GetGroupChannels_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 1, 0, 4, 1, 5, 3, 2, 4}, []string{"gb28181", "api", "groups", "groupId", "channels"}, ""))
|
|
pattern_Api_RemoveDevice_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 1, 0, 4, 1, 5, 4}, []string{"gb28181", "api", "device", "remove", "id"}, ""))
|
|
pattern_Api_ReceiveAlarm_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"gb28181", "api", "alarm", "receive"}, ""))
|
|
)
|
|
|
|
var (
|
|
forward_Api_List_0 = runtime.ForwardResponseMessage
|
|
forward_Api_GetDevice_0 = runtime.ForwardResponseMessage
|
|
forward_Api_GetDevices_0 = runtime.ForwardResponseMessage
|
|
forward_Api_GetChannels_0 = runtime.ForwardResponseMessage
|
|
forward_Api_SyncDevice_0 = runtime.ForwardResponseMessage
|
|
forward_Api_DeleteDevice_0 = runtime.ForwardResponseMessage
|
|
forward_Api_GetSubChannels_0 = runtime.ForwardResponseMessage
|
|
forward_Api_ChangeAudio_0 = runtime.ForwardResponseMessage
|
|
forward_Api_UpdateChannelStreamIdentification_0 = runtime.ForwardResponseMessage
|
|
forward_Api_UpdateTransport_0 = runtime.ForwardResponseMessage
|
|
forward_Api_AddDevice_0 = runtime.ForwardResponseMessage
|
|
forward_Api_UpdateDevice_0 = runtime.ForwardResponseMessage
|
|
forward_Api_GetDeviceStatus_0 = runtime.ForwardResponseMessage
|
|
forward_Api_GetDeviceAlarm_0 = runtime.ForwardResponseMessage
|
|
forward_Api_GetSyncStatus_0 = runtime.ForwardResponseMessage
|
|
forward_Api_GetSubscribeInfo_0 = runtime.ForwardResponseMessage
|
|
forward_Api_GetSnap_0 = runtime.ForwardResponseMessage
|
|
forward_Api_StopConvert_0 = runtime.ForwardResponseMessage
|
|
forward_Api_StartBroadcast_0 = runtime.ForwardResponseMessage
|
|
forward_Api_StopBroadcast_0 = runtime.ForwardResponseMessage
|
|
forward_Api_GetAllSSRC_0 = runtime.ForwardResponseMessage
|
|
forward_Api_GetRawChannel_0 = runtime.ForwardResponseMessage
|
|
forward_Api_AddPlatform_0 = runtime.ForwardResponseMessage
|
|
forward_Api_GetPlatform_0 = runtime.ForwardResponseMessage
|
|
forward_Api_UpdatePlatform_0 = runtime.ForwardResponseMessage
|
|
forward_Api_DeletePlatform_0 = runtime.ForwardResponseMessage
|
|
forward_Api_ListPlatforms_0 = runtime.ForwardResponseMessage
|
|
forward_Api_QueryRecord_0 = runtime.ForwardResponseMessage
|
|
forward_Api_PtzControl_0 = runtime.ForwardResponseMessage
|
|
forward_Api_IrisControl_0 = runtime.ForwardResponseMessage
|
|
forward_Api_FocusControl_0 = runtime.ForwardResponseMessage
|
|
forward_Api_QueryPreset_0 = runtime.ForwardResponseMessage
|
|
forward_Api_AddPreset_0 = runtime.ForwardResponseMessage
|
|
forward_Api_CallPreset_0 = runtime.ForwardResponseMessage
|
|
forward_Api_DeletePreset_0 = runtime.ForwardResponseMessage
|
|
forward_Api_AddCruisePoint_0 = runtime.ForwardResponseMessage
|
|
forward_Api_DeleteCruisePoint_0 = runtime.ForwardResponseMessage
|
|
forward_Api_SetCruiseSpeed_0 = runtime.ForwardResponseMessage
|
|
forward_Api_SetCruiseTime_0 = runtime.ForwardResponseMessage
|
|
forward_Api_StartCruise_0 = runtime.ForwardResponseMessage
|
|
forward_Api_StopCruise_0 = runtime.ForwardResponseMessage
|
|
forward_Api_StartScan_0 = runtime.ForwardResponseMessage
|
|
forward_Api_StopScan_0 = runtime.ForwardResponseMessage
|
|
forward_Api_SetScanLeft_0 = runtime.ForwardResponseMessage
|
|
forward_Api_SetScanRight_0 = runtime.ForwardResponseMessage
|
|
forward_Api_SetScanSpeed_0 = runtime.ForwardResponseMessage
|
|
forward_Api_WiperControl_0 = runtime.ForwardResponseMessage
|
|
forward_Api_AuxiliaryControl_0 = runtime.ForwardResponseMessage
|
|
forward_Api_TestSip_0 = runtime.ForwardResponseMessage
|
|
forward_Api_SearchAlarms_0 = runtime.ForwardResponseMessage
|
|
forward_Api_AddPlatformChannel_0 = runtime.ForwardResponseMessage
|
|
forward_Api_Recording_0 = runtime.ForwardResponseMessage
|
|
forward_Api_UploadJpeg_0 = runtime.ForwardResponseMessage
|
|
forward_Api_UpdateChannel_0 = runtime.ForwardResponseMessage
|
|
forward_Api_PlaybackPause_0 = runtime.ForwardResponseMessage
|
|
forward_Api_PlaybackResume_0 = runtime.ForwardResponseMessage
|
|
forward_Api_PlaybackSeek_0 = runtime.ForwardResponseMessage
|
|
forward_Api_PlaybackSpeed_0 = runtime.ForwardResponseMessage
|
|
forward_Api_GetGroups_0 = runtime.ForwardResponseMessage
|
|
forward_Api_AddGroup_0 = runtime.ForwardResponseMessage
|
|
forward_Api_UpdateGroup_0 = runtime.ForwardResponseMessage
|
|
forward_Api_DeleteGroup_0 = runtime.ForwardResponseMessage
|
|
forward_Api_AddGroupChannel_0 = runtime.ForwardResponseMessage
|
|
forward_Api_DeleteGroupChannel_0 = runtime.ForwardResponseMessage
|
|
forward_Api_GetGroupChannels_0 = runtime.ForwardResponseMessage
|
|
forward_Api_RemoveDevice_0 = runtime.ForwardResponseMessage
|
|
forward_Api_ReceiveAlarm_0 = runtime.ForwardResponseMessage
|
|
)
|