From cceed6f851b864aedb9abb2d482d3cb70c7bb45d Mon Sep 17 00:00:00 2001 From: filipriec Date: Sun, 23 Feb 2025 00:08:45 +0100 Subject: [PATCH] not working at all, make common from scrach once again please --- common/src/lib.rs | 18 +- common/src/proto/descriptor.bin | Bin 0 -> 10697 bytes common/src/proto/multieko2.adresar.rs | 789 ++++++++++++++++++ common/src/proto/multieko2.common.rs | 13 + common/src/proto/multieko2.table_structure.rs | 413 +++++++++ common/src/proto/multieko2.uctovnictvo.rs | 719 ++++++++++++++++ 6 files changed, 1947 insertions(+), 5 deletions(-) create mode 100644 common/src/proto/descriptor.bin create mode 100644 common/src/proto/multieko2.adresar.rs create mode 100644 common/src/proto/multieko2.common.rs create mode 100644 common/src/proto/multieko2.table_structure.rs create mode 100644 common/src/proto/multieko2.uctovnictvo.rs diff --git a/common/src/lib.rs b/common/src/lib.rs index ad2a4a0..6648ddb 100644 --- a/common/src/lib.rs +++ b/common/src/lib.rs @@ -1,7 +1,15 @@ -// common/src/lib.rs +// src/lib.rs pub mod proto { - include!("proto/multieko2.adresar.rs"); - include!("proto/multieko2.common.rs"); - include!("proto/multieko2.table_structure.rs"); - include!("proto/multieko2.uctovnictvo.rs"); + pub mod multieko2_adresar { + include!("proto/multieko2.adresar.rs"); + } + pub mod multieko2_common { + include!("proto/multieko2.common.rs"); + } + pub mod multieko2_table_structure { + include!("proto/multieko2.table_structure.rs"); + } + pub mod multieko2_uctovnictvo { + include!("proto/multieko2.uctovnictvo.rs"); + } } diff --git a/common/src/proto/descriptor.bin b/common/src/proto/descriptor.bin new file mode 100644 index 0000000000000000000000000000000000000000..3dc24d74ef020453e2de9fd66fb4a422b9f6d137 GIT binary patch literal 10697 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 gyL+2!RSV>I1_bguTy#btzr(d^1oAtXQ7Z`i2Ln { + inner: tonic::client::Grpc, + } + impl AdresarClient { + /// Attempt to create a new client by connecting to a given endpoint. + pub async fn connect(dst: D) -> Result + where + D: TryInto, + D::Error: Into, + { + let conn = tonic::transport::Endpoint::new(dst)?.connect().await?; + Ok(Self::new(conn)) + } + } + impl AdresarClient + where + T: tonic::client::GrpcService, + T::Error: Into, + T::ResponseBody: Body + std::marker::Send + 'static, + ::Error: Into + std::marker::Send, + { + pub fn new(inner: T) -> Self { + let inner = tonic::client::Grpc::new(inner); + Self { inner } + } + pub fn with_origin(inner: T, origin: Uri) -> Self { + let inner = tonic::client::Grpc::with_origin(inner, origin); + Self { inner } + } + pub fn with_interceptor( + inner: T, + interceptor: F, + ) -> AdresarClient> + where + F: tonic::service::Interceptor, + T::ResponseBody: Default, + T: tonic::codegen::Service< + http::Request, + Response = http::Response< + >::ResponseBody, + >, + >, + , + >>::Error: Into + std::marker::Send + std::marker::Sync, + { + AdresarClient::new(InterceptedService::new(inner, interceptor)) + } + /// Compress requests with the given encoding. + /// + /// This requires the server to support it otherwise it might respond with an + /// error. + #[must_use] + pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self { + self.inner = self.inner.send_compressed(encoding); + self + } + /// Enable decompressing responses. + #[must_use] + pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self { + self.inner = self.inner.accept_compressed(encoding); + self + } + /// Limits the maximum size of a decoded message. + /// + /// Default: `4MB` + #[must_use] + pub fn max_decoding_message_size(mut self, limit: usize) -> Self { + self.inner = self.inner.max_decoding_message_size(limit); + self + } + /// Limits the maximum size of an encoded message. + /// + /// Default: `usize::MAX` + #[must_use] + pub fn max_encoding_message_size(mut self, limit: usize) -> Self { + self.inner = self.inner.max_encoding_message_size(limit); + self + } + pub async fn post_adresar( + &mut self, + request: impl tonic::IntoRequest, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + > { + self.inner + .ready() + .await + .map_err(|e| { + tonic::Status::unknown( + format!("Service was not ready: {}", e.into()), + ) + })?; + let codec = tonic::codec::ProstCodec::default(); + let path = http::uri::PathAndQuery::from_static( + "/multieko2.adresar.Adresar/PostAdresar", + ); + let mut req = request.into_request(); + req.extensions_mut() + .insert(GrpcMethod::new("multieko2.adresar.Adresar", "PostAdresar")); + self.inner.unary(req, path, codec).await + } + pub async fn get_adresar( + &mut self, + request: impl tonic::IntoRequest, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + > { + self.inner + .ready() + .await + .map_err(|e| { + tonic::Status::unknown( + format!("Service was not ready: {}", e.into()), + ) + })?; + let codec = tonic::codec::ProstCodec::default(); + let path = http::uri::PathAndQuery::from_static( + "/multieko2.adresar.Adresar/GetAdresar", + ); + let mut req = request.into_request(); + req.extensions_mut() + .insert(GrpcMethod::new("multieko2.adresar.Adresar", "GetAdresar")); + self.inner.unary(req, path, codec).await + } + pub async fn put_adresar( + &mut self, + request: impl tonic::IntoRequest, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + > { + self.inner + .ready() + .await + .map_err(|e| { + tonic::Status::unknown( + format!("Service was not ready: {}", e.into()), + ) + })?; + let codec = tonic::codec::ProstCodec::default(); + let path = http::uri::PathAndQuery::from_static( + "/multieko2.adresar.Adresar/PutAdresar", + ); + let mut req = request.into_request(); + req.extensions_mut() + .insert(GrpcMethod::new("multieko2.adresar.Adresar", "PutAdresar")); + self.inner.unary(req, path, codec).await + } + pub async fn delete_adresar( + &mut self, + request: impl tonic::IntoRequest, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + > { + self.inner + .ready() + .await + .map_err(|e| { + tonic::Status::unknown( + format!("Service was not ready: {}", e.into()), + ) + })?; + let codec = tonic::codec::ProstCodec::default(); + let path = http::uri::PathAndQuery::from_static( + "/multieko2.adresar.Adresar/DeleteAdresar", + ); + let mut req = request.into_request(); + req.extensions_mut() + .insert(GrpcMethod::new("multieko2.adresar.Adresar", "DeleteAdresar")); + self.inner.unary(req, path, codec).await + } + pub async fn get_adresar_count( + &mut self, + request: impl tonic::IntoRequest, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + > { + self.inner + .ready() + .await + .map_err(|e| { + tonic::Status::unknown( + format!("Service was not ready: {}", e.into()), + ) + })?; + let codec = tonic::codec::ProstCodec::default(); + let path = http::uri::PathAndQuery::from_static( + "/multieko2.adresar.Adresar/GetAdresarCount", + ); + let mut req = request.into_request(); + req.extensions_mut() + .insert(GrpcMethod::new("multieko2.adresar.Adresar", "GetAdresarCount")); + self.inner.unary(req, path, codec).await + } + pub async fn get_adresar_by_position( + &mut self, + request: impl tonic::IntoRequest, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + > { + self.inner + .ready() + .await + .map_err(|e| { + tonic::Status::unknown( + format!("Service was not ready: {}", e.into()), + ) + })?; + let codec = tonic::codec::ProstCodec::default(); + let path = http::uri::PathAndQuery::from_static( + "/multieko2.adresar.Adresar/GetAdresarByPosition", + ); + let mut req = request.into_request(); + req.extensions_mut() + .insert( + GrpcMethod::new("multieko2.adresar.Adresar", "GetAdresarByPosition"), + ); + self.inner.unary(req, path, codec).await + } + } +} +/// Generated server implementations. +pub mod adresar_server { + #![allow( + unused_variables, + dead_code, + missing_docs, + clippy::wildcard_imports, + clippy::let_unit_value, + )] + use tonic::codegen::*; + /// Generated trait containing gRPC methods that should be implemented for use with AdresarServer. + #[async_trait] + pub trait Adresar: std::marker::Send + std::marker::Sync + 'static { + async fn post_adresar( + &self, + request: tonic::Request, + ) -> std::result::Result, tonic::Status>; + async fn get_adresar( + &self, + request: tonic::Request, + ) -> std::result::Result, tonic::Status>; + async fn put_adresar( + &self, + request: tonic::Request, + ) -> std::result::Result, tonic::Status>; + async fn delete_adresar( + &self, + request: tonic::Request, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + >; + async fn get_adresar_count( + &self, + request: tonic::Request, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + >; + async fn get_adresar_by_position( + &self, + request: tonic::Request, + ) -> std::result::Result, tonic::Status>; + } + #[derive(Debug)] + pub struct AdresarServer { + inner: Arc, + accept_compression_encodings: EnabledCompressionEncodings, + send_compression_encodings: EnabledCompressionEncodings, + max_decoding_message_size: Option, + max_encoding_message_size: Option, + } + impl AdresarServer { + pub fn new(inner: T) -> Self { + Self::from_arc(Arc::new(inner)) + } + pub fn from_arc(inner: Arc) -> Self { + Self { + inner, + accept_compression_encodings: Default::default(), + send_compression_encodings: Default::default(), + max_decoding_message_size: None, + max_encoding_message_size: None, + } + } + pub fn with_interceptor( + inner: T, + interceptor: F, + ) -> InterceptedService + where + F: tonic::service::Interceptor, + { + InterceptedService::new(Self::new(inner), interceptor) + } + /// Enable decompressing requests with the given encoding. + #[must_use] + pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self { + self.accept_compression_encodings.enable(encoding); + self + } + /// Compress responses with the given encoding, if the client supports it. + #[must_use] + pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self { + self.send_compression_encodings.enable(encoding); + self + } + /// Limits the maximum size of a decoded message. + /// + /// Default: `4MB` + #[must_use] + pub fn max_decoding_message_size(mut self, limit: usize) -> Self { + self.max_decoding_message_size = Some(limit); + self + } + /// Limits the maximum size of an encoded message. + /// + /// Default: `usize::MAX` + #[must_use] + pub fn max_encoding_message_size(mut self, limit: usize) -> Self { + self.max_encoding_message_size = Some(limit); + self + } + } + impl tonic::codegen::Service> for AdresarServer + where + T: Adresar, + B: Body + std::marker::Send + 'static, + B::Error: Into + std::marker::Send + 'static, + { + type Response = http::Response; + type Error = std::convert::Infallible; + type Future = BoxFuture; + fn poll_ready( + &mut self, + _cx: &mut Context<'_>, + ) -> Poll> { + Poll::Ready(Ok(())) + } + fn call(&mut self, req: http::Request) -> Self::Future { + match req.uri().path() { + "/multieko2.adresar.Adresar/PostAdresar" => { + #[allow(non_camel_case_types)] + struct PostAdresarSvc(pub Arc); + impl< + T: Adresar, + > tonic::server::UnaryService + for PostAdresarSvc { + type Response = super::AdresarResponse; + type Future = BoxFuture< + tonic::Response, + tonic::Status, + >; + fn call( + &mut self, + request: tonic::Request, + ) -> Self::Future { + let inner = Arc::clone(&self.0); + let fut = async move { + ::post_adresar(&inner, request).await + }; + Box::pin(fut) + } + } + let accept_compression_encodings = self.accept_compression_encodings; + let send_compression_encodings = self.send_compression_encodings; + let max_decoding_message_size = self.max_decoding_message_size; + let max_encoding_message_size = self.max_encoding_message_size; + let inner = self.inner.clone(); + let fut = async move { + let method = PostAdresarSvc(inner); + let codec = tonic::codec::ProstCodec::default(); + let mut grpc = tonic::server::Grpc::new(codec) + .apply_compression_config( + accept_compression_encodings, + send_compression_encodings, + ) + .apply_max_message_size_config( + max_decoding_message_size, + max_encoding_message_size, + ); + let res = grpc.unary(method, req).await; + Ok(res) + }; + Box::pin(fut) + } + "/multieko2.adresar.Adresar/GetAdresar" => { + #[allow(non_camel_case_types)] + struct GetAdresarSvc(pub Arc); + impl< + T: Adresar, + > tonic::server::UnaryService + for GetAdresarSvc { + type Response = super::AdresarResponse; + type Future = BoxFuture< + tonic::Response, + tonic::Status, + >; + fn call( + &mut self, + request: tonic::Request, + ) -> Self::Future { + let inner = Arc::clone(&self.0); + let fut = async move { + ::get_adresar(&inner, request).await + }; + Box::pin(fut) + } + } + let accept_compression_encodings = self.accept_compression_encodings; + let send_compression_encodings = self.send_compression_encodings; + let max_decoding_message_size = self.max_decoding_message_size; + let max_encoding_message_size = self.max_encoding_message_size; + let inner = self.inner.clone(); + let fut = async move { + let method = GetAdresarSvc(inner); + let codec = tonic::codec::ProstCodec::default(); + let mut grpc = tonic::server::Grpc::new(codec) + .apply_compression_config( + accept_compression_encodings, + send_compression_encodings, + ) + .apply_max_message_size_config( + max_decoding_message_size, + max_encoding_message_size, + ); + let res = grpc.unary(method, req).await; + Ok(res) + }; + Box::pin(fut) + } + "/multieko2.adresar.Adresar/PutAdresar" => { + #[allow(non_camel_case_types)] + struct PutAdresarSvc(pub Arc); + impl< + T: Adresar, + > tonic::server::UnaryService + for PutAdresarSvc { + type Response = super::AdresarResponse; + type Future = BoxFuture< + tonic::Response, + tonic::Status, + >; + fn call( + &mut self, + request: tonic::Request, + ) -> Self::Future { + let inner = Arc::clone(&self.0); + let fut = async move { + ::put_adresar(&inner, request).await + }; + Box::pin(fut) + } + } + let accept_compression_encodings = self.accept_compression_encodings; + let send_compression_encodings = self.send_compression_encodings; + let max_decoding_message_size = self.max_decoding_message_size; + let max_encoding_message_size = self.max_encoding_message_size; + let inner = self.inner.clone(); + let fut = async move { + let method = PutAdresarSvc(inner); + let codec = tonic::codec::ProstCodec::default(); + let mut grpc = tonic::server::Grpc::new(codec) + .apply_compression_config( + accept_compression_encodings, + send_compression_encodings, + ) + .apply_max_message_size_config( + max_decoding_message_size, + max_encoding_message_size, + ); + let res = grpc.unary(method, req).await; + Ok(res) + }; + Box::pin(fut) + } + "/multieko2.adresar.Adresar/DeleteAdresar" => { + #[allow(non_camel_case_types)] + struct DeleteAdresarSvc(pub Arc); + impl< + T: Adresar, + > tonic::server::UnaryService + for DeleteAdresarSvc { + type Response = super::DeleteAdresarResponse; + type Future = BoxFuture< + tonic::Response, + tonic::Status, + >; + fn call( + &mut self, + request: tonic::Request, + ) -> Self::Future { + let inner = Arc::clone(&self.0); + let fut = async move { + ::delete_adresar(&inner, request).await + }; + Box::pin(fut) + } + } + let accept_compression_encodings = self.accept_compression_encodings; + let send_compression_encodings = self.send_compression_encodings; + let max_decoding_message_size = self.max_decoding_message_size; + let max_encoding_message_size = self.max_encoding_message_size; + let inner = self.inner.clone(); + let fut = async move { + let method = DeleteAdresarSvc(inner); + let codec = tonic::codec::ProstCodec::default(); + let mut grpc = tonic::server::Grpc::new(codec) + .apply_compression_config( + accept_compression_encodings, + send_compression_encodings, + ) + .apply_max_message_size_config( + max_decoding_message_size, + max_encoding_message_size, + ); + let res = grpc.unary(method, req).await; + Ok(res) + }; + Box::pin(fut) + } + "/multieko2.adresar.Adresar/GetAdresarCount" => { + #[allow(non_camel_case_types)] + struct GetAdresarCountSvc(pub Arc); + impl< + T: Adresar, + > tonic::server::UnaryService + for GetAdresarCountSvc { + type Response = super::super::common::CountResponse; + type Future = BoxFuture< + tonic::Response, + tonic::Status, + >; + fn call( + &mut self, + request: tonic::Request, + ) -> Self::Future { + let inner = Arc::clone(&self.0); + let fut = async move { + ::get_adresar_count(&inner, request).await + }; + Box::pin(fut) + } + } + let accept_compression_encodings = self.accept_compression_encodings; + let send_compression_encodings = self.send_compression_encodings; + let max_decoding_message_size = self.max_decoding_message_size; + let max_encoding_message_size = self.max_encoding_message_size; + let inner = self.inner.clone(); + let fut = async move { + let method = GetAdresarCountSvc(inner); + let codec = tonic::codec::ProstCodec::default(); + let mut grpc = tonic::server::Grpc::new(codec) + .apply_compression_config( + accept_compression_encodings, + send_compression_encodings, + ) + .apply_max_message_size_config( + max_decoding_message_size, + max_encoding_message_size, + ); + let res = grpc.unary(method, req).await; + Ok(res) + }; + Box::pin(fut) + } + "/multieko2.adresar.Adresar/GetAdresarByPosition" => { + #[allow(non_camel_case_types)] + struct GetAdresarByPositionSvc(pub Arc); + impl< + T: Adresar, + > tonic::server::UnaryService + for GetAdresarByPositionSvc { + type Response = super::AdresarResponse; + type Future = BoxFuture< + tonic::Response, + tonic::Status, + >; + fn call( + &mut self, + request: tonic::Request< + super::super::common::PositionRequest, + >, + ) -> Self::Future { + let inner = Arc::clone(&self.0); + let fut = async move { + ::get_adresar_by_position(&inner, request) + .await + }; + Box::pin(fut) + } + } + let accept_compression_encodings = self.accept_compression_encodings; + let send_compression_encodings = self.send_compression_encodings; + let max_decoding_message_size = self.max_decoding_message_size; + let max_encoding_message_size = self.max_encoding_message_size; + let inner = self.inner.clone(); + let fut = async move { + let method = GetAdresarByPositionSvc(inner); + let codec = tonic::codec::ProstCodec::default(); + let mut grpc = tonic::server::Grpc::new(codec) + .apply_compression_config( + accept_compression_encodings, + send_compression_encodings, + ) + .apply_max_message_size_config( + max_decoding_message_size, + max_encoding_message_size, + ); + let res = grpc.unary(method, req).await; + Ok(res) + }; + Box::pin(fut) + } + _ => { + Box::pin(async move { + let mut response = http::Response::new(empty_body()); + let headers = response.headers_mut(); + headers + .insert( + tonic::Status::GRPC_STATUS, + (tonic::Code::Unimplemented as i32).into(), + ); + headers + .insert( + http::header::CONTENT_TYPE, + tonic::metadata::GRPC_CONTENT_TYPE, + ); + Ok(response) + }) + } + } + } + } + impl Clone for AdresarServer { + fn clone(&self) -> Self { + let inner = self.inner.clone(); + Self { + inner, + accept_compression_encodings: self.accept_compression_encodings, + send_compression_encodings: self.send_compression_encodings, + max_decoding_message_size: self.max_decoding_message_size, + max_encoding_message_size: self.max_encoding_message_size, + } + } + } + /// Generated gRPC service name + pub const SERVICE_NAME: &str = "multieko2.adresar.Adresar"; + impl tonic::server::NamedService for AdresarServer { + const NAME: &'static str = SERVICE_NAME; + } +} diff --git a/common/src/proto/multieko2.common.rs b/common/src/proto/multieko2.common.rs new file mode 100644 index 0000000..10aa25f --- /dev/null +++ b/common/src/proto/multieko2.common.rs @@ -0,0 +1,13 @@ +// This file is @generated by prost-build. +#[derive(Clone, Copy, PartialEq, ::prost::Message)] +pub struct Empty {} +#[derive(Clone, Copy, PartialEq, ::prost::Message)] +pub struct CountResponse { + #[prost(int64, tag = "1")] + pub count: i64, +} +#[derive(Clone, Copy, PartialEq, ::prost::Message)] +pub struct PositionRequest { + #[prost(int64, tag = "1")] + pub position: i64, +} diff --git a/common/src/proto/multieko2.table_structure.rs b/common/src/proto/multieko2.table_structure.rs new file mode 100644 index 0000000..01b3483 --- /dev/null +++ b/common/src/proto/multieko2.table_structure.rs @@ -0,0 +1,413 @@ +// This file is @generated by prost-build. +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct TableStructureResponse { + #[prost(message, repeated, tag = "1")] + pub columns: ::prost::alloc::vec::Vec, +} +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct TableColumn { + #[prost(string, tag = "1")] + pub name: ::prost::alloc::string::String, + #[prost(string, tag = "2")] + pub data_type: ::prost::alloc::string::String, + #[prost(bool, tag = "3")] + pub is_nullable: bool, + #[prost(bool, tag = "4")] + pub is_primary_key: bool, +} +/// Generated client implementations. +pub mod table_structure_service_client { + #![allow( + unused_variables, + dead_code, + missing_docs, + clippy::wildcard_imports, + clippy::let_unit_value, + )] + use tonic::codegen::*; + use tonic::codegen::http::Uri; + #[derive(Debug, Clone)] + pub struct TableStructureServiceClient { + inner: tonic::client::Grpc, + } + impl TableStructureServiceClient { + /// Attempt to create a new client by connecting to a given endpoint. + pub async fn connect(dst: D) -> Result + where + D: TryInto, + D::Error: Into, + { + let conn = tonic::transport::Endpoint::new(dst)?.connect().await?; + Ok(Self::new(conn)) + } + } + impl TableStructureServiceClient + where + T: tonic::client::GrpcService, + T::Error: Into, + T::ResponseBody: Body + std::marker::Send + 'static, + ::Error: Into + std::marker::Send, + { + pub fn new(inner: T) -> Self { + let inner = tonic::client::Grpc::new(inner); + Self { inner } + } + pub fn with_origin(inner: T, origin: Uri) -> Self { + let inner = tonic::client::Grpc::with_origin(inner, origin); + Self { inner } + } + pub fn with_interceptor( + inner: T, + interceptor: F, + ) -> TableStructureServiceClient> + where + F: tonic::service::Interceptor, + T::ResponseBody: Default, + T: tonic::codegen::Service< + http::Request, + Response = http::Response< + >::ResponseBody, + >, + >, + , + >>::Error: Into + std::marker::Send + std::marker::Sync, + { + TableStructureServiceClient::new(InterceptedService::new(inner, interceptor)) + } + /// Compress requests with the given encoding. + /// + /// This requires the server to support it otherwise it might respond with an + /// error. + #[must_use] + pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self { + self.inner = self.inner.send_compressed(encoding); + self + } + /// Enable decompressing responses. + #[must_use] + pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self { + self.inner = self.inner.accept_compressed(encoding); + self + } + /// Limits the maximum size of a decoded message. + /// + /// Default: `4MB` + #[must_use] + pub fn max_decoding_message_size(mut self, limit: usize) -> Self { + self.inner = self.inner.max_decoding_message_size(limit); + self + } + /// Limits the maximum size of an encoded message. + /// + /// Default: `usize::MAX` + #[must_use] + pub fn max_encoding_message_size(mut self, limit: usize) -> Self { + self.inner = self.inner.max_encoding_message_size(limit); + self + } + pub async fn get_adresar_table_structure( + &mut self, + request: impl tonic::IntoRequest, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + > { + self.inner + .ready() + .await + .map_err(|e| { + tonic::Status::unknown( + format!("Service was not ready: {}", e.into()), + ) + })?; + let codec = tonic::codec::ProstCodec::default(); + let path = http::uri::PathAndQuery::from_static( + "/multieko2.table_structure.TableStructureService/GetAdresarTableStructure", + ); + let mut req = request.into_request(); + req.extensions_mut() + .insert( + GrpcMethod::new( + "multieko2.table_structure.TableStructureService", + "GetAdresarTableStructure", + ), + ); + self.inner.unary(req, path, codec).await + } + pub async fn get_uctovnictvo_table_structure( + &mut self, + request: impl tonic::IntoRequest, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + > { + self.inner + .ready() + .await + .map_err(|e| { + tonic::Status::unknown( + format!("Service was not ready: {}", e.into()), + ) + })?; + let codec = tonic::codec::ProstCodec::default(); + let path = http::uri::PathAndQuery::from_static( + "/multieko2.table_structure.TableStructureService/GetUctovnictvoTableStructure", + ); + let mut req = request.into_request(); + req.extensions_mut() + .insert( + GrpcMethod::new( + "multieko2.table_structure.TableStructureService", + "GetUctovnictvoTableStructure", + ), + ); + self.inner.unary(req, path, codec).await + } + } +} +/// Generated server implementations. +pub mod table_structure_service_server { + #![allow( + unused_variables, + dead_code, + missing_docs, + clippy::wildcard_imports, + clippy::let_unit_value, + )] + use tonic::codegen::*; + /// Generated trait containing gRPC methods that should be implemented for use with TableStructureServiceServer. + #[async_trait] + pub trait TableStructureService: std::marker::Send + std::marker::Sync + 'static { + async fn get_adresar_table_structure( + &self, + request: tonic::Request, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + >; + async fn get_uctovnictvo_table_structure( + &self, + request: tonic::Request, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + >; + } + #[derive(Debug)] + pub struct TableStructureServiceServer { + inner: Arc, + accept_compression_encodings: EnabledCompressionEncodings, + send_compression_encodings: EnabledCompressionEncodings, + max_decoding_message_size: Option, + max_encoding_message_size: Option, + } + impl TableStructureServiceServer { + pub fn new(inner: T) -> Self { + Self::from_arc(Arc::new(inner)) + } + pub fn from_arc(inner: Arc) -> Self { + Self { + inner, + accept_compression_encodings: Default::default(), + send_compression_encodings: Default::default(), + max_decoding_message_size: None, + max_encoding_message_size: None, + } + } + pub fn with_interceptor( + inner: T, + interceptor: F, + ) -> InterceptedService + where + F: tonic::service::Interceptor, + { + InterceptedService::new(Self::new(inner), interceptor) + } + /// Enable decompressing requests with the given encoding. + #[must_use] + pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self { + self.accept_compression_encodings.enable(encoding); + self + } + /// Compress responses with the given encoding, if the client supports it. + #[must_use] + pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self { + self.send_compression_encodings.enable(encoding); + self + } + /// Limits the maximum size of a decoded message. + /// + /// Default: `4MB` + #[must_use] + pub fn max_decoding_message_size(mut self, limit: usize) -> Self { + self.max_decoding_message_size = Some(limit); + self + } + /// Limits the maximum size of an encoded message. + /// + /// Default: `usize::MAX` + #[must_use] + pub fn max_encoding_message_size(mut self, limit: usize) -> Self { + self.max_encoding_message_size = Some(limit); + self + } + } + impl tonic::codegen::Service> + for TableStructureServiceServer + where + T: TableStructureService, + B: Body + std::marker::Send + 'static, + B::Error: Into + std::marker::Send + 'static, + { + type Response = http::Response; + type Error = std::convert::Infallible; + type Future = BoxFuture; + fn poll_ready( + &mut self, + _cx: &mut Context<'_>, + ) -> Poll> { + Poll::Ready(Ok(())) + } + fn call(&mut self, req: http::Request) -> Self::Future { + match req.uri().path() { + "/multieko2.table_structure.TableStructureService/GetAdresarTableStructure" => { + #[allow(non_camel_case_types)] + struct GetAdresarTableStructureSvc( + pub Arc, + ); + impl< + T: TableStructureService, + > tonic::server::UnaryService + for GetAdresarTableStructureSvc { + type Response = super::TableStructureResponse; + type Future = BoxFuture< + tonic::Response, + tonic::Status, + >; + fn call( + &mut self, + request: tonic::Request, + ) -> Self::Future { + let inner = Arc::clone(&self.0); + let fut = async move { + ::get_adresar_table_structure( + &inner, + request, + ) + .await + }; + Box::pin(fut) + } + } + let accept_compression_encodings = self.accept_compression_encodings; + let send_compression_encodings = self.send_compression_encodings; + let max_decoding_message_size = self.max_decoding_message_size; + let max_encoding_message_size = self.max_encoding_message_size; + let inner = self.inner.clone(); + let fut = async move { + let method = GetAdresarTableStructureSvc(inner); + let codec = tonic::codec::ProstCodec::default(); + let mut grpc = tonic::server::Grpc::new(codec) + .apply_compression_config( + accept_compression_encodings, + send_compression_encodings, + ) + .apply_max_message_size_config( + max_decoding_message_size, + max_encoding_message_size, + ); + let res = grpc.unary(method, req).await; + Ok(res) + }; + Box::pin(fut) + } + "/multieko2.table_structure.TableStructureService/GetUctovnictvoTableStructure" => { + #[allow(non_camel_case_types)] + struct GetUctovnictvoTableStructureSvc( + pub Arc, + ); + impl< + T: TableStructureService, + > tonic::server::UnaryService + for GetUctovnictvoTableStructureSvc { + type Response = super::TableStructureResponse; + type Future = BoxFuture< + tonic::Response, + tonic::Status, + >; + fn call( + &mut self, + request: tonic::Request, + ) -> Self::Future { + let inner = Arc::clone(&self.0); + let fut = async move { + ::get_uctovnictvo_table_structure( + &inner, + request, + ) + .await + }; + Box::pin(fut) + } + } + let accept_compression_encodings = self.accept_compression_encodings; + let send_compression_encodings = self.send_compression_encodings; + let max_decoding_message_size = self.max_decoding_message_size; + let max_encoding_message_size = self.max_encoding_message_size; + let inner = self.inner.clone(); + let fut = async move { + let method = GetUctovnictvoTableStructureSvc(inner); + let codec = tonic::codec::ProstCodec::default(); + let mut grpc = tonic::server::Grpc::new(codec) + .apply_compression_config( + accept_compression_encodings, + send_compression_encodings, + ) + .apply_max_message_size_config( + max_decoding_message_size, + max_encoding_message_size, + ); + let res = grpc.unary(method, req).await; + Ok(res) + }; + Box::pin(fut) + } + _ => { + Box::pin(async move { + let mut response = http::Response::new(empty_body()); + let headers = response.headers_mut(); + headers + .insert( + tonic::Status::GRPC_STATUS, + (tonic::Code::Unimplemented as i32).into(), + ); + headers + .insert( + http::header::CONTENT_TYPE, + tonic::metadata::GRPC_CONTENT_TYPE, + ); + Ok(response) + }) + } + } + } + } + impl Clone for TableStructureServiceServer { + fn clone(&self) -> Self { + let inner = self.inner.clone(); + Self { + inner, + accept_compression_encodings: self.accept_compression_encodings, + send_compression_encodings: self.send_compression_encodings, + max_decoding_message_size: self.max_decoding_message_size, + max_encoding_message_size: self.max_encoding_message_size, + } + } + } + /// Generated gRPC service name + pub const SERVICE_NAME: &str = "multieko2.table_structure.TableStructureService"; + impl tonic::server::NamedService for TableStructureServiceServer { + const NAME: &'static str = SERVICE_NAME; + } +} diff --git a/common/src/proto/multieko2.uctovnictvo.rs b/common/src/proto/multieko2.uctovnictvo.rs new file mode 100644 index 0000000..0c6798a --- /dev/null +++ b/common/src/proto/multieko2.uctovnictvo.rs @@ -0,0 +1,719 @@ +// This file is @generated by prost-build. +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct PostUctovnictvoRequest { + #[prost(int64, tag = "1")] + pub adresar_id: i64, + #[prost(string, tag = "2")] + pub c_dokladu: ::prost::alloc::string::String, + /// Use string for simplicity, or use google.protobuf.Timestamp for better date handling + #[prost(string, tag = "3")] + pub datum: ::prost::alloc::string::String, + #[prost(string, tag = "4")] + pub c_faktury: ::prost::alloc::string::String, + #[prost(string, tag = "5")] + pub obsah: ::prost::alloc::string::String, + #[prost(string, tag = "6")] + pub stredisko: ::prost::alloc::string::String, + #[prost(string, tag = "7")] + pub c_uctu: ::prost::alloc::string::String, + #[prost(string, tag = "8")] + pub md: ::prost::alloc::string::String, + #[prost(string, tag = "9")] + pub identif: ::prost::alloc::string::String, + #[prost(string, tag = "10")] + pub poznanka: ::prost::alloc::string::String, + #[prost(string, tag = "11")] + pub firma: ::prost::alloc::string::String, +} +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct UctovnictvoResponse { + #[prost(int64, tag = "1")] + pub id: i64, + #[prost(int64, tag = "2")] + pub adresar_id: i64, + #[prost(string, tag = "3")] + pub c_dokladu: ::prost::alloc::string::String, + #[prost(string, tag = "4")] + pub datum: ::prost::alloc::string::String, + #[prost(string, tag = "5")] + pub c_faktury: ::prost::alloc::string::String, + #[prost(string, tag = "6")] + pub obsah: ::prost::alloc::string::String, + #[prost(string, tag = "7")] + pub stredisko: ::prost::alloc::string::String, + #[prost(string, tag = "8")] + pub c_uctu: ::prost::alloc::string::String, + #[prost(string, tag = "9")] + pub md: ::prost::alloc::string::String, + #[prost(string, tag = "10")] + pub identif: ::prost::alloc::string::String, + #[prost(string, tag = "11")] + pub poznanka: ::prost::alloc::string::String, + #[prost(string, tag = "12")] + pub firma: ::prost::alloc::string::String, +} +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct PutUctovnictvoRequest { + #[prost(int64, tag = "1")] + pub id: i64, + #[prost(int64, tag = "2")] + pub adresar_id: i64, + #[prost(string, tag = "3")] + pub c_dokladu: ::prost::alloc::string::String, + #[prost(string, tag = "4")] + pub datum: ::prost::alloc::string::String, + #[prost(string, tag = "5")] + pub c_faktury: ::prost::alloc::string::String, + #[prost(string, tag = "6")] + pub obsah: ::prost::alloc::string::String, + #[prost(string, tag = "7")] + pub stredisko: ::prost::alloc::string::String, + #[prost(string, tag = "8")] + pub c_uctu: ::prost::alloc::string::String, + #[prost(string, tag = "9")] + pub md: ::prost::alloc::string::String, + #[prost(string, tag = "10")] + pub identif: ::prost::alloc::string::String, + #[prost(string, tag = "11")] + pub poznanka: ::prost::alloc::string::String, + #[prost(string, tag = "12")] + pub firma: ::prost::alloc::string::String, +} +#[derive(Clone, Copy, PartialEq, ::prost::Message)] +pub struct GetUctovnictvoRequest { + #[prost(int64, tag = "1")] + pub id: i64, +} +/// Generated client implementations. +pub mod uctovnictvo_client { + #![allow( + unused_variables, + dead_code, + missing_docs, + clippy::wildcard_imports, + clippy::let_unit_value, + )] + use tonic::codegen::*; + use tonic::codegen::http::Uri; + #[derive(Debug, Clone)] + pub struct UctovnictvoClient { + inner: tonic::client::Grpc, + } + impl UctovnictvoClient { + /// Attempt to create a new client by connecting to a given endpoint. + pub async fn connect(dst: D) -> Result + where + D: TryInto, + D::Error: Into, + { + let conn = tonic::transport::Endpoint::new(dst)?.connect().await?; + Ok(Self::new(conn)) + } + } + impl UctovnictvoClient + where + T: tonic::client::GrpcService, + T::Error: Into, + T::ResponseBody: Body + std::marker::Send + 'static, + ::Error: Into + std::marker::Send, + { + pub fn new(inner: T) -> Self { + let inner = tonic::client::Grpc::new(inner); + Self { inner } + } + pub fn with_origin(inner: T, origin: Uri) -> Self { + let inner = tonic::client::Grpc::with_origin(inner, origin); + Self { inner } + } + pub fn with_interceptor( + inner: T, + interceptor: F, + ) -> UctovnictvoClient> + where + F: tonic::service::Interceptor, + T::ResponseBody: Default, + T: tonic::codegen::Service< + http::Request, + Response = http::Response< + >::ResponseBody, + >, + >, + , + >>::Error: Into + std::marker::Send + std::marker::Sync, + { + UctovnictvoClient::new(InterceptedService::new(inner, interceptor)) + } + /// Compress requests with the given encoding. + /// + /// This requires the server to support it otherwise it might respond with an + /// error. + #[must_use] + pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self { + self.inner = self.inner.send_compressed(encoding); + self + } + /// Enable decompressing responses. + #[must_use] + pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self { + self.inner = self.inner.accept_compressed(encoding); + self + } + /// Limits the maximum size of a decoded message. + /// + /// Default: `4MB` + #[must_use] + pub fn max_decoding_message_size(mut self, limit: usize) -> Self { + self.inner = self.inner.max_decoding_message_size(limit); + self + } + /// Limits the maximum size of an encoded message. + /// + /// Default: `usize::MAX` + #[must_use] + pub fn max_encoding_message_size(mut self, limit: usize) -> Self { + self.inner = self.inner.max_encoding_message_size(limit); + self + } + pub async fn post_uctovnictvo( + &mut self, + request: impl tonic::IntoRequest, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + > { + self.inner + .ready() + .await + .map_err(|e| { + tonic::Status::unknown( + format!("Service was not ready: {}", e.into()), + ) + })?; + let codec = tonic::codec::ProstCodec::default(); + let path = http::uri::PathAndQuery::from_static( + "/multieko2.uctovnictvo.Uctovnictvo/PostUctovnictvo", + ); + let mut req = request.into_request(); + req.extensions_mut() + .insert( + GrpcMethod::new( + "multieko2.uctovnictvo.Uctovnictvo", + "PostUctovnictvo", + ), + ); + self.inner.unary(req, path, codec).await + } + pub async fn get_uctovnictvo( + &mut self, + request: impl tonic::IntoRequest, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + > { + self.inner + .ready() + .await + .map_err(|e| { + tonic::Status::unknown( + format!("Service was not ready: {}", e.into()), + ) + })?; + let codec = tonic::codec::ProstCodec::default(); + let path = http::uri::PathAndQuery::from_static( + "/multieko2.uctovnictvo.Uctovnictvo/GetUctovnictvo", + ); + let mut req = request.into_request(); + req.extensions_mut() + .insert( + GrpcMethod::new( + "multieko2.uctovnictvo.Uctovnictvo", + "GetUctovnictvo", + ), + ); + self.inner.unary(req, path, codec).await + } + pub async fn get_uctovnictvo_count( + &mut self, + request: impl tonic::IntoRequest, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + > { + self.inner + .ready() + .await + .map_err(|e| { + tonic::Status::unknown( + format!("Service was not ready: {}", e.into()), + ) + })?; + let codec = tonic::codec::ProstCodec::default(); + let path = http::uri::PathAndQuery::from_static( + "/multieko2.uctovnictvo.Uctovnictvo/GetUctovnictvoCount", + ); + let mut req = request.into_request(); + req.extensions_mut() + .insert( + GrpcMethod::new( + "multieko2.uctovnictvo.Uctovnictvo", + "GetUctovnictvoCount", + ), + ); + self.inner.unary(req, path, codec).await + } + pub async fn get_uctovnictvo_by_position( + &mut self, + request: impl tonic::IntoRequest, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + > { + self.inner + .ready() + .await + .map_err(|e| { + tonic::Status::unknown( + format!("Service was not ready: {}", e.into()), + ) + })?; + let codec = tonic::codec::ProstCodec::default(); + let path = http::uri::PathAndQuery::from_static( + "/multieko2.uctovnictvo.Uctovnictvo/GetUctovnictvoByPosition", + ); + let mut req = request.into_request(); + req.extensions_mut() + .insert( + GrpcMethod::new( + "multieko2.uctovnictvo.Uctovnictvo", + "GetUctovnictvoByPosition", + ), + ); + self.inner.unary(req, path, codec).await + } + pub async fn put_uctovnictvo( + &mut self, + request: impl tonic::IntoRequest, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + > { + self.inner + .ready() + .await + .map_err(|e| { + tonic::Status::unknown( + format!("Service was not ready: {}", e.into()), + ) + })?; + let codec = tonic::codec::ProstCodec::default(); + let path = http::uri::PathAndQuery::from_static( + "/multieko2.uctovnictvo.Uctovnictvo/PutUctovnictvo", + ); + let mut req = request.into_request(); + req.extensions_mut() + .insert( + GrpcMethod::new( + "multieko2.uctovnictvo.Uctovnictvo", + "PutUctovnictvo", + ), + ); + self.inner.unary(req, path, codec).await + } + } +} +/// Generated server implementations. +pub mod uctovnictvo_server { + #![allow( + unused_variables, + dead_code, + missing_docs, + clippy::wildcard_imports, + clippy::let_unit_value, + )] + use tonic::codegen::*; + /// Generated trait containing gRPC methods that should be implemented for use with UctovnictvoServer. + #[async_trait] + pub trait Uctovnictvo: std::marker::Send + std::marker::Sync + 'static { + async fn post_uctovnictvo( + &self, + request: tonic::Request, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + >; + async fn get_uctovnictvo( + &self, + request: tonic::Request, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + >; + async fn get_uctovnictvo_count( + &self, + request: tonic::Request, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + >; + async fn get_uctovnictvo_by_position( + &self, + request: tonic::Request, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + >; + async fn put_uctovnictvo( + &self, + request: tonic::Request, + ) -> std::result::Result< + tonic::Response, + tonic::Status, + >; + } + #[derive(Debug)] + pub struct UctovnictvoServer { + inner: Arc, + accept_compression_encodings: EnabledCompressionEncodings, + send_compression_encodings: EnabledCompressionEncodings, + max_decoding_message_size: Option, + max_encoding_message_size: Option, + } + impl UctovnictvoServer { + pub fn new(inner: T) -> Self { + Self::from_arc(Arc::new(inner)) + } + pub fn from_arc(inner: Arc) -> Self { + Self { + inner, + accept_compression_encodings: Default::default(), + send_compression_encodings: Default::default(), + max_decoding_message_size: None, + max_encoding_message_size: None, + } + } + pub fn with_interceptor( + inner: T, + interceptor: F, + ) -> InterceptedService + where + F: tonic::service::Interceptor, + { + InterceptedService::new(Self::new(inner), interceptor) + } + /// Enable decompressing requests with the given encoding. + #[must_use] + pub fn accept_compressed(mut self, encoding: CompressionEncoding) -> Self { + self.accept_compression_encodings.enable(encoding); + self + } + /// Compress responses with the given encoding, if the client supports it. + #[must_use] + pub fn send_compressed(mut self, encoding: CompressionEncoding) -> Self { + self.send_compression_encodings.enable(encoding); + self + } + /// Limits the maximum size of a decoded message. + /// + /// Default: `4MB` + #[must_use] + pub fn max_decoding_message_size(mut self, limit: usize) -> Self { + self.max_decoding_message_size = Some(limit); + self + } + /// Limits the maximum size of an encoded message. + /// + /// Default: `usize::MAX` + #[must_use] + pub fn max_encoding_message_size(mut self, limit: usize) -> Self { + self.max_encoding_message_size = Some(limit); + self + } + } + impl tonic::codegen::Service> for UctovnictvoServer + where + T: Uctovnictvo, + B: Body + std::marker::Send + 'static, + B::Error: Into + std::marker::Send + 'static, + { + type Response = http::Response; + type Error = std::convert::Infallible; + type Future = BoxFuture; + fn poll_ready( + &mut self, + _cx: &mut Context<'_>, + ) -> Poll> { + Poll::Ready(Ok(())) + } + fn call(&mut self, req: http::Request) -> Self::Future { + match req.uri().path() { + "/multieko2.uctovnictvo.Uctovnictvo/PostUctovnictvo" => { + #[allow(non_camel_case_types)] + struct PostUctovnictvoSvc(pub Arc); + impl< + T: Uctovnictvo, + > tonic::server::UnaryService + for PostUctovnictvoSvc { + type Response = super::UctovnictvoResponse; + type Future = BoxFuture< + tonic::Response, + tonic::Status, + >; + fn call( + &mut self, + request: tonic::Request, + ) -> Self::Future { + let inner = Arc::clone(&self.0); + let fut = async move { + ::post_uctovnictvo(&inner, request).await + }; + Box::pin(fut) + } + } + let accept_compression_encodings = self.accept_compression_encodings; + let send_compression_encodings = self.send_compression_encodings; + let max_decoding_message_size = self.max_decoding_message_size; + let max_encoding_message_size = self.max_encoding_message_size; + let inner = self.inner.clone(); + let fut = async move { + let method = PostUctovnictvoSvc(inner); + let codec = tonic::codec::ProstCodec::default(); + let mut grpc = tonic::server::Grpc::new(codec) + .apply_compression_config( + accept_compression_encodings, + send_compression_encodings, + ) + .apply_max_message_size_config( + max_decoding_message_size, + max_encoding_message_size, + ); + let res = grpc.unary(method, req).await; + Ok(res) + }; + Box::pin(fut) + } + "/multieko2.uctovnictvo.Uctovnictvo/GetUctovnictvo" => { + #[allow(non_camel_case_types)] + struct GetUctovnictvoSvc(pub Arc); + impl< + T: Uctovnictvo, + > tonic::server::UnaryService + for GetUctovnictvoSvc { + type Response = super::UctovnictvoResponse; + type Future = BoxFuture< + tonic::Response, + tonic::Status, + >; + fn call( + &mut self, + request: tonic::Request, + ) -> Self::Future { + let inner = Arc::clone(&self.0); + let fut = async move { + ::get_uctovnictvo(&inner, request).await + }; + Box::pin(fut) + } + } + let accept_compression_encodings = self.accept_compression_encodings; + let send_compression_encodings = self.send_compression_encodings; + let max_decoding_message_size = self.max_decoding_message_size; + let max_encoding_message_size = self.max_encoding_message_size; + let inner = self.inner.clone(); + let fut = async move { + let method = GetUctovnictvoSvc(inner); + let codec = tonic::codec::ProstCodec::default(); + let mut grpc = tonic::server::Grpc::new(codec) + .apply_compression_config( + accept_compression_encodings, + send_compression_encodings, + ) + .apply_max_message_size_config( + max_decoding_message_size, + max_encoding_message_size, + ); + let res = grpc.unary(method, req).await; + Ok(res) + }; + Box::pin(fut) + } + "/multieko2.uctovnictvo.Uctovnictvo/GetUctovnictvoCount" => { + #[allow(non_camel_case_types)] + struct GetUctovnictvoCountSvc(pub Arc); + impl< + T: Uctovnictvo, + > tonic::server::UnaryService + for GetUctovnictvoCountSvc { + type Response = super::super::common::CountResponse; + type Future = BoxFuture< + tonic::Response, + tonic::Status, + >; + fn call( + &mut self, + request: tonic::Request, + ) -> Self::Future { + let inner = Arc::clone(&self.0); + let fut = async move { + ::get_uctovnictvo_count(&inner, request) + .await + }; + Box::pin(fut) + } + } + let accept_compression_encodings = self.accept_compression_encodings; + let send_compression_encodings = self.send_compression_encodings; + let max_decoding_message_size = self.max_decoding_message_size; + let max_encoding_message_size = self.max_encoding_message_size; + let inner = self.inner.clone(); + let fut = async move { + let method = GetUctovnictvoCountSvc(inner); + let codec = tonic::codec::ProstCodec::default(); + let mut grpc = tonic::server::Grpc::new(codec) + .apply_compression_config( + accept_compression_encodings, + send_compression_encodings, + ) + .apply_max_message_size_config( + max_decoding_message_size, + max_encoding_message_size, + ); + let res = grpc.unary(method, req).await; + Ok(res) + }; + Box::pin(fut) + } + "/multieko2.uctovnictvo.Uctovnictvo/GetUctovnictvoByPosition" => { + #[allow(non_camel_case_types)] + struct GetUctovnictvoByPositionSvc(pub Arc); + impl< + T: Uctovnictvo, + > tonic::server::UnaryService + for GetUctovnictvoByPositionSvc { + type Response = super::UctovnictvoResponse; + type Future = BoxFuture< + tonic::Response, + tonic::Status, + >; + fn call( + &mut self, + request: tonic::Request< + super::super::common::PositionRequest, + >, + ) -> Self::Future { + let inner = Arc::clone(&self.0); + let fut = async move { + ::get_uctovnictvo_by_position( + &inner, + request, + ) + .await + }; + Box::pin(fut) + } + } + let accept_compression_encodings = self.accept_compression_encodings; + let send_compression_encodings = self.send_compression_encodings; + let max_decoding_message_size = self.max_decoding_message_size; + let max_encoding_message_size = self.max_encoding_message_size; + let inner = self.inner.clone(); + let fut = async move { + let method = GetUctovnictvoByPositionSvc(inner); + let codec = tonic::codec::ProstCodec::default(); + let mut grpc = tonic::server::Grpc::new(codec) + .apply_compression_config( + accept_compression_encodings, + send_compression_encodings, + ) + .apply_max_message_size_config( + max_decoding_message_size, + max_encoding_message_size, + ); + let res = grpc.unary(method, req).await; + Ok(res) + }; + Box::pin(fut) + } + "/multieko2.uctovnictvo.Uctovnictvo/PutUctovnictvo" => { + #[allow(non_camel_case_types)] + struct PutUctovnictvoSvc(pub Arc); + impl< + T: Uctovnictvo, + > tonic::server::UnaryService + for PutUctovnictvoSvc { + type Response = super::UctovnictvoResponse; + type Future = BoxFuture< + tonic::Response, + tonic::Status, + >; + fn call( + &mut self, + request: tonic::Request, + ) -> Self::Future { + let inner = Arc::clone(&self.0); + let fut = async move { + ::put_uctovnictvo(&inner, request).await + }; + Box::pin(fut) + } + } + let accept_compression_encodings = self.accept_compression_encodings; + let send_compression_encodings = self.send_compression_encodings; + let max_decoding_message_size = self.max_decoding_message_size; + let max_encoding_message_size = self.max_encoding_message_size; + let inner = self.inner.clone(); + let fut = async move { + let method = PutUctovnictvoSvc(inner); + let codec = tonic::codec::ProstCodec::default(); + let mut grpc = tonic::server::Grpc::new(codec) + .apply_compression_config( + accept_compression_encodings, + send_compression_encodings, + ) + .apply_max_message_size_config( + max_decoding_message_size, + max_encoding_message_size, + ); + let res = grpc.unary(method, req).await; + Ok(res) + }; + Box::pin(fut) + } + _ => { + Box::pin(async move { + let mut response = http::Response::new(empty_body()); + let headers = response.headers_mut(); + headers + .insert( + tonic::Status::GRPC_STATUS, + (tonic::Code::Unimplemented as i32).into(), + ); + headers + .insert( + http::header::CONTENT_TYPE, + tonic::metadata::GRPC_CONTENT_TYPE, + ); + Ok(response) + }) + } + } + } + } + impl Clone for UctovnictvoServer { + fn clone(&self) -> Self { + let inner = self.inner.clone(); + Self { + inner, + accept_compression_encodings: self.accept_compression_encodings, + send_compression_encodings: self.send_compression_encodings, + max_decoding_message_size: self.max_decoding_message_size, + max_encoding_message_size: self.max_encoding_message_size, + } + } + } + /// Generated gRPC service name + pub const SERVICE_NAME: &str = "multieko2.uctovnictvo.Uctovnictvo"; + impl tonic::server::NamedService for UctovnictvoServer { + const NAME: &'static str = SERVICE_NAME; + } +}