protobuf_endpoint_converters.microgen.go

// Code generated by microgen 0.9.1. DO NOT EDIT.

// Please, do not change functions names!
package transportgrpc

import (
	"context"
	"errors"

	transport "git.perx.ru/perxis/perxis-go/pkg/delivery/transport"
	pb "git.perx.ru/perxis/perxis-go/proto/delivery"
)

func _Encode_ListLocales_Request(ctx context.Context, request interface{}) (interface{}, error) {
	if request == nil {
		return nil, errors.New("nil ListLocalesRequest")
	}
	req := request.(*transport.ListLocalesRequest)
	return &pb.ListLocalesRequest{SpaceId: req.SpaceId}, nil
}

func _Encode_GetEnvironment_Request(ctx context.Context, request interface{}) (interface{}, error) {
	if request == nil {
		return nil, errors.New("nil GetEnvironmentRequest")
	}
	req := request.(*transport.GetEnvironmentRequest)
	return &pb.GetEnvironmentRequest{
		EnvId:   req.EnvId,
		SpaceId: req.SpaceId,
	}, nil
}

func _Encode_ListEnvironments_Request(ctx context.Context, request interface{}) (interface{}, error) {
	if request == nil {
		return nil, errors.New("nil ListEnvironmentsRequest")
	}
	req := request.(*transport.ListEnvironmentsRequest)
	return &pb.ListEnvironmentsRequest{SpaceId: req.SpaceId}, nil
}

func _Encode_GetCollection_Request(ctx context.Context, request interface{}) (interface{}, error) {
	if request == nil {
		return nil, errors.New("nil GetCollectionRequest")
	}
	req := request.(*transport.GetCollectionRequest)
	return &pb.GetCollectionRequest{
		CollectionId: req.CollectionId,
		EnvId:        req.EnvId,
		SpaceId:      req.SpaceId,
	}, nil
}

func _Encode_ListCollections_Request(ctx context.Context, request interface{}) (interface{}, error) {
	if request == nil {
		return nil, errors.New("nil ListCollectionsRequest")
	}
	req := request.(*transport.ListCollectionsRequest)
	return &pb.ListCollectionsRequest{
		EnvId:   req.EnvId,
		SpaceId: req.SpaceId,
	}, nil
}

func _Encode_GetItem_Request(ctx context.Context, request interface{}) (interface{}, error) {
	if request == nil {
		return nil, errors.New("nil GetItemRequest")
	}
	req := request.(*transport.GetItemRequest)
	reqOptions, err := ElPtrItemsGetPublishedOptionsToProto(req.Options)
	if err != nil {
		return nil, err
	}
	return &pb.GetItemRequest{
		CollectionId: req.CollectionId,
		EnvId:        req.EnvId,
		ItemId:       req.ItemId,
		SpaceId:      req.SpaceId,
		Options:      reqOptions,
	}, nil
}

func _Encode_FindItems_Request(ctx context.Context, request interface{}) (interface{}, error) {
	if request == nil {
		return nil, errors.New("nil FindItemsRequest")
	}
	req := request.(*transport.FindItemsRequest)
	reqFilter, err := PtrItemsFilterToProto(req.Filter)
	if err != nil {
		return nil, err
	}
	reqOptions, err := ElPtrItemsFindPublishedOptionsToProto(req.Options)
	if err != nil {
		return nil, err
	}
	return &pb.FindItemsRequest{
		CollectionId: req.CollectionId,
		EnvId:        req.EnvId,
		Filter:       reqFilter,
		Options:      reqOptions,
		SpaceId:      req.SpaceId,
	}, nil
}

func _Encode_ListLocales_Response(ctx context.Context, response interface{}) (interface{}, error) {
	if response == nil {
		return nil, errors.New("nil ListLocalesResponse")
	}
	resp := response.(*transport.ListLocalesResponse)
	respLocales, err := ListPtrLocalesLocaleToProto(resp.Locales)
	if err != nil {
		return nil, err
	}
	return &pb.ListLocalesResponse{Locales: respLocales}, nil
}

func _Encode_GetEnvironment_Response(ctx context.Context, response interface{}) (interface{}, error) {
	if response == nil {
		return nil, errors.New("nil GetEnvironmentResponse")
	}
	resp := response.(*transport.GetEnvironmentResponse)
	respEnv, err := PtrEnvironmentsEnvironmentToProto(resp.Env)
	if err != nil {
		return nil, err
	}
	return &pb.GetEnvironmentResponse{Env: respEnv}, nil
}

func _Encode_ListEnvironments_Response(ctx context.Context, response interface{}) (interface{}, error) {
	if response == nil {
		return nil, errors.New("nil ListEnvironmentsResponse")
	}
	resp := response.(*transport.ListEnvironmentsResponse)
	respEnvs, err := ListPtrEnvironmentsEnvironmentToProto(resp.Envs)
	if err != nil {
		return nil, err
	}
	return &pb.ListEnvironmentsResponse{Envs: respEnvs}, nil
}

func _Encode_GetCollection_Response(ctx context.Context, response interface{}) (interface{}, error) {
	if response == nil {
		return nil, errors.New("nil GetCollectionResponse")
	}
	resp := response.(*transport.GetCollectionResponse)
	respCollection, err := PtrCollectionsCollectionToProto(resp.Collection)
	if err != nil {
		return nil, err
	}
	return &pb.GetCollectionResponse{Collection: respCollection}, nil
}

func _Encode_ListCollections_Response(ctx context.Context, response interface{}) (interface{}, error) {
	if response == nil {
		return nil, errors.New("nil ListCollectionsResponse")
	}
	resp := response.(*transport.ListCollectionsResponse)
	respCollections, err := ListPtrCollectionsCollectionToProto(resp.Collections)
	if err != nil {
		return nil, err
	}
	return &pb.ListCollectionsResponse{Collections: respCollections}, nil
}

func _Encode_GetItem_Response(ctx context.Context, response interface{}) (interface{}, error) {
	if response == nil {
		return nil, errors.New("nil GetItemResponse")
	}
	resp := response.(*transport.GetItemResponse)
	respItem, err := PtrItemsItemToProto(resp.Item)
	if err != nil {
		return nil, err
	}
	return &pb.GetItemResponse{Item: respItem}, nil
}

func _Encode_FindItems_Response(ctx context.Context, response interface{}) (interface{}, error) {
	if response == nil {
		return nil, errors.New("nil FindItemsResponse")
	}
	resp := response.(*transport.FindItemsResponse)
	respItem, err := ListPtrItemsItemToProto(resp.Items)
	if err != nil {
		return nil, err
	}
	return &pb.FindItemsResponse{
		Items: respItem,
		Total: int32(resp.Total),
	}, nil
}

func _Decode_ListLocales_Request(ctx context.Context, request interface{}) (interface{}, error) {
	if request == nil {
		return nil, errors.New("nil ListLocalesRequest")
	}
	req := request.(*pb.ListLocalesRequest)
	return &transport.ListLocalesRequest{SpaceId: string(req.SpaceId)}, nil
}

func _Decode_GetEnvironment_Request(ctx context.Context, request interface{}) (interface{}, error) {
	if request == nil {
		return nil, errors.New("nil GetEnvironmentRequest")
	}
	req := request.(*pb.GetEnvironmentRequest)
	return &transport.GetEnvironmentRequest{
		EnvId:   string(req.EnvId),
		SpaceId: string(req.SpaceId),
	}, nil
}

func _Decode_ListEnvironments_Request(ctx context.Context, request interface{}) (interface{}, error) {
	if request == nil {
		return nil, errors.New("nil ListEnvironmentsRequest")
	}
	req := request.(*pb.ListEnvironmentsRequest)
	return &transport.ListEnvironmentsRequest{SpaceId: string(req.SpaceId)}, nil
}

func _Decode_GetCollection_Request(ctx context.Context, request interface{}) (interface{}, error) {
	if request == nil {
		return nil, errors.New("nil GetCollectionRequest")
	}
	req := request.(*pb.GetCollectionRequest)
	return &transport.GetCollectionRequest{
		CollectionId: string(req.CollectionId),
		EnvId:        string(req.EnvId),
		SpaceId:      string(req.SpaceId),
	}, nil
}

func _Decode_ListCollections_Request(ctx context.Context, request interface{}) (interface{}, error) {
	if request == nil {
		return nil, errors.New("nil ListCollectionsRequest")
	}
	req := request.(*pb.ListCollectionsRequest)
	return &transport.ListCollectionsRequest{
		EnvId:   string(req.EnvId),
		SpaceId: string(req.SpaceId),
	}, nil
}

func _Decode_GetItem_Request(ctx context.Context, request interface{}) (interface{}, error) {
	if request == nil {
		return nil, errors.New("nil GetItemRequest")
	}
	req := request.(*pb.GetItemRequest)
	reqOptions, err := ProtoToElPtrItemsGetPublishedOptions(req.Options)
	if err != nil {
		return nil, err
	}
	return &transport.GetItemRequest{
		CollectionId: string(req.CollectionId),
		EnvId:        string(req.EnvId),
		ItemId:       string(req.ItemId),
		SpaceId:      string(req.SpaceId),
		Options:      reqOptions,
	}, nil
}

func _Decode_FindItems_Request(ctx context.Context, request interface{}) (interface{}, error) {
	if request == nil {
		return nil, errors.New("nil FindItemsRequest")
	}
	req := request.(*pb.FindItemsRequest)
	reqFilter, err := ProtoToPtrItemsFilter(req.Filter)
	if err != nil {
		return nil, err
	}
	reqOptions, err := ProtoToElPtrItemsFindPublishedOptions(req.Options)
	if err != nil {
		return nil, err
	}
	return &transport.FindItemsRequest{
		CollectionId: string(req.CollectionId),
		EnvId:        string(req.EnvId),
		Filter:       reqFilter,
		Options:      reqOptions,
		SpaceId:      string(req.SpaceId),
	}, nil
}

func _Decode_ListLocales_Response(ctx context.Context, response interface{}) (interface{}, error) {
	if response == nil {
		return nil, errors.New("nil ListLocalesResponse")
	}
	resp := response.(*pb.ListLocalesResponse)
	respLocales, err := ProtoToListPtrLocalesLocale(resp.Locales)
	if err != nil {
		return nil, err
	}
	return &transport.ListLocalesResponse{Locales: respLocales}, nil
}

func _Decode_GetEnvironment_Response(ctx context.Context, response interface{}) (interface{}, error) {
	if response == nil {
		return nil, errors.New("nil GetEnvironmentResponse")
	}
	resp := response.(*pb.GetEnvironmentResponse)
	respEnv, err := ProtoToPtrEnvironmentsEnvironment(resp.Env)
	if err != nil {
		return nil, err
	}
	return &transport.GetEnvironmentResponse{Env: respEnv}, nil
}

func _Decode_ListEnvironments_Response(ctx context.Context, response interface{}) (interface{}, error) {
	if response == nil {
		return nil, errors.New("nil ListEnvironmentsResponse")
	}
	resp := response.(*pb.ListEnvironmentsResponse)
	respEnvs, err := ProtoToListPtrEnvironmentsEnvironment(resp.Envs)
	if err != nil {
		return nil, err
	}
	return &transport.ListEnvironmentsResponse{Envs: respEnvs}, nil
}

func _Decode_GetCollection_Response(ctx context.Context, response interface{}) (interface{}, error) {
	if response == nil {
		return nil, errors.New("nil GetCollectionResponse")
	}
	resp := response.(*pb.GetCollectionResponse)
	respCollection, err := ProtoToPtrCollectionsCollection(resp.Collection)
	if err != nil {
		return nil, err
	}
	return &transport.GetCollectionResponse{Collection: respCollection}, nil
}

func _Decode_ListCollections_Response(ctx context.Context, response interface{}) (interface{}, error) {
	if response == nil {
		return nil, errors.New("nil ListCollectionsResponse")
	}
	resp := response.(*pb.ListCollectionsResponse)
	respCollections, err := ProtoToListPtrCollectionsCollection(resp.Collections)
	if err != nil {
		return nil, err
	}
	return &transport.ListCollectionsResponse{Collections: respCollections}, nil
}

func _Decode_GetItem_Response(ctx context.Context, response interface{}) (interface{}, error) {
	if response == nil {
		return nil, errors.New("nil GetItemResponse")
	}
	resp := response.(*pb.GetItemResponse)
	respItem, err := ProtoToPtrItemsItem(resp.Item)
	if err != nil {
		return nil, err
	}
	return &transport.GetItemResponse{Item: respItem}, nil
}

func _Decode_FindItems_Response(ctx context.Context, response interface{}) (interface{}, error) {
	if response == nil {
		return nil, errors.New("nil FindItemsResponse")
	}
	resp := response.(*pb.FindItemsResponse)
	respItem, err := ProtoToListPtrItemsItem(resp.Items)
	if err != nil {
		return nil, err
	}
	return &transport.FindItemsResponse{
		Items: respItem,
		Total: int(resp.Total),
	}, nil
}

func _Encode_Aggregate_Request(ctx context.Context, request interface{}) (interface{}, error) {
	if request == nil {
		return nil, errors.New("nil AggregateRequest")
	}
	req := request.(*transport.AggregateRequest)
	reqFilter, err := PtrItemsFilterToProto(req.Filter)
	if err != nil {
		return nil, err
	}
	reqOptions, err := ElPtrItemsAggregateOptionsToProto(req.Options)
	if err != nil {
		return nil, err
	}
	return &pb.AggregateRequest{
		CollectionId: req.CollectionId,
		EnvId:        req.EnvId,
		Filter:       reqFilter,
		Options:      reqOptions,
		SpaceId:      req.SpaceId,
	}, nil
}

func _Encode_Aggregate_Response(ctx context.Context, response interface{}) (interface{}, error) {
	if response == nil {
		return nil, errors.New("nil AggregateResponse")
	}
	resp := response.(*transport.AggregateResponse)
	respResult, err := MapStringInterfaceToProto(resp.Result)
	if err != nil {
		return nil, err
	}
	return &pb.AggregateResponse{Result: respResult}, nil
}

func _Decode_Aggregate_Request(ctx context.Context, request interface{}) (interface{}, error) {
	if request == nil {
		return nil, errors.New("nil AggregateRequest")
	}
	req := request.(*pb.AggregateRequest)
	reqFilter, err := ProtoToPtrItemsFilter(req.Filter)
	if err != nil {
		return nil, err
	}
	reqOptions, err := ProtoToElPtrItemsAggregateOptions(req.Options)
	if err != nil {
		return nil, err
	}
	return &transport.AggregateRequest{
		CollectionId: string(req.CollectionId),
		EnvId:        string(req.EnvId),
		Filter:       reqFilter,
		Options:      reqOptions,
		SpaceId:      string(req.SpaceId),
	}, nil
}

func _Decode_Aggregate_Response(ctx context.Context, response interface{}) (interface{}, error) {
	if response == nil {
		return nil, errors.New("nil AggregateResponse")
	}
	resp := response.(*pb.AggregateResponse)
	respResult, err := ProtoToMapStringInterface(resp.Result)
	if err != nil {
		return nil, err
	}
	return &transport.AggregateResponse{Result: respResult}, nil
}