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 0000000..3dc24d7 Binary files /dev/null and b/common/src/proto/descriptor.bin differ diff --git a/common/src/proto/multieko2.adresar.rs b/common/src/proto/multieko2.adresar.rs new file mode 100644 index 0000000..6731a5e --- /dev/null +++ b/common/src/proto/multieko2.adresar.rs @@ -0,0 +1,789 @@ +// This file is @generated by prost-build. +#[derive(Clone, Copy, PartialEq, ::prost::Message)] +pub struct GetAdresarRequest { + #[prost(int64, tag = "1")] + pub id: i64, +} +#[derive(Clone, Copy, PartialEq, ::prost::Message)] +pub struct DeleteAdresarRequest { + #[prost(int64, tag = "1")] + pub id: i64, +} +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct PostAdresarRequest { + #[prost(string, tag = "1")] + pub firma: ::prost::alloc::string::String, + #[prost(string, tag = "2")] + pub kz: ::prost::alloc::string::String, + #[prost(string, tag = "3")] + pub drc: ::prost::alloc::string::String, + #[prost(string, tag = "4")] + pub ulica: ::prost::alloc::string::String, + #[prost(string, tag = "5")] + pub psc: ::prost::alloc::string::String, + #[prost(string, tag = "6")] + pub mesto: ::prost::alloc::string::String, + #[prost(string, tag = "7")] + pub stat: ::prost::alloc::string::String, + #[prost(string, tag = "8")] + pub banka: ::prost::alloc::string::String, + #[prost(string, tag = "9")] + pub ucet: ::prost::alloc::string::String, + #[prost(string, tag = "10")] + pub skladm: ::prost::alloc::string::String, + #[prost(string, tag = "11")] + pub ico: ::prost::alloc::string::String, + #[prost(string, tag = "12")] + pub kontakt: ::prost::alloc::string::String, + #[prost(string, tag = "13")] + pub telefon: ::prost::alloc::string::String, + #[prost(string, tag = "14")] + pub skladu: ::prost::alloc::string::String, + #[prost(string, tag = "15")] + pub fax: ::prost::alloc::string::String, +} +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct AdresarResponse { + #[prost(int64, tag = "1")] + pub id: i64, + #[prost(string, tag = "2")] + pub firma: ::prost::alloc::string::String, + #[prost(string, tag = "3")] + pub kz: ::prost::alloc::string::String, + #[prost(string, tag = "4")] + pub drc: ::prost::alloc::string::String, + #[prost(string, tag = "5")] + pub ulica: ::prost::alloc::string::String, + #[prost(string, tag = "6")] + pub psc: ::prost::alloc::string::String, + #[prost(string, tag = "7")] + pub mesto: ::prost::alloc::string::String, + #[prost(string, tag = "8")] + pub stat: ::prost::alloc::string::String, + #[prost(string, tag = "9")] + pub banka: ::prost::alloc::string::String, + #[prost(string, tag = "10")] + pub ucet: ::prost::alloc::string::String, + #[prost(string, tag = "11")] + pub skladm: ::prost::alloc::string::String, + #[prost(string, tag = "12")] + pub ico: ::prost::alloc::string::String, + #[prost(string, tag = "13")] + pub kontakt: ::prost::alloc::string::String, + #[prost(string, tag = "14")] + pub telefon: ::prost::alloc::string::String, + #[prost(string, tag = "15")] + pub skladu: ::prost::alloc::string::String, + #[prost(string, tag = "16")] + pub fax: ::prost::alloc::string::String, +} +#[derive(Clone, PartialEq, ::prost::Message)] +pub struct PutAdresarRequest { + #[prost(int64, tag = "1")] + pub id: i64, + #[prost(string, tag = "2")] + pub firma: ::prost::alloc::string::String, + #[prost(string, tag = "3")] + pub kz: ::prost::alloc::string::String, + #[prost(string, tag = "4")] + pub drc: ::prost::alloc::string::String, + #[prost(string, tag = "5")] + pub ulica: ::prost::alloc::string::String, + #[prost(string, tag = "6")] + pub psc: ::prost::alloc::string::String, + #[prost(string, tag = "7")] + pub mesto: ::prost::alloc::string::String, + #[prost(string, tag = "8")] + pub stat: ::prost::alloc::string::String, + #[prost(string, tag = "9")] + pub banka: ::prost::alloc::string::String, + #[prost(string, tag = "10")] + pub ucet: ::prost::alloc::string::String, + #[prost(string, tag = "11")] + pub skladm: ::prost::alloc::string::String, + #[prost(string, tag = "12")] + pub ico: ::prost::alloc::string::String, + #[prost(string, tag = "13")] + pub kontakt: ::prost::alloc::string::String, + #[prost(string, tag = "14")] + pub telefon: ::prost::alloc::string::String, + #[prost(string, tag = "15")] + pub skladu: ::prost::alloc::string::String, + #[prost(string, tag = "16")] + pub fax: ::prost::alloc::string::String, +} +#[derive(Clone, Copy, PartialEq, ::prost::Message)] +pub struct DeleteAdresarResponse { + #[prost(bool, tag = "1")] + pub success: bool, +} +/// Generated client implementations. +pub mod adresar_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 AdresarClient { + 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; + } +}