kompAC

Cargo.toml

@@ -4,14 +4,14 @@ resolver = "2"
 
 [workspace.package]
 # TODO: idk how to do the name, fix later
-# name = "Multieko2"
+# name = "KompAC"
 version = "0.3.13"
 edition = "2021"
 license = "GPL-3.0-or-later"
 authors = ["Filip Priečinský <filippriec@gmail.com>"]
 description = "Poriadny uctovnicky software."
 readme = "README.md"
-repository = "https://gitlab.com/filipriec/multieko2"
+repository = "https://gitlab.com/filipriec/KompAC"
 categories = ["command-line-interface"]
 
 # [workspace.metadata]

client/src/components/admin/admin_panel.rs

@@ -4,7 +4,7 @@ use crate::config::colors::themes::Theme;
 use crate::state::pages::auth::AuthState;
 use crate::state::app::state::AppState;
 use crate::state::pages::admin::AdminState;
-use common::proto::multieko2::table_definition::ProfileTreeResponse;
+use common::proto::KompAC::table_definition::ProfileTreeResponse;
 use ratatui::{
     layout::{Constraint, Direction, Layout, Rect},
     style::Style,

client/src/components/common/autocomplete.rs

@@ -2,7 +2,7 @@
 
 use crate::config::colors::themes::Theme;
 use crate::state::pages::form::FormState;
-use common::proto::multieko2::search::search_response::Hit;
+use common::proto::KompAC::search::search_response::Hit;
 use ratatui::{
     layout::Rect,
     style::{Color, Modifier, Style},

client/src/components/common/status_line.rs

@@ -47,7 +47,7 @@ pub fn render_status_line(
     }
 
     // --- The normal status line rendering logic (unchanged) ---
-    let program_info = format!("multieko2 v{}", env!("CARGO_PKG_VERSION"));
+    let program_info = format!("KompAC v{}", env!("CARGO_PKG_VERSION"));
     let mode_text = if is_edit_mode { "[EDIT]" } else { "[READ-ONLY]" };
 
     let home_dir = dirs::home_dir()

client/src/components/handlers/sidebar.rs

@@ -6,7 +6,7 @@ use ratatui::{
     Frame,
 };
 use crate::config::colors::themes::Theme;
-use common::proto::multieko2::table_definition::{ProfileTreeResponse};
+use common::proto::KompAC::table_definition::{ProfileTreeResponse};
 use ratatui::text::{Span, Line};
 use crate::components::utils::text::truncate_string;
 

client/src/components/intro/intro.rs

@@ -32,7 +32,7 @@ pub fn render_intro(f: &mut Frame, intro_state: &IntroState, area: Rect, theme:
 
     // Title
     let title = Line::from(vec![
-        Span::styled("multieko2", Style::default().fg(theme.highlight)),
+        Span::styled("KompAC", Style::default().fg(theme.highlight)),
         Span::styled(" v", Style::default().fg(theme.fg)),
         Span::styled(env!("CARGO_PKG_VERSION"), Style::default().fg(theme.secondary)),
     ]);

client/src/config/storage/storage.rs

@@ -9,7 +9,7 @@ use tracing::{error, info};
 #[cfg(unix)]
 use std::os::unix::fs::PermissionsExt;
 
-pub const APP_NAME: &str = "multieko2_client";
+pub const APP_NAME: &str = "KompAC_client";
 pub const TOKEN_FILE_NAME: &str = "auth.token";
 
 #[derive(Serialize, Deserialize, Debug, Clone)]

client/src/modes/canvas/edit.rs

@@ -13,7 +13,7 @@ use crate::state::pages::{
     form::FormState,
 };
 use anyhow::Result;
-use common::proto::multieko2::search::search_response::Hit;
+use common::proto::KompAC::search::search_response::Hit;
 use crossterm::event::{KeyCode, KeyEvent};
 use tokio::sync::mpsc;
 use tracing::{debug, info};

client/src/modes/general/command_navigation.rs

@@ -2,7 +2,7 @@
 use crate::config::binds::config::Config;
 use crate::modes::handlers::event::EventOutcome;
 use anyhow::Result;
-use common::proto::multieko2::table_definition::ProfileTreeResponse;
+use common::proto::KompAC::table_definition::ProfileTreeResponse;
 use crossterm::event::{KeyCode, KeyEvent};
 use std::collections::{HashMap, HashSet};
 

client/src/modes/handlers/event.rs

@@ -42,7 +42,7 @@ use crate::tui::{
 use crate::ui::handlers::context::UiContext;
 use crate::ui::handlers::rat_state::UiStateHandler;
 use anyhow::Result;
-use common::proto::multieko2::search::search_response::Hit;
+use common::proto::KompAC::search::search_response::Hit;
 use crossterm::cursor::SetCursorStyle;
 use crossterm::event::{Event, KeyCode, KeyEvent};
 use tokio::sync::mpsc;

client/src/services/auth.rs

@@ -1,6 +1,6 @@
 // src/services/auth.rs
 use tonic::transport::Channel;
-use common::proto::multieko2::auth::{
+use common::proto::KompAC::auth::{
     auth_service_client::AuthServiceClient,
     LoginRequest, LoginResponse,
     RegisterRequest, AuthResponse,

client/src/services/grpc_client.rs

@@ -1,17 +1,17 @@
 // src/services/grpc_client.rs
 
-use common::proto::multieko2::common::Empty;
+use common::proto::KompAC::common::Empty;
-use common::proto::multieko2::table_structure::table_structure_service_client::TableStructureServiceClient;
+use common::proto::KompAC::table_structure::table_structure_service_client::TableStructureServiceClient;
-use common::proto::multieko2::table_structure::{GetTableStructureRequest, TableStructureResponse};
+use common::proto::KompAC::table_structure::{GetTableStructureRequest, TableStructureResponse};
-use common::proto::multieko2::table_definition::{
+use common::proto::KompAC::table_definition::{
     table_definition_client::TableDefinitionClient,
     PostTableDefinitionRequest, ProfileTreeResponse, TableDefinitionResponse,
 };
-use common::proto::multieko2::table_script::{
+use common::proto::KompAC::table_script::{
     table_script_client::TableScriptClient,
     PostTableScriptRequest, TableScriptResponse,
 };
-use common::proto::multieko2::tables_data::{
+use common::proto::KompAC::tables_data::{
     tables_data_client::TablesDataClient,
     GetTableDataByPositionRequest,
     GetTableDataRequest,          // ADD THIS
@@ -22,7 +22,7 @@ use common::proto::multieko2::tables_data::{
     PostTableDataRequest, PostTableDataResponse, PutTableDataRequest,
     PutTableDataResponse,
 };
-use common::proto::multieko2::search::{
+use common::proto::KompAC::search::{
     searcher_client::SearcherClient, SearchRequest, SearchResponse,
 };
 use anyhow::{Context, Result};

client/src/services/ui_service.rs

@@ -98,7 +98,7 @@ impl UiService {
     pub async fn initialize_add_logic_table_data(
         grpc_client: &mut GrpcClient,
         add_logic_state: &mut AddLogicState,
-        profile_tree: &common::proto::multieko2::table_definition::ProfileTreeResponse,
+        profile_tree: &common::proto::KompAC::table_definition::ProfileTreeResponse,
     ) -> Result<String> {
         let profile_name_clone_opt = Some(add_logic_state.profile_name.clone());
         let table_name_opt_clone = add_logic_state.selected_table_name.clone();

client/src/state/app/search.rs

@@ -1,6 +1,6 @@
 // src/state/app/search.rs
 
-use common::proto::multieko2::search::search_response::Hit;
+use common::proto::KompAC::search::search_response::Hit;
 
 /// Holds the complete state for the search palette.
 pub struct SearchState {

client/src/state/app/state.rs

@@ -1,9 +1,9 @@
 // src/state/app/state.rs
 
 use anyhow::Result;
-use common::proto::multieko2::table_definition::ProfileTreeResponse;
+use common::proto::KompAC::table_definition::ProfileTreeResponse;
 // NEW: Import the types we need for the cache
-use common::proto::multieko2::table_structure::TableStructureResponse;
+use common::proto::KompAC::table_structure::TableStructureResponse;
 use crate::modes::handlers::mode_manager::AppMode;
 use crate::state::app::search::SearchState;
 use crate::ui::handlers::context::DialogPurpose;

client/src/state/pages/canvas_state.rs

@@ -1,6 +1,6 @@
 // src/state/pages/canvas_state.rs
 
-use common::proto::multieko2::search::search_response::Hit;
+use common::proto::KompAC::search::search_response::Hit;
 
 pub trait CanvasState {
     // --- Existing methods (unchanged) ---

client/src/state/pages/form.rs

@@ -3,7 +3,7 @@
 use crate::config::colors::themes::Theme;
 use crate::state::app::highlight::HighlightState;
 use crate::state::pages::canvas_state::CanvasState;
-use common::proto::multieko2::search::search_response::Hit;
+use common::proto::KompAC::search::search_response::Hit;
 use ratatui::layout::Rect;
 use ratatui::Frame;
 use std::collections::HashMap;

client/src/tui/functions/common/add_table.rs

@@ -4,7 +4,7 @@ use crate::state::pages::add_table::{
 };
 use crate::services::GrpcClient;
 use anyhow::{anyhow, Result};
-use common::proto::multieko2::table_definition::{
+use common::proto::KompAC::table_definition::{
     PostTableDefinitionRequest,
     ColumnDefinition as ProtoColumnDefinition,
     TableLink as ProtoTableLink,

client/src/tui/functions/common/login.rs

@@ -8,7 +8,7 @@ use crate::state::app::buffer::{AppView, BufferState};
 use crate::config::storage::storage::{StoredAuthData, save_auth_data};
 use crate::state::pages::canvas_state::CanvasState;
 use crate::ui::handlers::context::DialogPurpose;
-use common::proto::multieko2::auth::LoginResponse;
+use common::proto::KompAC::auth::LoginResponse;
 use anyhow::{Context, Result};
 use tokio::spawn;
 use tokio::sync::mpsc;

client/src/tui/functions/common/register.rs

@@ -8,7 +8,7 @@ use crate::state::{
 };
 use crate::ui::handlers::context::DialogPurpose;
 use crate::state::app::buffer::{AppView, BufferState};
-use common::proto::multieko2::auth::AuthResponse;
+use common::proto::KompAC::auth::AuthResponse;
 use anyhow::Context;
 use tokio::spawn;
 use tokio::sync::mpsc;

client/src/utils/data_converter.rs

@@ -1,6 +1,6 @@
 // src/utils/data_converter.rs
 
-use common::proto::multieko2::table_structure::TableStructureResponse;
+use common::proto::KompAC::table_structure::TableStructureResponse;
 use prost_types::{value::Kind, NullValue, Value};
 use std::collections::HashMap;
 

common/proto/adresar.proto

@@ -1,6 +1,6 @@
 // proto/adresar.proto
 syntax = "proto3";
-package multieko2.adresar;
+package KompAC.adresar;
 
 import "common.proto";
 // import "table_structure.proto";

common/proto/auth.proto

@@ -1,6 +1,6 @@
 // proto/auth.proto
 syntax = "proto3";
-package multieko2.auth;
+package KompAC.auth;
 
 import "common.proto";
 

common/proto/common.proto

@@ -1,6 +1,6 @@
 // proto/common.proto
 syntax = "proto3";
-package multieko2.common;
+package KompAC.common;
 
 message Empty {}
 message CountResponse { int64 count = 1; }

common/proto/search.proto

@@ -1,6 +1,6 @@
 // In common/proto/search.proto
 syntax = "proto3";
-package multieko2.search;
+package KompAC.search;
 
 service Searcher {
     rpc SearchTable(SearchRequest) returns (SearchResponse);

common/proto/table_definition.proto

@@ -1,12 +1,12 @@
 // common/proto/table_definition.proto
 syntax = "proto3";
-package multieko2.table_definition;
+package KompAC.table_definition;
 
 import "common.proto";
 
 service TableDefinition {
     rpc PostTableDefinition (PostTableDefinitionRequest) returns (TableDefinitionResponse);
-    rpc GetProfileTree (multieko2.common.Empty) returns (ProfileTreeResponse);
+    rpc GetProfileTree (KompAC.common.Empty) returns (ProfileTreeResponse);
     rpc DeleteTable (DeleteTableRequest) returns (DeleteTableResponse);
 }
 

common/proto/table_script.proto

@@ -1,5 +1,5 @@
 syntax = "proto3";
-package multieko2.table_script;
+package KompAC.table_script;
 
 service TableScript {
     rpc PostTableScript(PostTableScriptRequest) returns (TableScriptResponse);

common/proto/table_structure.proto

@@ -1,6 +1,6 @@
 // proto/table_structure.proto
 syntax = "proto3";
-package multieko2.table_structure;
+package KompAC.table_structure;
 
 import "common.proto";
 

common/proto/tables_data.proto

@@ -1,6 +1,6 @@
 // common/proto/tables_data.proto
 syntax = "proto3";
-package multieko2.tables_data;
+package KompAC.tables_data;
 
 import "common.proto";
 import "google/protobuf/struct.proto";
@@ -10,7 +10,7 @@ service TablesData {
   rpc PutTableData (PutTableDataRequest) returns (PutTableDataResponse);
   rpc DeleteTableData (DeleteTableDataRequest) returns (DeleteTableDataResponse);
   rpc GetTableData(GetTableDataRequest) returns (GetTableDataResponse);
-  rpc GetTableDataCount(GetTableDataCountRequest) returns (multieko2.common.CountResponse);
+  rpc GetTableDataCount(GetTableDataCountRequest) returns (KompAC.common.CountResponse);
   rpc GetTableDataByPosition(GetTableDataByPositionRequest) returns (GetTableDataResponse);
 }
 

common/proto/uctovnictvo.proto

@@ -1,6 +1,6 @@
 // proto/uctovnictvo.proto
 syntax = "proto3";
-package multieko2.uctovnictvo;
+package KompAC.uctovnictvo;
 
 import "common.proto";
 

common/src/lib.rs

@@ -3,33 +3,33 @@
 pub mod search;
 
 pub mod proto {
-    pub mod multieko2 {
+    pub mod KompAC {
         pub mod adresar {
-            include!("proto/multieko2.adresar.rs");
+            include!("proto/komp_ac.adresar.rs");
         }
         pub mod auth {
-            include!("proto/multieko2.auth.rs");
+            include!("proto/komp_ac.auth.rs");
         }
         pub mod common {
-            include!("proto/multieko2.common.rs");
+            include!("proto/komp_ac.common.rs");
         }
         pub mod table_structure {
-            include!("proto/multieko2.table_structure.rs");
+            include!("proto/komp_ac.table_structure.rs");
         }
         pub mod uctovnictvo {
-            include!("proto/multieko2.uctovnictvo.rs");
+            include!("proto/komp_ac.uctovnictvo.rs");
         }
         pub mod table_definition {
-            include!("proto/multieko2.table_definition.rs");
+            include!("proto/komp_ac.table_definition.rs");
         }
         pub mod tables_data {
-            include!("proto/multieko2.tables_data.rs");
+            include!("proto/komp_ac.tables_data.rs");
         }
         pub mod table_script {
-            include!("proto/multieko2.table_script.rs");
+            include!("proto/komp_ac.table_script.rs");
         }
         pub mod search {
-            include!("proto/multieko2.search.rs");
+            include!("proto/komp_ac.search.rs");
         }
         pub const FILE_DESCRIPTOR_SET: &[u8] =
             include_bytes!("proto/descriptor.bin");

common/src/proto/komp_ac.adresar.rs

@@ -0,0 +1,791 @@
+// 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<T> {
+        inner: tonic::client::Grpc<T>,
+    }
+    impl AdresarClient<tonic::transport::Channel> {
+        /// Attempt to create a new client by connecting to a given endpoint.
+        pub async fn connect<D>(dst: D) -> Result<Self, tonic::transport::Error>
+        where
+            D: TryInto<tonic::transport::Endpoint>,
+            D::Error: Into<StdError>,
+        {
+            let conn = tonic::transport::Endpoint::new(dst)?.connect().await?;
+            Ok(Self::new(conn))
+        }
+    }
+    impl<T> AdresarClient<T>
+    where
+        T: tonic::client::GrpcService<tonic::body::Body>,
+        T::Error: Into<StdError>,
+        T::ResponseBody: Body<Data = Bytes> + std::marker::Send + 'static,
+        <T::ResponseBody as Body>::Error: Into<StdError> + 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<F>(
+            inner: T,
+            interceptor: F,
+        ) -> AdresarClient<InterceptedService<T, F>>
+        where
+            F: tonic::service::Interceptor,
+            T::ResponseBody: Default,
+            T: tonic::codegen::Service<
+                http::Request<tonic::body::Body>,
+                Response = http::Response<
+                    <T as tonic::client::GrpcService<tonic::body::Body>>::ResponseBody,
+                >,
+            >,
+            <T as tonic::codegen::Service<
+                http::Request<tonic::body::Body>,
+            >>::Error: Into<StdError> + 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<super::PostAdresarRequest>,
+        ) -> std::result::Result<
+            tonic::Response<super::AdresarResponse>,
+            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(
+                "/KompAC.adresar.Adresar/PostAdresar",
+            );
+            let mut req = request.into_request();
+            req.extensions_mut()
+                .insert(GrpcMethod::new("KompAC.adresar.Adresar", "PostAdresar"));
+            self.inner.unary(req, path, codec).await
+        }
+        pub async fn get_adresar(
+            &mut self,
+            request: impl tonic::IntoRequest<super::GetAdresarRequest>,
+        ) -> std::result::Result<
+            tonic::Response<super::AdresarResponse>,
+            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(
+                "/KompAC.adresar.Adresar/GetAdresar",
+            );
+            let mut req = request.into_request();
+            req.extensions_mut()
+                .insert(GrpcMethod::new("KompAC.adresar.Adresar", "GetAdresar"));
+            self.inner.unary(req, path, codec).await
+        }
+        pub async fn put_adresar(
+            &mut self,
+            request: impl tonic::IntoRequest<super::PutAdresarRequest>,
+        ) -> std::result::Result<
+            tonic::Response<super::AdresarResponse>,
+            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(
+                "/KompAC.adresar.Adresar/PutAdresar",
+            );
+            let mut req = request.into_request();
+            req.extensions_mut()
+                .insert(GrpcMethod::new("KompAC.adresar.Adresar", "PutAdresar"));
+            self.inner.unary(req, path, codec).await
+        }
+        pub async fn delete_adresar(
+            &mut self,
+            request: impl tonic::IntoRequest<super::DeleteAdresarRequest>,
+        ) -> std::result::Result<
+            tonic::Response<super::DeleteAdresarResponse>,
+            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(
+                "/KompAC.adresar.Adresar/DeleteAdresar",
+            );
+            let mut req = request.into_request();
+            req.extensions_mut()
+                .insert(GrpcMethod::new("KompAC.adresar.Adresar", "DeleteAdresar"));
+            self.inner.unary(req, path, codec).await
+        }
+        pub async fn get_adresar_count(
+            &mut self,
+            request: impl tonic::IntoRequest<super::super::common::Empty>,
+        ) -> std::result::Result<
+            tonic::Response<super::super::common::CountResponse>,
+            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(
+                "/KompAC.adresar.Adresar/GetAdresarCount",
+            );
+            let mut req = request.into_request();
+            req.extensions_mut()
+                .insert(GrpcMethod::new("KompAC.adresar.Adresar", "GetAdresarCount"));
+            self.inner.unary(req, path, codec).await
+        }
+        pub async fn get_adresar_by_position(
+            &mut self,
+            request: impl tonic::IntoRequest<super::super::common::PositionRequest>,
+        ) -> std::result::Result<
+            tonic::Response<super::AdresarResponse>,
+            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(
+                "/KompAC.adresar.Adresar/GetAdresarByPosition",
+            );
+            let mut req = request.into_request();
+            req.extensions_mut()
+                .insert(
+                    GrpcMethod::new("KompAC.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<super::PostAdresarRequest>,
+        ) -> std::result::Result<tonic::Response<super::AdresarResponse>, tonic::Status>;
+        async fn get_adresar(
+            &self,
+            request: tonic::Request<super::GetAdresarRequest>,
+        ) -> std::result::Result<tonic::Response<super::AdresarResponse>, tonic::Status>;
+        async fn put_adresar(
+            &self,
+            request: tonic::Request<super::PutAdresarRequest>,
+        ) -> std::result::Result<tonic::Response<super::AdresarResponse>, tonic::Status>;
+        async fn delete_adresar(
+            &self,
+            request: tonic::Request<super::DeleteAdresarRequest>,
+        ) -> std::result::Result<
+            tonic::Response<super::DeleteAdresarResponse>,
+            tonic::Status,
+        >;
+        async fn get_adresar_count(
+            &self,
+            request: tonic::Request<super::super::common::Empty>,
+        ) -> std::result::Result<
+            tonic::Response<super::super::common::CountResponse>,
+            tonic::Status,
+        >;
+        async fn get_adresar_by_position(
+            &self,
+            request: tonic::Request<super::super::common::PositionRequest>,
+        ) -> std::result::Result<tonic::Response<super::AdresarResponse>, tonic::Status>;
+    }
+    #[derive(Debug)]
+    pub struct AdresarServer<T> {
+        inner: Arc<T>,
+        accept_compression_encodings: EnabledCompressionEncodings,
+        send_compression_encodings: EnabledCompressionEncodings,
+        max_decoding_message_size: Option<usize>,
+        max_encoding_message_size: Option<usize>,
+    }
+    impl<T> AdresarServer<T> {
+        pub fn new(inner: T) -> Self {
+            Self::from_arc(Arc::new(inner))
+        }
+        pub fn from_arc(inner: Arc<T>) -> 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<F>(
+            inner: T,
+            interceptor: F,
+        ) -> InterceptedService<Self, F>
+        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<T, B> tonic::codegen::Service<http::Request<B>> for AdresarServer<T>
+    where
+        T: Adresar,
+        B: Body + std::marker::Send + 'static,
+        B::Error: Into<StdError> + std::marker::Send + 'static,
+    {
+        type Response = http::Response<tonic::body::Body>;
+        type Error = std::convert::Infallible;
+        type Future = BoxFuture<Self::Response, Self::Error>;
+        fn poll_ready(
+            &mut self,
+            _cx: &mut Context<'_>,
+        ) -> Poll<std::result::Result<(), Self::Error>> {
+            Poll::Ready(Ok(()))
+        }
+        fn call(&mut self, req: http::Request<B>) -> Self::Future {
+            match req.uri().path() {
+                "/KompAC.adresar.Adresar/PostAdresar" => {
+                    #[allow(non_camel_case_types)]
+                    struct PostAdresarSvc<T: Adresar>(pub Arc<T>);
+                    impl<
+                        T: Adresar,
+                    > tonic::server::UnaryService<super::PostAdresarRequest>
+                    for PostAdresarSvc<T> {
+                        type Response = super::AdresarResponse;
+                        type Future = BoxFuture<
+                            tonic::Response<Self::Response>,
+                            tonic::Status,
+                        >;
+                        fn call(
+                            &mut self,
+                            request: tonic::Request<super::PostAdresarRequest>,
+                        ) -> Self::Future {
+                            let inner = Arc::clone(&self.0);
+                            let fut = async move {
+                                <T as Adresar>::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)
+                }
+                "/KompAC.adresar.Adresar/GetAdresar" => {
+                    #[allow(non_camel_case_types)]
+                    struct GetAdresarSvc<T: Adresar>(pub Arc<T>);
+                    impl<
+                        T: Adresar,
+                    > tonic::server::UnaryService<super::GetAdresarRequest>
+                    for GetAdresarSvc<T> {
+                        type Response = super::AdresarResponse;
+                        type Future = BoxFuture<
+                            tonic::Response<Self::Response>,
+                            tonic::Status,
+                        >;
+                        fn call(
+                            &mut self,
+                            request: tonic::Request<super::GetAdresarRequest>,
+                        ) -> Self::Future {
+                            let inner = Arc::clone(&self.0);
+                            let fut = async move {
+                                <T as Adresar>::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)
+                }
+                "/KompAC.adresar.Adresar/PutAdresar" => {
+                    #[allow(non_camel_case_types)]
+                    struct PutAdresarSvc<T: Adresar>(pub Arc<T>);
+                    impl<
+                        T: Adresar,
+                    > tonic::server::UnaryService<super::PutAdresarRequest>
+                    for PutAdresarSvc<T> {
+                        type Response = super::AdresarResponse;
+                        type Future = BoxFuture<
+                            tonic::Response<Self::Response>,
+                            tonic::Status,
+                        >;
+                        fn call(
+                            &mut self,
+                            request: tonic::Request<super::PutAdresarRequest>,
+                        ) -> Self::Future {
+                            let inner = Arc::clone(&self.0);
+                            let fut = async move {
+                                <T as Adresar>::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)
+                }
+                "/KompAC.adresar.Adresar/DeleteAdresar" => {
+                    #[allow(non_camel_case_types)]
+                    struct DeleteAdresarSvc<T: Adresar>(pub Arc<T>);
+                    impl<
+                        T: Adresar,
+                    > tonic::server::UnaryService<super::DeleteAdresarRequest>
+                    for DeleteAdresarSvc<T> {
+                        type Response = super::DeleteAdresarResponse;
+                        type Future = BoxFuture<
+                            tonic::Response<Self::Response>,
+                            tonic::Status,
+                        >;
+                        fn call(
+                            &mut self,
+                            request: tonic::Request<super::DeleteAdresarRequest>,
+                        ) -> Self::Future {
+                            let inner = Arc::clone(&self.0);
+                            let fut = async move {
+                                <T as Adresar>::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)
+                }
+                "/KompAC.adresar.Adresar/GetAdresarCount" => {
+                    #[allow(non_camel_case_types)]
+                    struct GetAdresarCountSvc<T: Adresar>(pub Arc<T>);
+                    impl<
+                        T: Adresar,
+                    > tonic::server::UnaryService<super::super::common::Empty>
+                    for GetAdresarCountSvc<T> {
+                        type Response = super::super::common::CountResponse;
+                        type Future = BoxFuture<
+                            tonic::Response<Self::Response>,
+                            tonic::Status,
+                        >;
+                        fn call(
+                            &mut self,
+                            request: tonic::Request<super::super::common::Empty>,
+                        ) -> Self::Future {
+                            let inner = Arc::clone(&self.0);
+                            let fut = async move {
+                                <T as Adresar>::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)
+                }
+                "/KompAC.adresar.Adresar/GetAdresarByPosition" => {
+                    #[allow(non_camel_case_types)]
+                    struct GetAdresarByPositionSvc<T: Adresar>(pub Arc<T>);
+                    impl<
+                        T: Adresar,
+                    > tonic::server::UnaryService<super::super::common::PositionRequest>
+                    for GetAdresarByPositionSvc<T> {
+                        type Response = super::AdresarResponse;
+                        type Future = BoxFuture<
+                            tonic::Response<Self::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 {
+                                <T as Adresar>::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(
+                            tonic::body::Body::default(),
+                        );
+                        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<T> Clone for AdresarServer<T> {
+        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 = "KompAC.adresar.Adresar";
+    impl<T> tonic::server::NamedService for AdresarServer<T> {
+        const NAME: &'static str = SERVICE_NAME;
+    }
+}

common/src/proto/komp_ac.auth.rs

@@ -0,0 +1,418 @@
+// This file is @generated by prost-build.
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct RegisterRequest {
+    #[prost(string, tag = "1")]
+    pub username: ::prost::alloc::string::String,
+    #[prost(string, tag = "2")]
+    pub email: ::prost::alloc::string::String,
+    #[prost(string, tag = "3")]
+    pub password: ::prost::alloc::string::String,
+    #[prost(string, tag = "4")]
+    pub password_confirmation: ::prost::alloc::string::String,
+    #[prost(string, tag = "5")]
+    pub role: ::prost::alloc::string::String,
+}
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct AuthResponse {
+    /// UUID in string format
+    #[prost(string, tag = "1")]
+    pub id: ::prost::alloc::string::String,
+    /// Registered username
+    #[prost(string, tag = "2")]
+    pub username: ::prost::alloc::string::String,
+    /// Registered email (if provided)
+    #[prost(string, tag = "3")]
+    pub email: ::prost::alloc::string::String,
+    /// Default role: 'accountant'
+    #[prost(string, tag = "4")]
+    pub role: ::prost::alloc::string::String,
+}
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct LoginRequest {
+    /// Can be username or email
+    #[prost(string, tag = "1")]
+    pub identifier: ::prost::alloc::string::String,
+    #[prost(string, tag = "2")]
+    pub password: ::prost::alloc::string::String,
+}
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct LoginResponse {
+    /// JWT token
+    #[prost(string, tag = "1")]
+    pub access_token: ::prost::alloc::string::String,
+    /// Usually "Bearer"
+    #[prost(string, tag = "2")]
+    pub token_type: ::prost::alloc::string::String,
+    /// Expiration in seconds (86400 for 24 hours)
+    #[prost(int32, tag = "3")]
+    pub expires_in: i32,
+    /// User's UUID in string format
+    #[prost(string, tag = "4")]
+    pub user_id: ::prost::alloc::string::String,
+    /// User's role
+    #[prost(string, tag = "5")]
+    pub role: ::prost::alloc::string::String,
+    #[prost(string, tag = "6")]
+    pub username: ::prost::alloc::string::String,
+}
+/// Generated client implementations.
+pub mod auth_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 AuthServiceClient<T> {
+        inner: tonic::client::Grpc<T>,
+    }
+    impl AuthServiceClient<tonic::transport::Channel> {
+        /// Attempt to create a new client by connecting to a given endpoint.
+        pub async fn connect<D>(dst: D) -> Result<Self, tonic::transport::Error>
+        where
+            D: TryInto<tonic::transport::Endpoint>,
+            D::Error: Into<StdError>,
+        {
+            let conn = tonic::transport::Endpoint::new(dst)?.connect().await?;
+            Ok(Self::new(conn))
+        }
+    }
+    impl<T> AuthServiceClient<T>
+    where
+        T: tonic::client::GrpcService<tonic::body::Body>,
+        T::Error: Into<StdError>,
+        T::ResponseBody: Body<Data = Bytes> + std::marker::Send + 'static,
+        <T::ResponseBody as Body>::Error: Into<StdError> + 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<F>(
+            inner: T,
+            interceptor: F,
+        ) -> AuthServiceClient<InterceptedService<T, F>>
+        where
+            F: tonic::service::Interceptor,
+            T::ResponseBody: Default,
+            T: tonic::codegen::Service<
+                http::Request<tonic::body::Body>,
+                Response = http::Response<
+                    <T as tonic::client::GrpcService<tonic::body::Body>>::ResponseBody,
+                >,
+            >,
+            <T as tonic::codegen::Service<
+                http::Request<tonic::body::Body>,
+            >>::Error: Into<StdError> + std::marker::Send + std::marker::Sync,
+        {
+            AuthServiceClient::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 register(
+            &mut self,
+            request: impl tonic::IntoRequest<super::RegisterRequest>,
+        ) -> std::result::Result<tonic::Response<super::AuthResponse>, 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(
+                "/KompAC.auth.AuthService/Register",
+            );
+            let mut req = request.into_request();
+            req.extensions_mut()
+                .insert(GrpcMethod::new("KompAC.auth.AuthService", "Register"));
+            self.inner.unary(req, path, codec).await
+        }
+        pub async fn login(
+            &mut self,
+            request: impl tonic::IntoRequest<super::LoginRequest>,
+        ) -> std::result::Result<tonic::Response<super::LoginResponse>, 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(
+                "/KompAC.auth.AuthService/Login",
+            );
+            let mut req = request.into_request();
+            req.extensions_mut()
+                .insert(GrpcMethod::new("KompAC.auth.AuthService", "Login"));
+            self.inner.unary(req, path, codec).await
+        }
+    }
+}
+/// Generated server implementations.
+pub mod auth_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 AuthServiceServer.
+    #[async_trait]
+    pub trait AuthService: std::marker::Send + std::marker::Sync + 'static {
+        async fn register(
+            &self,
+            request: tonic::Request<super::RegisterRequest>,
+        ) -> std::result::Result<tonic::Response<super::AuthResponse>, tonic::Status>;
+        async fn login(
+            &self,
+            request: tonic::Request<super::LoginRequest>,
+        ) -> std::result::Result<tonic::Response<super::LoginResponse>, tonic::Status>;
+    }
+    #[derive(Debug)]
+    pub struct AuthServiceServer<T> {
+        inner: Arc<T>,
+        accept_compression_encodings: EnabledCompressionEncodings,
+        send_compression_encodings: EnabledCompressionEncodings,
+        max_decoding_message_size: Option<usize>,
+        max_encoding_message_size: Option<usize>,
+    }
+    impl<T> AuthServiceServer<T> {
+        pub fn new(inner: T) -> Self {
+            Self::from_arc(Arc::new(inner))
+        }
+        pub fn from_arc(inner: Arc<T>) -> 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<F>(
+            inner: T,
+            interceptor: F,
+        ) -> InterceptedService<Self, F>
+        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<T, B> tonic::codegen::Service<http::Request<B>> for AuthServiceServer<T>
+    where
+        T: AuthService,
+        B: Body + std::marker::Send + 'static,
+        B::Error: Into<StdError> + std::marker::Send + 'static,
+    {
+        type Response = http::Response<tonic::body::Body>;
+        type Error = std::convert::Infallible;
+        type Future = BoxFuture<Self::Response, Self::Error>;
+        fn poll_ready(
+            &mut self,
+            _cx: &mut Context<'_>,
+        ) -> Poll<std::result::Result<(), Self::Error>> {
+            Poll::Ready(Ok(()))
+        }
+        fn call(&mut self, req: http::Request<B>) -> Self::Future {
+            match req.uri().path() {
+                "/KompAC.auth.AuthService/Register" => {
+                    #[allow(non_camel_case_types)]
+                    struct RegisterSvc<T: AuthService>(pub Arc<T>);
+                    impl<
+                        T: AuthService,
+                    > tonic::server::UnaryService<super::RegisterRequest>
+                    for RegisterSvc<T> {
+                        type Response = super::AuthResponse;
+                        type Future = BoxFuture<
+                            tonic::Response<Self::Response>,
+                            tonic::Status,
+                        >;
+                        fn call(
+                            &mut self,
+                            request: tonic::Request<super::RegisterRequest>,
+                        ) -> Self::Future {
+                            let inner = Arc::clone(&self.0);
+                            let fut = async move {
+                                <T as AuthService>::register(&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 = RegisterSvc(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)
+                }
+                "/KompAC.auth.AuthService/Login" => {
+                    #[allow(non_camel_case_types)]
+                    struct LoginSvc<T: AuthService>(pub Arc<T>);
+                    impl<T: AuthService> tonic::server::UnaryService<super::LoginRequest>
+                    for LoginSvc<T> {
+                        type Response = super::LoginResponse;
+                        type Future = BoxFuture<
+                            tonic::Response<Self::Response>,
+                            tonic::Status,
+                        >;
+                        fn call(
+                            &mut self,
+                            request: tonic::Request<super::LoginRequest>,
+                        ) -> Self::Future {
+                            let inner = Arc::clone(&self.0);
+                            let fut = async move {
+                                <T as AuthService>::login(&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 = LoginSvc(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(
+                            tonic::body::Body::default(),
+                        );
+                        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<T> Clone for AuthServiceServer<T> {
+        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 = "KompAC.auth.AuthService";
+    impl<T> tonic::server::NamedService for AuthServiceServer<T> {
+        const NAME: &'static str = SERVICE_NAME;
+    }
+}

common/src/proto/komp_ac.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,
+}

common/src/proto/komp_ac.search.rs

@@ -0,0 +1,317 @@
+// This file is @generated by prost-build.
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct SearchRequest {
+    #[prost(string, tag = "1")]
+    pub table_name: ::prost::alloc::string::String,
+    #[prost(string, tag = "2")]
+    pub query: ::prost::alloc::string::String,
+}
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct SearchResponse {
+    #[prost(message, repeated, tag = "1")]
+    pub hits: ::prost::alloc::vec::Vec<search_response::Hit>,
+}
+/// Nested message and enum types in `SearchResponse`.
+pub mod search_response {
+    #[derive(Clone, PartialEq, ::prost::Message)]
+    pub struct Hit {
+        /// PostgreSQL row ID
+        #[prost(int64, tag = "1")]
+        pub id: i64,
+        #[prost(float, tag = "2")]
+        pub score: f32,
+        #[prost(string, tag = "3")]
+        pub content_json: ::prost::alloc::string::String,
+    }
+}
+/// Generated client implementations.
+pub mod searcher_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 SearcherClient<T> {
+        inner: tonic::client::Grpc<T>,
+    }
+    impl SearcherClient<tonic::transport::Channel> {
+        /// Attempt to create a new client by connecting to a given endpoint.
+        pub async fn connect<D>(dst: D) -> Result<Self, tonic::transport::Error>
+        where
+            D: TryInto<tonic::transport::Endpoint>,
+            D::Error: Into<StdError>,
+        {
+            let conn = tonic::transport::Endpoint::new(dst)?.connect().await?;
+            Ok(Self::new(conn))
+        }
+    }
+    impl<T> SearcherClient<T>
+    where
+        T: tonic::client::GrpcService<tonic::body::Body>,
+        T::Error: Into<StdError>,
+        T::ResponseBody: Body<Data = Bytes> + std::marker::Send + 'static,
+        <T::ResponseBody as Body>::Error: Into<StdError> + 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<F>(
+            inner: T,
+            interceptor: F,
+        ) -> SearcherClient<InterceptedService<T, F>>
+        where
+            F: tonic::service::Interceptor,
+            T::ResponseBody: Default,
+            T: tonic::codegen::Service<
+                http::Request<tonic::body::Body>,
+                Response = http::Response<
+                    <T as tonic::client::GrpcService<tonic::body::Body>>::ResponseBody,
+                >,
+            >,
+            <T as tonic::codegen::Service<
+                http::Request<tonic::body::Body>,
+            >>::Error: Into<StdError> + std::marker::Send + std::marker::Sync,
+        {
+            SearcherClient::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 search_table(
+            &mut self,
+            request: impl tonic::IntoRequest<super::SearchRequest>,
+        ) -> std::result::Result<tonic::Response<super::SearchResponse>, 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(
+                "/KompAC.search.Searcher/SearchTable",
+            );
+            let mut req = request.into_request();
+            req.extensions_mut()
+                .insert(GrpcMethod::new("KompAC.search.Searcher", "SearchTable"));
+            self.inner.unary(req, path, codec).await
+        }
+    }
+}
+/// Generated server implementations.
+pub mod searcher_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 SearcherServer.
+    #[async_trait]
+    pub trait Searcher: std::marker::Send + std::marker::Sync + 'static {
+        async fn search_table(
+            &self,
+            request: tonic::Request<super::SearchRequest>,
+        ) -> std::result::Result<tonic::Response<super::SearchResponse>, tonic::Status>;
+    }
+    #[derive(Debug)]
+    pub struct SearcherServer<T> {
+        inner: Arc<T>,
+        accept_compression_encodings: EnabledCompressionEncodings,
+        send_compression_encodings: EnabledCompressionEncodings,
+        max_decoding_message_size: Option<usize>,
+        max_encoding_message_size: Option<usize>,
+    }
+    impl<T> SearcherServer<T> {
+        pub fn new(inner: T) -> Self {
+            Self::from_arc(Arc::new(inner))
+        }
+        pub fn from_arc(inner: Arc<T>) -> 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<F>(
+            inner: T,
+            interceptor: F,
+        ) -> InterceptedService<Self, F>
+        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<T, B> tonic::codegen::Service<http::Request<B>> for SearcherServer<T>
+    where
+        T: Searcher,
+        B: Body + std::marker::Send + 'static,
+        B::Error: Into<StdError> + std::marker::Send + 'static,
+    {
+        type Response = http::Response<tonic::body::Body>;
+        type Error = std::convert::Infallible;
+        type Future = BoxFuture<Self::Response, Self::Error>;
+        fn poll_ready(
+            &mut self,
+            _cx: &mut Context<'_>,
+        ) -> Poll<std::result::Result<(), Self::Error>> {
+            Poll::Ready(Ok(()))
+        }
+        fn call(&mut self, req: http::Request<B>) -> Self::Future {
+            match req.uri().path() {
+                "/KompAC.search.Searcher/SearchTable" => {
+                    #[allow(non_camel_case_types)]
+                    struct SearchTableSvc<T: Searcher>(pub Arc<T>);
+                    impl<T: Searcher> tonic::server::UnaryService<super::SearchRequest>
+                    for SearchTableSvc<T> {
+                        type Response = super::SearchResponse;
+                        type Future = BoxFuture<
+                            tonic::Response<Self::Response>,
+                            tonic::Status,
+                        >;
+                        fn call(
+                            &mut self,
+                            request: tonic::Request<super::SearchRequest>,
+                        ) -> Self::Future {
+                            let inner = Arc::clone(&self.0);
+                            let fut = async move {
+                                <T as Searcher>::search_table(&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 = SearchTableSvc(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(
+                            tonic::body::Body::default(),
+                        );
+                        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<T> Clone for SearcherServer<T> {
+        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 = "KompAC.search.Searcher";
+    impl<T> tonic::server::NamedService for SearcherServer<T> {
+        const NAME: &'static str = SERVICE_NAME;
+    }
+}

common/src/proto/komp_ac.table_definition.rs

@@ -0,0 +1,544 @@
+// This file is @generated by prost-build.
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct TableLink {
+    #[prost(string, tag = "1")]
+    pub linked_table_name: ::prost::alloc::string::String,
+    #[prost(bool, tag = "2")]
+    pub required: bool,
+}
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct PostTableDefinitionRequest {
+    #[prost(string, tag = "1")]
+    pub table_name: ::prost::alloc::string::String,
+    #[prost(message, repeated, tag = "2")]
+    pub links: ::prost::alloc::vec::Vec<TableLink>,
+    #[prost(message, repeated, tag = "3")]
+    pub columns: ::prost::alloc::vec::Vec<ColumnDefinition>,
+    #[prost(string, repeated, tag = "4")]
+    pub indexes: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
+    #[prost(string, tag = "5")]
+    pub profile_name: ::prost::alloc::string::String,
+}
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct ColumnDefinition {
+    #[prost(string, tag = "1")]
+    pub name: ::prost::alloc::string::String,
+    #[prost(string, tag = "2")]
+    pub field_type: ::prost::alloc::string::String,
+}
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct TableDefinitionResponse {
+    #[prost(bool, tag = "1")]
+    pub success: bool,
+    #[prost(string, tag = "2")]
+    pub sql: ::prost::alloc::string::String,
+}
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct ProfileTreeResponse {
+    #[prost(message, repeated, tag = "1")]
+    pub profiles: ::prost::alloc::vec::Vec<profile_tree_response::Profile>,
+}
+/// Nested message and enum types in `ProfileTreeResponse`.
+pub mod profile_tree_response {
+    #[derive(Clone, PartialEq, ::prost::Message)]
+    pub struct Table {
+        #[prost(int64, tag = "1")]
+        pub id: i64,
+        #[prost(string, tag = "2")]
+        pub name: ::prost::alloc::string::String,
+        #[prost(string, repeated, tag = "3")]
+        pub depends_on: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
+    }
+    #[derive(Clone, PartialEq, ::prost::Message)]
+    pub struct Profile {
+        #[prost(string, tag = "1")]
+        pub name: ::prost::alloc::string::String,
+        #[prost(message, repeated, tag = "2")]
+        pub tables: ::prost::alloc::vec::Vec<Table>,
+    }
+}
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct DeleteTableRequest {
+    #[prost(string, tag = "1")]
+    pub profile_name: ::prost::alloc::string::String,
+    #[prost(string, tag = "2")]
+    pub table_name: ::prost::alloc::string::String,
+}
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct DeleteTableResponse {
+    #[prost(bool, tag = "1")]
+    pub success: bool,
+    #[prost(string, tag = "2")]
+    pub message: ::prost::alloc::string::String,
+}
+/// Generated client implementations.
+pub mod table_definition_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 TableDefinitionClient<T> {
+        inner: tonic::client::Grpc<T>,
+    }
+    impl TableDefinitionClient<tonic::transport::Channel> {
+        /// Attempt to create a new client by connecting to a given endpoint.
+        pub async fn connect<D>(dst: D) -> Result<Self, tonic::transport::Error>
+        where
+            D: TryInto<tonic::transport::Endpoint>,
+            D::Error: Into<StdError>,
+        {
+            let conn = tonic::transport::Endpoint::new(dst)?.connect().await?;
+            Ok(Self::new(conn))
+        }
+    }
+    impl<T> TableDefinitionClient<T>
+    where
+        T: tonic::client::GrpcService<tonic::body::Body>,
+        T::Error: Into<StdError>,
+        T::ResponseBody: Body<Data = Bytes> + std::marker::Send + 'static,
+        <T::ResponseBody as Body>::Error: Into<StdError> + 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<F>(
+            inner: T,
+            interceptor: F,
+        ) -> TableDefinitionClient<InterceptedService<T, F>>
+        where
+            F: tonic::service::Interceptor,
+            T::ResponseBody: Default,
+            T: tonic::codegen::Service<
+                http::Request<tonic::body::Body>,
+                Response = http::Response<
+                    <T as tonic::client::GrpcService<tonic::body::Body>>::ResponseBody,
+                >,
+            >,
+            <T as tonic::codegen::Service<
+                http::Request<tonic::body::Body>,
+            >>::Error: Into<StdError> + std::marker::Send + std::marker::Sync,
+        {
+            TableDefinitionClient::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_table_definition(
+            &mut self,
+            request: impl tonic::IntoRequest<super::PostTableDefinitionRequest>,
+        ) -> std::result::Result<
+            tonic::Response<super::TableDefinitionResponse>,
+            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(
+                "/KompAC.table_definition.TableDefinition/PostTableDefinition",
+            );
+            let mut req = request.into_request();
+            req.extensions_mut()
+                .insert(
+                    GrpcMethod::new(
+                        "KompAC.table_definition.TableDefinition",
+                        "PostTableDefinition",
+                    ),
+                );
+            self.inner.unary(req, path, codec).await
+        }
+        pub async fn get_profile_tree(
+            &mut self,
+            request: impl tonic::IntoRequest<super::super::common::Empty>,
+        ) -> std::result::Result<
+            tonic::Response<super::ProfileTreeResponse>,
+            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(
+                "/KompAC.table_definition.TableDefinition/GetProfileTree",
+            );
+            let mut req = request.into_request();
+            req.extensions_mut()
+                .insert(
+                    GrpcMethod::new(
+                        "KompAC.table_definition.TableDefinition",
+                        "GetProfileTree",
+                    ),
+                );
+            self.inner.unary(req, path, codec).await
+        }
+        pub async fn delete_table(
+            &mut self,
+            request: impl tonic::IntoRequest<super::DeleteTableRequest>,
+        ) -> std::result::Result<
+            tonic::Response<super::DeleteTableResponse>,
+            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(
+                "/KompAC.table_definition.TableDefinition/DeleteTable",
+            );
+            let mut req = request.into_request();
+            req.extensions_mut()
+                .insert(
+                    GrpcMethod::new(
+                        "KompAC.table_definition.TableDefinition",
+                        "DeleteTable",
+                    ),
+                );
+            self.inner.unary(req, path, codec).await
+        }
+    }
+}
+/// Generated server implementations.
+pub mod table_definition_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 TableDefinitionServer.
+    #[async_trait]
+    pub trait TableDefinition: std::marker::Send + std::marker::Sync + 'static {
+        async fn post_table_definition(
+            &self,
+            request: tonic::Request<super::PostTableDefinitionRequest>,
+        ) -> std::result::Result<
+            tonic::Response<super::TableDefinitionResponse>,
+            tonic::Status,
+        >;
+        async fn get_profile_tree(
+            &self,
+            request: tonic::Request<super::super::common::Empty>,
+        ) -> std::result::Result<
+            tonic::Response<super::ProfileTreeResponse>,
+            tonic::Status,
+        >;
+        async fn delete_table(
+            &self,
+            request: tonic::Request<super::DeleteTableRequest>,
+        ) -> std::result::Result<
+            tonic::Response<super::DeleteTableResponse>,
+            tonic::Status,
+        >;
+    }
+    #[derive(Debug)]
+    pub struct TableDefinitionServer<T> {
+        inner: Arc<T>,
+        accept_compression_encodings: EnabledCompressionEncodings,
+        send_compression_encodings: EnabledCompressionEncodings,
+        max_decoding_message_size: Option<usize>,
+        max_encoding_message_size: Option<usize>,
+    }
+    impl<T> TableDefinitionServer<T> {
+        pub fn new(inner: T) -> Self {
+            Self::from_arc(Arc::new(inner))
+        }
+        pub fn from_arc(inner: Arc<T>) -> 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<F>(
+            inner: T,
+            interceptor: F,
+        ) -> InterceptedService<Self, F>
+        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<T, B> tonic::codegen::Service<http::Request<B>> for TableDefinitionServer<T>
+    where
+        T: TableDefinition,
+        B: Body + std::marker::Send + 'static,
+        B::Error: Into<StdError> + std::marker::Send + 'static,
+    {
+        type Response = http::Response<tonic::body::Body>;
+        type Error = std::convert::Infallible;
+        type Future = BoxFuture<Self::Response, Self::Error>;
+        fn poll_ready(
+            &mut self,
+            _cx: &mut Context<'_>,
+        ) -> Poll<std::result::Result<(), Self::Error>> {
+            Poll::Ready(Ok(()))
+        }
+        fn call(&mut self, req: http::Request<B>) -> Self::Future {
+            match req.uri().path() {
+                "/KompAC.table_definition.TableDefinition/PostTableDefinition" => {
+                    #[allow(non_camel_case_types)]
+                    struct PostTableDefinitionSvc<T: TableDefinition>(pub Arc<T>);
+                    impl<
+                        T: TableDefinition,
+                    > tonic::server::UnaryService<super::PostTableDefinitionRequest>
+                    for PostTableDefinitionSvc<T> {
+                        type Response = super::TableDefinitionResponse;
+                        type Future = BoxFuture<
+                            tonic::Response<Self::Response>,
+                            tonic::Status,
+                        >;
+                        fn call(
+                            &mut self,
+                            request: tonic::Request<super::PostTableDefinitionRequest>,
+                        ) -> Self::Future {
+                            let inner = Arc::clone(&self.0);
+                            let fut = async move {
+                                <T as TableDefinition>::post_table_definition(
+                                        &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 = PostTableDefinitionSvc(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)
+                }
+                "/KompAC.table_definition.TableDefinition/GetProfileTree" => {
+                    #[allow(non_camel_case_types)]
+                    struct GetProfileTreeSvc<T: TableDefinition>(pub Arc<T>);
+                    impl<
+                        T: TableDefinition,
+                    > tonic::server::UnaryService<super::super::common::Empty>
+                    for GetProfileTreeSvc<T> {
+                        type Response = super::ProfileTreeResponse;
+                        type Future = BoxFuture<
+                            tonic::Response<Self::Response>,
+                            tonic::Status,
+                        >;
+                        fn call(
+                            &mut self,
+                            request: tonic::Request<super::super::common::Empty>,
+                        ) -> Self::Future {
+                            let inner = Arc::clone(&self.0);
+                            let fut = async move {
+                                <T as TableDefinition>::get_profile_tree(&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 = GetProfileTreeSvc(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)
+                }
+                "/KompAC.table_definition.TableDefinition/DeleteTable" => {
+                    #[allow(non_camel_case_types)]
+                    struct DeleteTableSvc<T: TableDefinition>(pub Arc<T>);
+                    impl<
+                        T: TableDefinition,
+                    > tonic::server::UnaryService<super::DeleteTableRequest>
+                    for DeleteTableSvc<T> {
+                        type Response = super::DeleteTableResponse;
+                        type Future = BoxFuture<
+                            tonic::Response<Self::Response>,
+                            tonic::Status,
+                        >;
+                        fn call(
+                            &mut self,
+                            request: tonic::Request<super::DeleteTableRequest>,
+                        ) -> Self::Future {
+                            let inner = Arc::clone(&self.0);
+                            let fut = async move {
+                                <T as TableDefinition>::delete_table(&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 = DeleteTableSvc(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(
+                            tonic::body::Body::default(),
+                        );
+                        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<T> Clone for TableDefinitionServer<T> {
+        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 = "KompAC.table_definition.TableDefinition";
+    impl<T> tonic::server::NamedService for TableDefinitionServer<T> {
+        const NAME: &'static str = SERVICE_NAME;
+    }
+}

common/src/proto/komp_ac.table_script.rs

@@ -0,0 +1,320 @@
+// This file is @generated by prost-build.
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct PostTableScriptRequest {
+    #[prost(int64, tag = "1")]
+    pub table_definition_id: i64,
+    #[prost(string, tag = "2")]
+    pub target_column: ::prost::alloc::string::String,
+    #[prost(string, tag = "3")]
+    pub script: ::prost::alloc::string::String,
+    #[prost(string, tag = "4")]
+    pub description: ::prost::alloc::string::String,
+}
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct TableScriptResponse {
+    #[prost(int64, tag = "1")]
+    pub id: i64,
+    #[prost(string, tag = "2")]
+    pub warnings: ::prost::alloc::string::String,
+}
+/// Generated client implementations.
+pub mod table_script_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 TableScriptClient<T> {
+        inner: tonic::client::Grpc<T>,
+    }
+    impl TableScriptClient<tonic::transport::Channel> {
+        /// Attempt to create a new client by connecting to a given endpoint.
+        pub async fn connect<D>(dst: D) -> Result<Self, tonic::transport::Error>
+        where
+            D: TryInto<tonic::transport::Endpoint>,
+            D::Error: Into<StdError>,
+        {
+            let conn = tonic::transport::Endpoint::new(dst)?.connect().await?;
+            Ok(Self::new(conn))
+        }
+    }
+    impl<T> TableScriptClient<T>
+    where
+        T: tonic::client::GrpcService<tonic::body::Body>,
+        T::Error: Into<StdError>,
+        T::ResponseBody: Body<Data = Bytes> + std::marker::Send + 'static,
+        <T::ResponseBody as Body>::Error: Into<StdError> + 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<F>(
+            inner: T,
+            interceptor: F,
+        ) -> TableScriptClient<InterceptedService<T, F>>
+        where
+            F: tonic::service::Interceptor,
+            T::ResponseBody: Default,
+            T: tonic::codegen::Service<
+                http::Request<tonic::body::Body>,
+                Response = http::Response<
+                    <T as tonic::client::GrpcService<tonic::body::Body>>::ResponseBody,
+                >,
+            >,
+            <T as tonic::codegen::Service<
+                http::Request<tonic::body::Body>,
+            >>::Error: Into<StdError> + std::marker::Send + std::marker::Sync,
+        {
+            TableScriptClient::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_table_script(
+            &mut self,
+            request: impl tonic::IntoRequest<super::PostTableScriptRequest>,
+        ) -> std::result::Result<
+            tonic::Response<super::TableScriptResponse>,
+            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(
+                "/KompAC.table_script.TableScript/PostTableScript",
+            );
+            let mut req = request.into_request();
+            req.extensions_mut()
+                .insert(
+                    GrpcMethod::new("KompAC.table_script.TableScript", "PostTableScript"),
+                );
+            self.inner.unary(req, path, codec).await
+        }
+    }
+}
+/// Generated server implementations.
+pub mod table_script_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 TableScriptServer.
+    #[async_trait]
+    pub trait TableScript: std::marker::Send + std::marker::Sync + 'static {
+        async fn post_table_script(
+            &self,
+            request: tonic::Request<super::PostTableScriptRequest>,
+        ) -> std::result::Result<
+            tonic::Response<super::TableScriptResponse>,
+            tonic::Status,
+        >;
+    }
+    #[derive(Debug)]
+    pub struct TableScriptServer<T> {
+        inner: Arc<T>,
+        accept_compression_encodings: EnabledCompressionEncodings,
+        send_compression_encodings: EnabledCompressionEncodings,
+        max_decoding_message_size: Option<usize>,
+        max_encoding_message_size: Option<usize>,
+    }
+    impl<T> TableScriptServer<T> {
+        pub fn new(inner: T) -> Self {
+            Self::from_arc(Arc::new(inner))
+        }
+        pub fn from_arc(inner: Arc<T>) -> 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<F>(
+            inner: T,
+            interceptor: F,
+        ) -> InterceptedService<Self, F>
+        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<T, B> tonic::codegen::Service<http::Request<B>> for TableScriptServer<T>
+    where
+        T: TableScript,
+        B: Body + std::marker::Send + 'static,
+        B::Error: Into<StdError> + std::marker::Send + 'static,
+    {
+        type Response = http::Response<tonic::body::Body>;
+        type Error = std::convert::Infallible;
+        type Future = BoxFuture<Self::Response, Self::Error>;
+        fn poll_ready(
+            &mut self,
+            _cx: &mut Context<'_>,
+        ) -> Poll<std::result::Result<(), Self::Error>> {
+            Poll::Ready(Ok(()))
+        }
+        fn call(&mut self, req: http::Request<B>) -> Self::Future {
+            match req.uri().path() {
+                "/KompAC.table_script.TableScript/PostTableScript" => {
+                    #[allow(non_camel_case_types)]
+                    struct PostTableScriptSvc<T: TableScript>(pub Arc<T>);
+                    impl<
+                        T: TableScript,
+                    > tonic::server::UnaryService<super::PostTableScriptRequest>
+                    for PostTableScriptSvc<T> {
+                        type Response = super::TableScriptResponse;
+                        type Future = BoxFuture<
+                            tonic::Response<Self::Response>,
+                            tonic::Status,
+                        >;
+                        fn call(
+                            &mut self,
+                            request: tonic::Request<super::PostTableScriptRequest>,
+                        ) -> Self::Future {
+                            let inner = Arc::clone(&self.0);
+                            let fut = async move {
+                                <T as TableScript>::post_table_script(&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 = PostTableScriptSvc(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(
+                            tonic::body::Body::default(),
+                        );
+                        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<T> Clone for TableScriptServer<T> {
+        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 = "KompAC.table_script.TableScript";
+    impl<T> tonic::server::NamedService for TableScriptServer<T> {
+        const NAME: &'static str = SERVICE_NAME;
+    }
+}

common/src/proto/komp_ac.table_structure.rs

@@ -0,0 +1,336 @@
+// This file is @generated by prost-build.
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct GetTableStructureRequest {
+    /// e.g., "default"
+    #[prost(string, tag = "1")]
+    pub profile_name: ::prost::alloc::string::String,
+    /// e.g., "2025_adresar6"
+    #[prost(string, tag = "2")]
+    pub table_name: ::prost::alloc::string::String,
+}
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct TableStructureResponse {
+    #[prost(message, repeated, tag = "1")]
+    pub columns: ::prost::alloc::vec::Vec<TableColumn>,
+}
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct TableColumn {
+    #[prost(string, tag = "1")]
+    pub name: ::prost::alloc::string::String,
+    /// e.g., "TEXT", "BIGINT", "VARCHAR(255)", "TIMESTAMPTZ"
+    #[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<T> {
+        inner: tonic::client::Grpc<T>,
+    }
+    impl TableStructureServiceClient<tonic::transport::Channel> {
+        /// Attempt to create a new client by connecting to a given endpoint.
+        pub async fn connect<D>(dst: D) -> Result<Self, tonic::transport::Error>
+        where
+            D: TryInto<tonic::transport::Endpoint>,
+            D::Error: Into<StdError>,
+        {
+            let conn = tonic::transport::Endpoint::new(dst)?.connect().await?;
+            Ok(Self::new(conn))
+        }
+    }
+    impl<T> TableStructureServiceClient<T>
+    where
+        T: tonic::client::GrpcService<tonic::body::Body>,
+        T::Error: Into<StdError>,
+        T::ResponseBody: Body<Data = Bytes> + std::marker::Send + 'static,
+        <T::ResponseBody as Body>::Error: Into<StdError> + 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<F>(
+            inner: T,
+            interceptor: F,
+        ) -> TableStructureServiceClient<InterceptedService<T, F>>
+        where
+            F: tonic::service::Interceptor,
+            T::ResponseBody: Default,
+            T: tonic::codegen::Service<
+                http::Request<tonic::body::Body>,
+                Response = http::Response<
+                    <T as tonic::client::GrpcService<tonic::body::Body>>::ResponseBody,
+                >,
+            >,
+            <T as tonic::codegen::Service<
+                http::Request<tonic::body::Body>,
+            >>::Error: Into<StdError> + 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_table_structure(
+            &mut self,
+            request: impl tonic::IntoRequest<super::GetTableStructureRequest>,
+        ) -> std::result::Result<
+            tonic::Response<super::TableStructureResponse>,
+            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(
+                "/KompAC.table_structure.TableStructureService/GetTableStructure",
+            );
+            let mut req = request.into_request();
+            req.extensions_mut()
+                .insert(
+                    GrpcMethod::new(
+                        "KompAC.table_structure.TableStructureService",
+                        "GetTableStructure",
+                    ),
+                );
+            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_table_structure(
+            &self,
+            request: tonic::Request<super::GetTableStructureRequest>,
+        ) -> std::result::Result<
+            tonic::Response<super::TableStructureResponse>,
+            tonic::Status,
+        >;
+    }
+    #[derive(Debug)]
+    pub struct TableStructureServiceServer<T> {
+        inner: Arc<T>,
+        accept_compression_encodings: EnabledCompressionEncodings,
+        send_compression_encodings: EnabledCompressionEncodings,
+        max_decoding_message_size: Option<usize>,
+        max_encoding_message_size: Option<usize>,
+    }
+    impl<T> TableStructureServiceServer<T> {
+        pub fn new(inner: T) -> Self {
+            Self::from_arc(Arc::new(inner))
+        }
+        pub fn from_arc(inner: Arc<T>) -> 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<F>(
+            inner: T,
+            interceptor: F,
+        ) -> InterceptedService<Self, F>
+        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<T, B> tonic::codegen::Service<http::Request<B>>
+    for TableStructureServiceServer<T>
+    where
+        T: TableStructureService,
+        B: Body + std::marker::Send + 'static,
+        B::Error: Into<StdError> + std::marker::Send + 'static,
+    {
+        type Response = http::Response<tonic::body::Body>;
+        type Error = std::convert::Infallible;
+        type Future = BoxFuture<Self::Response, Self::Error>;
+        fn poll_ready(
+            &mut self,
+            _cx: &mut Context<'_>,
+        ) -> Poll<std::result::Result<(), Self::Error>> {
+            Poll::Ready(Ok(()))
+        }
+        fn call(&mut self, req: http::Request<B>) -> Self::Future {
+            match req.uri().path() {
+                "/KompAC.table_structure.TableStructureService/GetTableStructure" => {
+                    #[allow(non_camel_case_types)]
+                    struct GetTableStructureSvc<T: TableStructureService>(pub Arc<T>);
+                    impl<
+                        T: TableStructureService,
+                    > tonic::server::UnaryService<super::GetTableStructureRequest>
+                    for GetTableStructureSvc<T> {
+                        type Response = super::TableStructureResponse;
+                        type Future = BoxFuture<
+                            tonic::Response<Self::Response>,
+                            tonic::Status,
+                        >;
+                        fn call(
+                            &mut self,
+                            request: tonic::Request<super::GetTableStructureRequest>,
+                        ) -> Self::Future {
+                            let inner = Arc::clone(&self.0);
+                            let fut = async move {
+                                <T as TableStructureService>::get_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 = GetTableStructureSvc(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(
+                            tonic::body::Body::default(),
+                        );
+                        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<T> Clone for TableStructureServiceServer<T> {
+        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 = "KompAC.table_structure.TableStructureService";
+    impl<T> tonic::server::NamedService for TableStructureServiceServer<T> {
+        const NAME: &'static str = SERVICE_NAME;
+    }
+}

common/src/proto/komp_ac.tables_data.rs

@@ -0,0 +1,791 @@
+// This file is @generated by prost-build.
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct PostTableDataRequest {
+    #[prost(string, tag = "1")]
+    pub profile_name: ::prost::alloc::string::String,
+    #[prost(string, tag = "2")]
+    pub table_name: ::prost::alloc::string::String,
+    #[prost(map = "string, message", tag = "3")]
+    pub data: ::std::collections::HashMap<
+        ::prost::alloc::string::String,
+        ::prost_types::Value,
+    >,
+}
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct PostTableDataResponse {
+    #[prost(bool, tag = "1")]
+    pub success: bool,
+    #[prost(string, tag = "2")]
+    pub message: ::prost::alloc::string::String,
+    #[prost(int64, tag = "3")]
+    pub inserted_id: i64,
+}
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct PutTableDataRequest {
+    #[prost(string, tag = "1")]
+    pub profile_name: ::prost::alloc::string::String,
+    #[prost(string, tag = "2")]
+    pub table_name: ::prost::alloc::string::String,
+    #[prost(int64, tag = "3")]
+    pub id: i64,
+    #[prost(map = "string, message", tag = "4")]
+    pub data: ::std::collections::HashMap<
+        ::prost::alloc::string::String,
+        ::prost_types::Value,
+    >,
+}
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct PutTableDataResponse {
+    #[prost(bool, tag = "1")]
+    pub success: bool,
+    #[prost(string, tag = "2")]
+    pub message: ::prost::alloc::string::String,
+    #[prost(int64, tag = "3")]
+    pub updated_id: i64,
+}
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct DeleteTableDataRequest {
+    #[prost(string, tag = "1")]
+    pub profile_name: ::prost::alloc::string::String,
+    #[prost(string, tag = "2")]
+    pub table_name: ::prost::alloc::string::String,
+    #[prost(int64, tag = "3")]
+    pub record_id: i64,
+}
+#[derive(Clone, Copy, PartialEq, ::prost::Message)]
+pub struct DeleteTableDataResponse {
+    #[prost(bool, tag = "1")]
+    pub success: bool,
+}
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct GetTableDataRequest {
+    #[prost(string, tag = "1")]
+    pub profile_name: ::prost::alloc::string::String,
+    #[prost(string, tag = "2")]
+    pub table_name: ::prost::alloc::string::String,
+    #[prost(int64, tag = "3")]
+    pub id: i64,
+}
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct GetTableDataResponse {
+    #[prost(map = "string, string", tag = "1")]
+    pub data: ::std::collections::HashMap<
+        ::prost::alloc::string::String,
+        ::prost::alloc::string::String,
+    >,
+}
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct GetTableDataCountRequest {
+    #[prost(string, tag = "1")]
+    pub profile_name: ::prost::alloc::string::String,
+    #[prost(string, tag = "2")]
+    pub table_name: ::prost::alloc::string::String,
+}
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct GetTableDataByPositionRequest {
+    #[prost(string, tag = "1")]
+    pub profile_name: ::prost::alloc::string::String,
+    #[prost(string, tag = "2")]
+    pub table_name: ::prost::alloc::string::String,
+    #[prost(int32, tag = "3")]
+    pub position: i32,
+}
+/// Generated client implementations.
+pub mod tables_data_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 TablesDataClient<T> {
+        inner: tonic::client::Grpc<T>,
+    }
+    impl TablesDataClient<tonic::transport::Channel> {
+        /// Attempt to create a new client by connecting to a given endpoint.
+        pub async fn connect<D>(dst: D) -> Result<Self, tonic::transport::Error>
+        where
+            D: TryInto<tonic::transport::Endpoint>,
+            D::Error: Into<StdError>,
+        {
+            let conn = tonic::transport::Endpoint::new(dst)?.connect().await?;
+            Ok(Self::new(conn))
+        }
+    }
+    impl<T> TablesDataClient<T>
+    where
+        T: tonic::client::GrpcService<tonic::body::Body>,
+        T::Error: Into<StdError>,
+        T::ResponseBody: Body<Data = Bytes> + std::marker::Send + 'static,
+        <T::ResponseBody as Body>::Error: Into<StdError> + 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<F>(
+            inner: T,
+            interceptor: F,
+        ) -> TablesDataClient<InterceptedService<T, F>>
+        where
+            F: tonic::service::Interceptor,
+            T::ResponseBody: Default,
+            T: tonic::codegen::Service<
+                http::Request<tonic::body::Body>,
+                Response = http::Response<
+                    <T as tonic::client::GrpcService<tonic::body::Body>>::ResponseBody,
+                >,
+            >,
+            <T as tonic::codegen::Service<
+                http::Request<tonic::body::Body>,
+            >>::Error: Into<StdError> + std::marker::Send + std::marker::Sync,
+        {
+            TablesDataClient::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_table_data(
+            &mut self,
+            request: impl tonic::IntoRequest<super::PostTableDataRequest>,
+        ) -> std::result::Result<
+            tonic::Response<super::PostTableDataResponse>,
+            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(
+                "/KompAC.tables_data.TablesData/PostTableData",
+            );
+            let mut req = request.into_request();
+            req.extensions_mut()
+                .insert(
+                    GrpcMethod::new("KompAC.tables_data.TablesData", "PostTableData"),
+                );
+            self.inner.unary(req, path, codec).await
+        }
+        pub async fn put_table_data(
+            &mut self,
+            request: impl tonic::IntoRequest<super::PutTableDataRequest>,
+        ) -> std::result::Result<
+            tonic::Response<super::PutTableDataResponse>,
+            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(
+                "/KompAC.tables_data.TablesData/PutTableData",
+            );
+            let mut req = request.into_request();
+            req.extensions_mut()
+                .insert(
+                    GrpcMethod::new("KompAC.tables_data.TablesData", "PutTableData"),
+                );
+            self.inner.unary(req, path, codec).await
+        }
+        pub async fn delete_table_data(
+            &mut self,
+            request: impl tonic::IntoRequest<super::DeleteTableDataRequest>,
+        ) -> std::result::Result<
+            tonic::Response<super::DeleteTableDataResponse>,
+            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(
+                "/KompAC.tables_data.TablesData/DeleteTableData",
+            );
+            let mut req = request.into_request();
+            req.extensions_mut()
+                .insert(
+                    GrpcMethod::new("KompAC.tables_data.TablesData", "DeleteTableData"),
+                );
+            self.inner.unary(req, path, codec).await
+        }
+        pub async fn get_table_data(
+            &mut self,
+            request: impl tonic::IntoRequest<super::GetTableDataRequest>,
+        ) -> std::result::Result<
+            tonic::Response<super::GetTableDataResponse>,
+            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(
+                "/KompAC.tables_data.TablesData/GetTableData",
+            );
+            let mut req = request.into_request();
+            req.extensions_mut()
+                .insert(
+                    GrpcMethod::new("KompAC.tables_data.TablesData", "GetTableData"),
+                );
+            self.inner.unary(req, path, codec).await
+        }
+        pub async fn get_table_data_count(
+            &mut self,
+            request: impl tonic::IntoRequest<super::GetTableDataCountRequest>,
+        ) -> std::result::Result<
+            tonic::Response<super::super::common::CountResponse>,
+            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(
+                "/KompAC.tables_data.TablesData/GetTableDataCount",
+            );
+            let mut req = request.into_request();
+            req.extensions_mut()
+                .insert(
+                    GrpcMethod::new("KompAC.tables_data.TablesData", "GetTableDataCount"),
+                );
+            self.inner.unary(req, path, codec).await
+        }
+        pub async fn get_table_data_by_position(
+            &mut self,
+            request: impl tonic::IntoRequest<super::GetTableDataByPositionRequest>,
+        ) -> std::result::Result<
+            tonic::Response<super::GetTableDataResponse>,
+            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(
+                "/KompAC.tables_data.TablesData/GetTableDataByPosition",
+            );
+            let mut req = request.into_request();
+            req.extensions_mut()
+                .insert(
+                    GrpcMethod::new(
+                        "KompAC.tables_data.TablesData",
+                        "GetTableDataByPosition",
+                    ),
+                );
+            self.inner.unary(req, path, codec).await
+        }
+    }
+}
+/// Generated server implementations.
+pub mod tables_data_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 TablesDataServer.
+    #[async_trait]
+    pub trait TablesData: std::marker::Send + std::marker::Sync + 'static {
+        async fn post_table_data(
+            &self,
+            request: tonic::Request<super::PostTableDataRequest>,
+        ) -> std::result::Result<
+            tonic::Response<super::PostTableDataResponse>,
+            tonic::Status,
+        >;
+        async fn put_table_data(
+            &self,
+            request: tonic::Request<super::PutTableDataRequest>,
+        ) -> std::result::Result<
+            tonic::Response<super::PutTableDataResponse>,
+            tonic::Status,
+        >;
+        async fn delete_table_data(
+            &self,
+            request: tonic::Request<super::DeleteTableDataRequest>,
+        ) -> std::result::Result<
+            tonic::Response<super::DeleteTableDataResponse>,
+            tonic::Status,
+        >;
+        async fn get_table_data(
+            &self,
+            request: tonic::Request<super::GetTableDataRequest>,
+        ) -> std::result::Result<
+            tonic::Response<super::GetTableDataResponse>,
+            tonic::Status,
+        >;
+        async fn get_table_data_count(
+            &self,
+            request: tonic::Request<super::GetTableDataCountRequest>,
+        ) -> std::result::Result<
+            tonic::Response<super::super::common::CountResponse>,
+            tonic::Status,
+        >;
+        async fn get_table_data_by_position(
+            &self,
+            request: tonic::Request<super::GetTableDataByPositionRequest>,
+        ) -> std::result::Result<
+            tonic::Response<super::GetTableDataResponse>,
+            tonic::Status,
+        >;
+    }
+    #[derive(Debug)]
+    pub struct TablesDataServer<T> {
+        inner: Arc<T>,
+        accept_compression_encodings: EnabledCompressionEncodings,
+        send_compression_encodings: EnabledCompressionEncodings,
+        max_decoding_message_size: Option<usize>,
+        max_encoding_message_size: Option<usize>,
+    }
+    impl<T> TablesDataServer<T> {
+        pub fn new(inner: T) -> Self {
+            Self::from_arc(Arc::new(inner))
+        }
+        pub fn from_arc(inner: Arc<T>) -> 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<F>(
+            inner: T,
+            interceptor: F,
+        ) -> InterceptedService<Self, F>
+        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<T, B> tonic::codegen::Service<http::Request<B>> for TablesDataServer<T>
+    where
+        T: TablesData,
+        B: Body + std::marker::Send + 'static,
+        B::Error: Into<StdError> + std::marker::Send + 'static,
+    {
+        type Response = http::Response<tonic::body::Body>;
+        type Error = std::convert::Infallible;
+        type Future = BoxFuture<Self::Response, Self::Error>;
+        fn poll_ready(
+            &mut self,
+            _cx: &mut Context<'_>,
+        ) -> Poll<std::result::Result<(), Self::Error>> {
+            Poll::Ready(Ok(()))
+        }
+        fn call(&mut self, req: http::Request<B>) -> Self::Future {
+            match req.uri().path() {
+                "/KompAC.tables_data.TablesData/PostTableData" => {
+                    #[allow(non_camel_case_types)]
+                    struct PostTableDataSvc<T: TablesData>(pub Arc<T>);
+                    impl<
+                        T: TablesData,
+                    > tonic::server::UnaryService<super::PostTableDataRequest>
+                    for PostTableDataSvc<T> {
+                        type Response = super::PostTableDataResponse;
+                        type Future = BoxFuture<
+                            tonic::Response<Self::Response>,
+                            tonic::Status,
+                        >;
+                        fn call(
+                            &mut self,
+                            request: tonic::Request<super::PostTableDataRequest>,
+                        ) -> Self::Future {
+                            let inner = Arc::clone(&self.0);
+                            let fut = async move {
+                                <T as TablesData>::post_table_data(&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 = PostTableDataSvc(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)
+                }
+                "/KompAC.tables_data.TablesData/PutTableData" => {
+                    #[allow(non_camel_case_types)]
+                    struct PutTableDataSvc<T: TablesData>(pub Arc<T>);
+                    impl<
+                        T: TablesData,
+                    > tonic::server::UnaryService<super::PutTableDataRequest>
+                    for PutTableDataSvc<T> {
+                        type Response = super::PutTableDataResponse;
+                        type Future = BoxFuture<
+                            tonic::Response<Self::Response>,
+                            tonic::Status,
+                        >;
+                        fn call(
+                            &mut self,
+                            request: tonic::Request<super::PutTableDataRequest>,
+                        ) -> Self::Future {
+                            let inner = Arc::clone(&self.0);
+                            let fut = async move {
+                                <T as TablesData>::put_table_data(&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 = PutTableDataSvc(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)
+                }
+                "/KompAC.tables_data.TablesData/DeleteTableData" => {
+                    #[allow(non_camel_case_types)]
+                    struct DeleteTableDataSvc<T: TablesData>(pub Arc<T>);
+                    impl<
+                        T: TablesData,
+                    > tonic::server::UnaryService<super::DeleteTableDataRequest>
+                    for DeleteTableDataSvc<T> {
+                        type Response = super::DeleteTableDataResponse;
+                        type Future = BoxFuture<
+                            tonic::Response<Self::Response>,
+                            tonic::Status,
+                        >;
+                        fn call(
+                            &mut self,
+                            request: tonic::Request<super::DeleteTableDataRequest>,
+                        ) -> Self::Future {
+                            let inner = Arc::clone(&self.0);
+                            let fut = async move {
+                                <T as TablesData>::delete_table_data(&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 = DeleteTableDataSvc(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)
+                }
+                "/KompAC.tables_data.TablesData/GetTableData" => {
+                    #[allow(non_camel_case_types)]
+                    struct GetTableDataSvc<T: TablesData>(pub Arc<T>);
+                    impl<
+                        T: TablesData,
+                    > tonic::server::UnaryService<super::GetTableDataRequest>
+                    for GetTableDataSvc<T> {
+                        type Response = super::GetTableDataResponse;
+                        type Future = BoxFuture<
+                            tonic::Response<Self::Response>,
+                            tonic::Status,
+                        >;
+                        fn call(
+                            &mut self,
+                            request: tonic::Request<super::GetTableDataRequest>,
+                        ) -> Self::Future {
+                            let inner = Arc::clone(&self.0);
+                            let fut = async move {
+                                <T as TablesData>::get_table_data(&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 = GetTableDataSvc(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)
+                }
+                "/KompAC.tables_data.TablesData/GetTableDataCount" => {
+                    #[allow(non_camel_case_types)]
+                    struct GetTableDataCountSvc<T: TablesData>(pub Arc<T>);
+                    impl<
+                        T: TablesData,
+                    > tonic::server::UnaryService<super::GetTableDataCountRequest>
+                    for GetTableDataCountSvc<T> {
+                        type Response = super::super::common::CountResponse;
+                        type Future = BoxFuture<
+                            tonic::Response<Self::Response>,
+                            tonic::Status,
+                        >;
+                        fn call(
+                            &mut self,
+                            request: tonic::Request<super::GetTableDataCountRequest>,
+                        ) -> Self::Future {
+                            let inner = Arc::clone(&self.0);
+                            let fut = async move {
+                                <T as TablesData>::get_table_data_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 = GetTableDataCountSvc(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)
+                }
+                "/KompAC.tables_data.TablesData/GetTableDataByPosition" => {
+                    #[allow(non_camel_case_types)]
+                    struct GetTableDataByPositionSvc<T: TablesData>(pub Arc<T>);
+                    impl<
+                        T: TablesData,
+                    > tonic::server::UnaryService<super::GetTableDataByPositionRequest>
+                    for GetTableDataByPositionSvc<T> {
+                        type Response = super::GetTableDataResponse;
+                        type Future = BoxFuture<
+                            tonic::Response<Self::Response>,
+                            tonic::Status,
+                        >;
+                        fn call(
+                            &mut self,
+                            request: tonic::Request<super::GetTableDataByPositionRequest>,
+                        ) -> Self::Future {
+                            let inner = Arc::clone(&self.0);
+                            let fut = async move {
+                                <T as TablesData>::get_table_data_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 = GetTableDataByPositionSvc(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(
+                            tonic::body::Body::default(),
+                        );
+                        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<T> Clone for TablesDataServer<T> {
+        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 = "KompAC.tables_data.TablesData";
+    impl<T> tonic::server::NamedService for TablesDataServer<T> {
+        const NAME: &'static str = SERVICE_NAME;
+    }
+}

common/src/proto/komp_ac.uctovnictvo.rs

@@ -0,0 +1,712 @@
+// 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<T> {
+        inner: tonic::client::Grpc<T>,
+    }
+    impl UctovnictvoClient<tonic::transport::Channel> {
+        /// Attempt to create a new client by connecting to a given endpoint.
+        pub async fn connect<D>(dst: D) -> Result<Self, tonic::transport::Error>
+        where
+            D: TryInto<tonic::transport::Endpoint>,
+            D::Error: Into<StdError>,
+        {
+            let conn = tonic::transport::Endpoint::new(dst)?.connect().await?;
+            Ok(Self::new(conn))
+        }
+    }
+    impl<T> UctovnictvoClient<T>
+    where
+        T: tonic::client::GrpcService<tonic::body::Body>,
+        T::Error: Into<StdError>,
+        T::ResponseBody: Body<Data = Bytes> + std::marker::Send + 'static,
+        <T::ResponseBody as Body>::Error: Into<StdError> + 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<F>(
+            inner: T,
+            interceptor: F,
+        ) -> UctovnictvoClient<InterceptedService<T, F>>
+        where
+            F: tonic::service::Interceptor,
+            T::ResponseBody: Default,
+            T: tonic::codegen::Service<
+                http::Request<tonic::body::Body>,
+                Response = http::Response<
+                    <T as tonic::client::GrpcService<tonic::body::Body>>::ResponseBody,
+                >,
+            >,
+            <T as tonic::codegen::Service<
+                http::Request<tonic::body::Body>,
+            >>::Error: Into<StdError> + 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<super::PostUctovnictvoRequest>,
+        ) -> std::result::Result<
+            tonic::Response<super::UctovnictvoResponse>,
+            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(
+                "/KompAC.uctovnictvo.Uctovnictvo/PostUctovnictvo",
+            );
+            let mut req = request.into_request();
+            req.extensions_mut()
+                .insert(
+                    GrpcMethod::new("KompAC.uctovnictvo.Uctovnictvo", "PostUctovnictvo"),
+                );
+            self.inner.unary(req, path, codec).await
+        }
+        pub async fn get_uctovnictvo(
+            &mut self,
+            request: impl tonic::IntoRequest<super::GetUctovnictvoRequest>,
+        ) -> std::result::Result<
+            tonic::Response<super::UctovnictvoResponse>,
+            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(
+                "/KompAC.uctovnictvo.Uctovnictvo/GetUctovnictvo",
+            );
+            let mut req = request.into_request();
+            req.extensions_mut()
+                .insert(
+                    GrpcMethod::new("KompAC.uctovnictvo.Uctovnictvo", "GetUctovnictvo"),
+                );
+            self.inner.unary(req, path, codec).await
+        }
+        pub async fn get_uctovnictvo_count(
+            &mut self,
+            request: impl tonic::IntoRequest<super::super::common::Empty>,
+        ) -> std::result::Result<
+            tonic::Response<super::super::common::CountResponse>,
+            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(
+                "/KompAC.uctovnictvo.Uctovnictvo/GetUctovnictvoCount",
+            );
+            let mut req = request.into_request();
+            req.extensions_mut()
+                .insert(
+                    GrpcMethod::new(
+                        "KompAC.uctovnictvo.Uctovnictvo",
+                        "GetUctovnictvoCount",
+                    ),
+                );
+            self.inner.unary(req, path, codec).await
+        }
+        pub async fn get_uctovnictvo_by_position(
+            &mut self,
+            request: impl tonic::IntoRequest<super::super::common::PositionRequest>,
+        ) -> std::result::Result<
+            tonic::Response<super::UctovnictvoResponse>,
+            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(
+                "/KompAC.uctovnictvo.Uctovnictvo/GetUctovnictvoByPosition",
+            );
+            let mut req = request.into_request();
+            req.extensions_mut()
+                .insert(
+                    GrpcMethod::new(
+                        "KompAC.uctovnictvo.Uctovnictvo",
+                        "GetUctovnictvoByPosition",
+                    ),
+                );
+            self.inner.unary(req, path, codec).await
+        }
+        pub async fn put_uctovnictvo(
+            &mut self,
+            request: impl tonic::IntoRequest<super::PutUctovnictvoRequest>,
+        ) -> std::result::Result<
+            tonic::Response<super::UctovnictvoResponse>,
+            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(
+                "/KompAC.uctovnictvo.Uctovnictvo/PutUctovnictvo",
+            );
+            let mut req = request.into_request();
+            req.extensions_mut()
+                .insert(
+                    GrpcMethod::new("KompAC.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<super::PostUctovnictvoRequest>,
+        ) -> std::result::Result<
+            tonic::Response<super::UctovnictvoResponse>,
+            tonic::Status,
+        >;
+        async fn get_uctovnictvo(
+            &self,
+            request: tonic::Request<super::GetUctovnictvoRequest>,
+        ) -> std::result::Result<
+            tonic::Response<super::UctovnictvoResponse>,
+            tonic::Status,
+        >;
+        async fn get_uctovnictvo_count(
+            &self,
+            request: tonic::Request<super::super::common::Empty>,
+        ) -> std::result::Result<
+            tonic::Response<super::super::common::CountResponse>,
+            tonic::Status,
+        >;
+        async fn get_uctovnictvo_by_position(
+            &self,
+            request: tonic::Request<super::super::common::PositionRequest>,
+        ) -> std::result::Result<
+            tonic::Response<super::UctovnictvoResponse>,
+            tonic::Status,
+        >;
+        async fn put_uctovnictvo(
+            &self,
+            request: tonic::Request<super::PutUctovnictvoRequest>,
+        ) -> std::result::Result<
+            tonic::Response<super::UctovnictvoResponse>,
+            tonic::Status,
+        >;
+    }
+    #[derive(Debug)]
+    pub struct UctovnictvoServer<T> {
+        inner: Arc<T>,
+        accept_compression_encodings: EnabledCompressionEncodings,
+        send_compression_encodings: EnabledCompressionEncodings,
+        max_decoding_message_size: Option<usize>,
+        max_encoding_message_size: Option<usize>,
+    }
+    impl<T> UctovnictvoServer<T> {
+        pub fn new(inner: T) -> Self {
+            Self::from_arc(Arc::new(inner))
+        }
+        pub fn from_arc(inner: Arc<T>) -> 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<F>(
+            inner: T,
+            interceptor: F,
+        ) -> InterceptedService<Self, F>
+        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<T, B> tonic::codegen::Service<http::Request<B>> for UctovnictvoServer<T>
+    where
+        T: Uctovnictvo,
+        B: Body + std::marker::Send + 'static,
+        B::Error: Into<StdError> + std::marker::Send + 'static,
+    {
+        type Response = http::Response<tonic::body::Body>;
+        type Error = std::convert::Infallible;
+        type Future = BoxFuture<Self::Response, Self::Error>;
+        fn poll_ready(
+            &mut self,
+            _cx: &mut Context<'_>,
+        ) -> Poll<std::result::Result<(), Self::Error>> {
+            Poll::Ready(Ok(()))
+        }
+        fn call(&mut self, req: http::Request<B>) -> Self::Future {
+            match req.uri().path() {
+                "/KompAC.uctovnictvo.Uctovnictvo/PostUctovnictvo" => {
+                    #[allow(non_camel_case_types)]
+                    struct PostUctovnictvoSvc<T: Uctovnictvo>(pub Arc<T>);
+                    impl<
+                        T: Uctovnictvo,
+                    > tonic::server::UnaryService<super::PostUctovnictvoRequest>
+                    for PostUctovnictvoSvc<T> {
+                        type Response = super::UctovnictvoResponse;
+                        type Future = BoxFuture<
+                            tonic::Response<Self::Response>,
+                            tonic::Status,
+                        >;
+                        fn call(
+                            &mut self,
+                            request: tonic::Request<super::PostUctovnictvoRequest>,
+                        ) -> Self::Future {
+                            let inner = Arc::clone(&self.0);
+                            let fut = async move {
+                                <T as Uctovnictvo>::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)
+                }
+                "/KompAC.uctovnictvo.Uctovnictvo/GetUctovnictvo" => {
+                    #[allow(non_camel_case_types)]
+                    struct GetUctovnictvoSvc<T: Uctovnictvo>(pub Arc<T>);
+                    impl<
+                        T: Uctovnictvo,
+                    > tonic::server::UnaryService<super::GetUctovnictvoRequest>
+                    for GetUctovnictvoSvc<T> {
+                        type Response = super::UctovnictvoResponse;
+                        type Future = BoxFuture<
+                            tonic::Response<Self::Response>,
+                            tonic::Status,
+                        >;
+                        fn call(
+                            &mut self,
+                            request: tonic::Request<super::GetUctovnictvoRequest>,
+                        ) -> Self::Future {
+                            let inner = Arc::clone(&self.0);
+                            let fut = async move {
+                                <T as Uctovnictvo>::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)
+                }
+                "/KompAC.uctovnictvo.Uctovnictvo/GetUctovnictvoCount" => {
+                    #[allow(non_camel_case_types)]
+                    struct GetUctovnictvoCountSvc<T: Uctovnictvo>(pub Arc<T>);
+                    impl<
+                        T: Uctovnictvo,
+                    > tonic::server::UnaryService<super::super::common::Empty>
+                    for GetUctovnictvoCountSvc<T> {
+                        type Response = super::super::common::CountResponse;
+                        type Future = BoxFuture<
+                            tonic::Response<Self::Response>,
+                            tonic::Status,
+                        >;
+                        fn call(
+                            &mut self,
+                            request: tonic::Request<super::super::common::Empty>,
+                        ) -> Self::Future {
+                            let inner = Arc::clone(&self.0);
+                            let fut = async move {
+                                <T as Uctovnictvo>::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)
+                }
+                "/KompAC.uctovnictvo.Uctovnictvo/GetUctovnictvoByPosition" => {
+                    #[allow(non_camel_case_types)]
+                    struct GetUctovnictvoByPositionSvc<T: Uctovnictvo>(pub Arc<T>);
+                    impl<
+                        T: Uctovnictvo,
+                    > tonic::server::UnaryService<super::super::common::PositionRequest>
+                    for GetUctovnictvoByPositionSvc<T> {
+                        type Response = super::UctovnictvoResponse;
+                        type Future = BoxFuture<
+                            tonic::Response<Self::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 {
+                                <T as Uctovnictvo>::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)
+                }
+                "/KompAC.uctovnictvo.Uctovnictvo/PutUctovnictvo" => {
+                    #[allow(non_camel_case_types)]
+                    struct PutUctovnictvoSvc<T: Uctovnictvo>(pub Arc<T>);
+                    impl<
+                        T: Uctovnictvo,
+                    > tonic::server::UnaryService<super::PutUctovnictvoRequest>
+                    for PutUctovnictvoSvc<T> {
+                        type Response = super::UctovnictvoResponse;
+                        type Future = BoxFuture<
+                            tonic::Response<Self::Response>,
+                            tonic::Status,
+                        >;
+                        fn call(
+                            &mut self,
+                            request: tonic::Request<super::PutUctovnictvoRequest>,
+                        ) -> Self::Future {
+                            let inner = Arc::clone(&self.0);
+                            let fut = async move {
+                                <T as Uctovnictvo>::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(
+                            tonic::body::Body::default(),
+                        );
+                        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<T> Clone for UctovnictvoServer<T> {
+        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 = "KompAC.uctovnictvo.Uctovnictvo";
+    impl<T> tonic::server::NamedService for UctovnictvoServer<T> {
+        const NAME: &'static str = SERVICE_NAME;
+    }
+}

common/src/proto/multieko2.adresar.rs

@@ -225,11 +225,11 @@ pub mod adresar_client {
                 })?;
             let codec = tonic::codec::ProstCodec::default();
             let path = http::uri::PathAndQuery::from_static(
-                "/multieko2.adresar.Adresar/PostAdresar",
+                "/KompAC.adresar.Adresar/PostAdresar",
             );
             let mut req = request.into_request();
             req.extensions_mut()
-                .insert(GrpcMethod::new("multieko2.adresar.Adresar", "PostAdresar"));
+                .insert(GrpcMethod::new("KompAC.adresar.Adresar", "PostAdresar"));
             self.inner.unary(req, path, codec).await
         }
         pub async fn get_adresar(
@@ -249,11 +249,11 @@ pub mod adresar_client {
                 })?;
             let codec = tonic::codec::ProstCodec::default();
             let path = http::uri::PathAndQuery::from_static(
-                "/multieko2.adresar.Adresar/GetAdresar",
+                "/KompAC.adresar.Adresar/GetAdresar",
             );
             let mut req = request.into_request();
             req.extensions_mut()
-                .insert(GrpcMethod::new("multieko2.adresar.Adresar", "GetAdresar"));
+                .insert(GrpcMethod::new("KompAC.adresar.Adresar", "GetAdresar"));
             self.inner.unary(req, path, codec).await
         }
         pub async fn put_adresar(
@@ -273,11 +273,11 @@ pub mod adresar_client {
                 })?;
             let codec = tonic::codec::ProstCodec::default();
             let path = http::uri::PathAndQuery::from_static(
-                "/multieko2.adresar.Adresar/PutAdresar",
+                "/KompAC.adresar.Adresar/PutAdresar",
             );
             let mut req = request.into_request();
             req.extensions_mut()
-                .insert(GrpcMethod::new("multieko2.adresar.Adresar", "PutAdresar"));
+                .insert(GrpcMethod::new("KompAC.adresar.Adresar", "PutAdresar"));
             self.inner.unary(req, path, codec).await
         }
         pub async fn delete_adresar(
@@ -297,11 +297,11 @@ pub mod adresar_client {
                 })?;
             let codec = tonic::codec::ProstCodec::default();
             let path = http::uri::PathAndQuery::from_static(
-                "/multieko2.adresar.Adresar/DeleteAdresar",
+                "/KompAC.adresar.Adresar/DeleteAdresar",
             );
             let mut req = request.into_request();
             req.extensions_mut()
-                .insert(GrpcMethod::new("multieko2.adresar.Adresar", "DeleteAdresar"));
+                .insert(GrpcMethod::new("KompAC.adresar.Adresar", "DeleteAdresar"));
             self.inner.unary(req, path, codec).await
         }
         pub async fn get_adresar_count(
@@ -321,11 +321,11 @@ pub mod adresar_client {
                 })?;
             let codec = tonic::codec::ProstCodec::default();
             let path = http::uri::PathAndQuery::from_static(
-                "/multieko2.adresar.Adresar/GetAdresarCount",
+                "/KompAC.adresar.Adresar/GetAdresarCount",
             );
             let mut req = request.into_request();
             req.extensions_mut()
-                .insert(GrpcMethod::new("multieko2.adresar.Adresar", "GetAdresarCount"));
+                .insert(GrpcMethod::new("KompAC.adresar.Adresar", "GetAdresarCount"));
             self.inner.unary(req, path, codec).await
         }
         pub async fn get_adresar_by_position(
@@ -345,12 +345,12 @@ pub mod adresar_client {
                 })?;
             let codec = tonic::codec::ProstCodec::default();
             let path = http::uri::PathAndQuery::from_static(
-                "/multieko2.adresar.Adresar/GetAdresarByPosition",
+                "/KompAC.adresar.Adresar/GetAdresarByPosition",
             );
             let mut req = request.into_request();
             req.extensions_mut()
                 .insert(
-                    GrpcMethod::new("multieko2.adresar.Adresar", "GetAdresarByPosition"),
+                    GrpcMethod::new("KompAC.adresar.Adresar", "GetAdresarByPosition"),
                 );
             self.inner.unary(req, path, codec).await
         }
@@ -476,7 +476,7 @@ pub mod adresar_server {
         }
         fn call(&mut self, req: http::Request<B>) -> Self::Future {
             match req.uri().path() {
-                "/multieko2.adresar.Adresar/PostAdresar" => {
+                "/KompAC.adresar.Adresar/PostAdresar" => {
                     #[allow(non_camel_case_types)]
                     struct PostAdresarSvc<T: Adresar>(pub Arc<T>);
                     impl<
@@ -521,7 +521,7 @@ pub mod adresar_server {
                     };
                     Box::pin(fut)
                 }
-                "/multieko2.adresar.Adresar/GetAdresar" => {
+                "/KompAC.adresar.Adresar/GetAdresar" => {
                     #[allow(non_camel_case_types)]
                     struct GetAdresarSvc<T: Adresar>(pub Arc<T>);
                     impl<
@@ -566,7 +566,7 @@ pub mod adresar_server {
                     };
                     Box::pin(fut)
                 }
-                "/multieko2.adresar.Adresar/PutAdresar" => {
+                "/KompAC.adresar.Adresar/PutAdresar" => {
                     #[allow(non_camel_case_types)]
                     struct PutAdresarSvc<T: Adresar>(pub Arc<T>);
                     impl<
@@ -611,7 +611,7 @@ pub mod adresar_server {
                     };
                     Box::pin(fut)
                 }
-                "/multieko2.adresar.Adresar/DeleteAdresar" => {
+                "/KompAC.adresar.Adresar/DeleteAdresar" => {
                     #[allow(non_camel_case_types)]
                     struct DeleteAdresarSvc<T: Adresar>(pub Arc<T>);
                     impl<
@@ -656,7 +656,7 @@ pub mod adresar_server {
                     };
                     Box::pin(fut)
                 }
-                "/multieko2.adresar.Adresar/GetAdresarCount" => {
+                "/KompAC.adresar.Adresar/GetAdresarCount" => {
                     #[allow(non_camel_case_types)]
                     struct GetAdresarCountSvc<T: Adresar>(pub Arc<T>);
                     impl<
@@ -701,7 +701,7 @@ pub mod adresar_server {
                     };
                     Box::pin(fut)
                 }
-                "/multieko2.adresar.Adresar/GetAdresarByPosition" => {
+                "/KompAC.adresar.Adresar/GetAdresarByPosition" => {
                     #[allow(non_camel_case_types)]
                     struct GetAdresarByPositionSvc<T: Adresar>(pub Arc<T>);
                     impl<
@@ -784,7 +784,7 @@ pub mod adresar_server {
         }
     }
     /// Generated gRPC service name
-    pub const SERVICE_NAME: &str = "multieko2.adresar.Adresar";
+    pub const SERVICE_NAME: &str = "KompAC.adresar.Adresar";
     impl<T> tonic::server::NamedService for AdresarServer<T> {
         const NAME: &'static str = SERVICE_NAME;
     }

common/src/proto/multieko2.auth.rs

@@ -160,11 +160,11 @@ pub mod auth_service_client {
                 })?;
             let codec = tonic::codec::ProstCodec::default();
             let path = http::uri::PathAndQuery::from_static(
-                "/multieko2.auth.AuthService/Register",
+                "/KompAC.auth.AuthService/Register",
             );
             let mut req = request.into_request();
             req.extensions_mut()
-                .insert(GrpcMethod::new("multieko2.auth.AuthService", "Register"));
+                .insert(GrpcMethod::new("KompAC.auth.AuthService", "Register"));
             self.inner.unary(req, path, codec).await
         }
         pub async fn login(
@@ -181,11 +181,11 @@ pub mod auth_service_client {
                 })?;
             let codec = tonic::codec::ProstCodec::default();
             let path = http::uri::PathAndQuery::from_static(
-                "/multieko2.auth.AuthService/Login",
+                "/KompAC.auth.AuthService/Login",
             );
             let mut req = request.into_request();
             req.extensions_mut()
-                .insert(GrpcMethod::new("multieko2.auth.AuthService", "Login"));
+                .insert(GrpcMethod::new("KompAC.auth.AuthService", "Login"));
             self.inner.unary(req, path, codec).await
         }
     }
@@ -288,7 +288,7 @@ pub mod auth_service_server {
         }
         fn call(&mut self, req: http::Request<B>) -> Self::Future {
             match req.uri().path() {
-                "/multieko2.auth.AuthService/Register" => {
+                "/KompAC.auth.AuthService/Register" => {
                     #[allow(non_camel_case_types)]
                     struct RegisterSvc<T: AuthService>(pub Arc<T>);
                     impl<
@@ -333,7 +333,7 @@ pub mod auth_service_server {
                     };
                     Box::pin(fut)
                 }
-                "/multieko2.auth.AuthService/Login" => {
+                "/KompAC.auth.AuthService/Login" => {
                     #[allow(non_camel_case_types)]
                     struct LoginSvc<T: AuthService>(pub Arc<T>);
                     impl<T: AuthService> tonic::server::UnaryService<super::LoginRequest>
@@ -411,7 +411,7 @@ pub mod auth_service_server {
         }
     }
     /// Generated gRPC service name
-    pub const SERVICE_NAME: &str = "multieko2.auth.AuthService";
+    pub const SERVICE_NAME: &str = "KompAC.auth.AuthService";
     impl<T> tonic::server::NamedService for AuthServiceServer<T> {
         const NAME: &'static str = SERVICE_NAME;
     }

common/src/proto/multieko2.search.rs

@@ -129,11 +129,11 @@ pub mod searcher_client {
                 })?;
             let codec = tonic::codec::ProstCodec::default();
             let path = http::uri::PathAndQuery::from_static(
-                "/multieko2.search.Searcher/SearchTable",
+                "/KompAC.search.Searcher/SearchTable",
             );
             let mut req = request.into_request();
             req.extensions_mut()
-                .insert(GrpcMethod::new("multieko2.search.Searcher", "SearchTable"));
+                .insert(GrpcMethod::new("KompAC.search.Searcher", "SearchTable"));
             self.inner.unary(req, path, codec).await
         }
     }
@@ -232,7 +232,7 @@ pub mod searcher_server {
         }
         fn call(&mut self, req: http::Request<B>) -> Self::Future {
             match req.uri().path() {
-                "/multieko2.search.Searcher/SearchTable" => {
+                "/KompAC.search.Searcher/SearchTable" => {
                     #[allow(non_camel_case_types)]
                     struct SearchTableSvc<T: Searcher>(pub Arc<T>);
                     impl<T: Searcher> tonic::server::UnaryService<super::SearchRequest>
@@ -310,7 +310,7 @@ pub mod searcher_server {
         }
     }
     /// Generated gRPC service name
-    pub const SERVICE_NAME: &str = "multieko2.search.Searcher";
+    pub const SERVICE_NAME: &str = "KompAC.search.Searcher";
     impl<T> tonic::server::NamedService for SearcherServer<T> {
         const NAME: &'static str = SERVICE_NAME;
     }

common/src/proto/multieko2.table_definition.rs

@@ -179,13 +179,13 @@ pub mod table_definition_client {
                 })?;
             let codec = tonic::codec::ProstCodec::default();
             let path = http::uri::PathAndQuery::from_static(
-                "/multieko2.table_definition.TableDefinition/PostTableDefinition",
+                "/KompAC.table_definition.TableDefinition/PostTableDefinition",
             );
             let mut req = request.into_request();
             req.extensions_mut()
                 .insert(
                     GrpcMethod::new(
-                        "multieko2.table_definition.TableDefinition",
+                        "KompAC.table_definition.TableDefinition",
                         "PostTableDefinition",
                     ),
                 );
@@ -208,13 +208,13 @@ pub mod table_definition_client {
                 })?;
             let codec = tonic::codec::ProstCodec::default();
             let path = http::uri::PathAndQuery::from_static(
-                "/multieko2.table_definition.TableDefinition/GetProfileTree",
+                "/KompAC.table_definition.TableDefinition/GetProfileTree",
             );
             let mut req = request.into_request();
             req.extensions_mut()
                 .insert(
                     GrpcMethod::new(
-                        "multieko2.table_definition.TableDefinition",
+                        "KompAC.table_definition.TableDefinition",
                         "GetProfileTree",
                     ),
                 );
@@ -237,13 +237,13 @@ pub mod table_definition_client {
                 })?;
             let codec = tonic::codec::ProstCodec::default();
             let path = http::uri::PathAndQuery::from_static(
-                "/multieko2.table_definition.TableDefinition/DeleteTable",
+                "/KompAC.table_definition.TableDefinition/DeleteTable",
             );
             let mut req = request.into_request();
             req.extensions_mut()
                 .insert(
                     GrpcMethod::new(
-                        "multieko2.table_definition.TableDefinition",
+                        "KompAC.table_definition.TableDefinition",
                         "DeleteTable",
                     ),
                 );
@@ -362,7 +362,7 @@ pub mod table_definition_server {
         }
         fn call(&mut self, req: http::Request<B>) -> Self::Future {
             match req.uri().path() {
-                "/multieko2.table_definition.TableDefinition/PostTableDefinition" => {
+                "/KompAC.table_definition.TableDefinition/PostTableDefinition" => {
                     #[allow(non_camel_case_types)]
                     struct PostTableDefinitionSvc<T: TableDefinition>(pub Arc<T>);
                     impl<
@@ -411,7 +411,7 @@ pub mod table_definition_server {
                     };
                     Box::pin(fut)
                 }
-                "/multieko2.table_definition.TableDefinition/GetProfileTree" => {
+                "/KompAC.table_definition.TableDefinition/GetProfileTree" => {
                     #[allow(non_camel_case_types)]
                     struct GetProfileTreeSvc<T: TableDefinition>(pub Arc<T>);
                     impl<
@@ -457,7 +457,7 @@ pub mod table_definition_server {
                     };
                     Box::pin(fut)
                 }
-                "/multieko2.table_definition.TableDefinition/DeleteTable" => {
+                "/KompAC.table_definition.TableDefinition/DeleteTable" => {
                     #[allow(non_camel_case_types)]
                     struct DeleteTableSvc<T: TableDefinition>(pub Arc<T>);
                     impl<
@@ -537,7 +537,7 @@ pub mod table_definition_server {
         }
     }
     /// Generated gRPC service name
-    pub const SERVICE_NAME: &str = "multieko2.table_definition.TableDefinition";
+    pub const SERVICE_NAME: &str = "KompAC.table_definition.TableDefinition";
     impl<T> tonic::server::NamedService for TableDefinitionServer<T> {
         const NAME: &'static str = SERVICE_NAME;
     }

common/src/proto/multieko2.table_script.rs

@@ -125,13 +125,13 @@ pub mod table_script_client {
                 })?;
             let codec = tonic::codec::ProstCodec::default();
             let path = http::uri::PathAndQuery::from_static(
-                "/multieko2.table_script.TableScript/PostTableScript",
+                "/KompAC.table_script.TableScript/PostTableScript",
             );
             let mut req = request.into_request();
             req.extensions_mut()
                 .insert(
                     GrpcMethod::new(
-                        "multieko2.table_script.TableScript",
+                        "KompAC.table_script.TableScript",
                         "PostTableScript",
                     ),
                 );
@@ -236,7 +236,7 @@ pub mod table_script_server {
         }
         fn call(&mut self, req: http::Request<B>) -> Self::Future {
             match req.uri().path() {
-                "/multieko2.table_script.TableScript/PostTableScript" => {
+                "/KompAC.table_script.TableScript/PostTableScript" => {
                     #[allow(non_camel_case_types)]
                     struct PostTableScriptSvc<T: TableScript>(pub Arc<T>);
                     impl<
@@ -316,7 +316,7 @@ pub mod table_script_server {
         }
     }
     /// Generated gRPC service name
-    pub const SERVICE_NAME: &str = "multieko2.table_script.TableScript";
+    pub const SERVICE_NAME: &str = "KompAC.table_script.TableScript";
     impl<T> tonic::server::NamedService for TableScriptServer<T> {
         const NAME: &'static str = SERVICE_NAME;
     }

common/src/proto/multieko2.table_structure.rs

@@ -133,13 +133,13 @@ pub mod table_structure_service_client {
                 })?;
             let codec = tonic::codec::ProstCodec::default();
             let path = http::uri::PathAndQuery::from_static(
-                "/multieko2.table_structure.TableStructureService/GetTableStructure",
+                "/KompAC.table_structure.TableStructureService/GetTableStructure",
             );
             let mut req = request.into_request();
             req.extensions_mut()
                 .insert(
                     GrpcMethod::new(
-                        "multieko2.table_structure.TableStructureService",
+                        "KompAC.table_structure.TableStructureService",
                         "GetTableStructure",
                     ),
                 );
@@ -245,7 +245,7 @@ pub mod table_structure_service_server {
         }
         fn call(&mut self, req: http::Request<B>) -> Self::Future {
             match req.uri().path() {
-                "/multieko2.table_structure.TableStructureService/GetTableStructure" => {
+                "/KompAC.table_structure.TableStructureService/GetTableStructure" => {
                     #[allow(non_camel_case_types)]
                     struct GetTableStructureSvc<T: TableStructureService>(pub Arc<T>);
                     impl<
@@ -329,7 +329,7 @@ pub mod table_structure_service_server {
         }
     }
     /// Generated gRPC service name
-    pub const SERVICE_NAME: &str = "multieko2.table_structure.TableStructureService";
+    pub const SERVICE_NAME: &str = "KompAC.table_structure.TableStructureService";
     impl<T> tonic::server::NamedService for TableStructureServiceServer<T> {
         const NAME: &'static str = SERVICE_NAME;
     }

common/src/proto/multieko2.tables_data.rs

@@ -198,12 +198,12 @@ pub mod tables_data_client {
                 })?;
             let codec = tonic::codec::ProstCodec::default();
             let path = http::uri::PathAndQuery::from_static(
-                "/multieko2.tables_data.TablesData/PostTableData",
+                "/KompAC.tables_data.TablesData/PostTableData",
             );
             let mut req = request.into_request();
             req.extensions_mut()
                 .insert(
-                    GrpcMethod::new("multieko2.tables_data.TablesData", "PostTableData"),
+                    GrpcMethod::new("KompAC.tables_data.TablesData", "PostTableData"),
                 );
             self.inner.unary(req, path, codec).await
         }
@@ -224,12 +224,12 @@ pub mod tables_data_client {
                 })?;
             let codec = tonic::codec::ProstCodec::default();
             let path = http::uri::PathAndQuery::from_static(
-                "/multieko2.tables_data.TablesData/PutTableData",
+                "/KompAC.tables_data.TablesData/PutTableData",
             );
             let mut req = request.into_request();
             req.extensions_mut()
                 .insert(
-                    GrpcMethod::new("multieko2.tables_data.TablesData", "PutTableData"),
+                    GrpcMethod::new("KompAC.tables_data.TablesData", "PutTableData"),
                 );
             self.inner.unary(req, path, codec).await
         }
@@ -250,13 +250,13 @@ pub mod tables_data_client {
                 })?;
             let codec = tonic::codec::ProstCodec::default();
             let path = http::uri::PathAndQuery::from_static(
-                "/multieko2.tables_data.TablesData/DeleteTableData",
+                "/KompAC.tables_data.TablesData/DeleteTableData",
             );
             let mut req = request.into_request();
             req.extensions_mut()
                 .insert(
                     GrpcMethod::new(
-                        "multieko2.tables_data.TablesData",
+                        "KompAC.tables_data.TablesData",
                         "DeleteTableData",
                     ),
                 );
@@ -279,12 +279,12 @@ pub mod tables_data_client {
                 })?;
             let codec = tonic::codec::ProstCodec::default();
             let path = http::uri::PathAndQuery::from_static(
-                "/multieko2.tables_data.TablesData/GetTableData",
+                "/KompAC.tables_data.TablesData/GetTableData",
             );
             let mut req = request.into_request();
             req.extensions_mut()
                 .insert(
-                    GrpcMethod::new("multieko2.tables_data.TablesData", "GetTableData"),
+                    GrpcMethod::new("KompAC.tables_data.TablesData", "GetTableData"),
                 );
             self.inner.unary(req, path, codec).await
         }
@@ -305,13 +305,13 @@ pub mod tables_data_client {
                 })?;
             let codec = tonic::codec::ProstCodec::default();
             let path = http::uri::PathAndQuery::from_static(
-                "/multieko2.tables_data.TablesData/GetTableDataCount",
+                "/KompAC.tables_data.TablesData/GetTableDataCount",
             );
             let mut req = request.into_request();
             req.extensions_mut()
                 .insert(
                     GrpcMethod::new(
-                        "multieko2.tables_data.TablesData",
+                        "KompAC.tables_data.TablesData",
                         "GetTableDataCount",
                     ),
                 );
@@ -334,13 +334,13 @@ pub mod tables_data_client {
                 })?;
             let codec = tonic::codec::ProstCodec::default();
             let path = http::uri::PathAndQuery::from_static(
-                "/multieko2.tables_data.TablesData/GetTableDataByPosition",
+                "/KompAC.tables_data.TablesData/GetTableDataByPosition",
             );
             let mut req = request.into_request();
             req.extensions_mut()
                 .insert(
                     GrpcMethod::new(
-                        "multieko2.tables_data.TablesData",
+                        "KompAC.tables_data.TablesData",
                         "GetTableDataByPosition",
                     ),
                 );
@@ -480,7 +480,7 @@ pub mod tables_data_server {
         }
         fn call(&mut self, req: http::Request<B>) -> Self::Future {
             match req.uri().path() {
-                "/multieko2.tables_data.TablesData/PostTableData" => {
+                "/KompAC.tables_data.TablesData/PostTableData" => {
                     #[allow(non_camel_case_types)]
                     struct PostTableDataSvc<T: TablesData>(pub Arc<T>);
                     impl<
@@ -525,7 +525,7 @@ pub mod tables_data_server {
                     };
                     Box::pin(fut)
                 }
-                "/multieko2.tables_data.TablesData/PutTableData" => {
+                "/KompAC.tables_data.TablesData/PutTableData" => {
                     #[allow(non_camel_case_types)]
                     struct PutTableDataSvc<T: TablesData>(pub Arc<T>);
                     impl<
@@ -570,7 +570,7 @@ pub mod tables_data_server {
                     };
                     Box::pin(fut)
                 }
-                "/multieko2.tables_data.TablesData/DeleteTableData" => {
+                "/KompAC.tables_data.TablesData/DeleteTableData" => {
                     #[allow(non_camel_case_types)]
                     struct DeleteTableDataSvc<T: TablesData>(pub Arc<T>);
                     impl<
@@ -615,7 +615,7 @@ pub mod tables_data_server {
                     };
                     Box::pin(fut)
                 }
-                "/multieko2.tables_data.TablesData/GetTableData" => {
+                "/KompAC.tables_data.TablesData/GetTableData" => {
                     #[allow(non_camel_case_types)]
                     struct GetTableDataSvc<T: TablesData>(pub Arc<T>);
                     impl<
@@ -660,7 +660,7 @@ pub mod tables_data_server {
                     };
                     Box::pin(fut)
                 }
-                "/multieko2.tables_data.TablesData/GetTableDataCount" => {
+                "/KompAC.tables_data.TablesData/GetTableDataCount" => {
                     #[allow(non_camel_case_types)]
                     struct GetTableDataCountSvc<T: TablesData>(pub Arc<T>);
                     impl<
@@ -706,7 +706,7 @@ pub mod tables_data_server {
                     };
                     Box::pin(fut)
                 }
-                "/multieko2.tables_data.TablesData/GetTableDataByPosition" => {
+                "/KompAC.tables_data.TablesData/GetTableDataByPosition" => {
                     #[allow(non_camel_case_types)]
                     struct GetTableDataByPositionSvc<T: TablesData>(pub Arc<T>);
                     impl<
@@ -790,7 +790,7 @@ pub mod tables_data_server {
         }
     }
     /// Generated gRPC service name
-    pub const SERVICE_NAME: &str = "multieko2.tables_data.TablesData";
+    pub const SERVICE_NAME: &str = "KompAC.tables_data.TablesData";
     impl<T> tonic::server::NamedService for TablesDataServer<T> {
         const NAME: &'static str = SERVICE_NAME;
     }

common/src/proto/multieko2.uctovnictvo.rs

@@ -192,13 +192,13 @@ pub mod uctovnictvo_client {
                 })?;
             let codec = tonic::codec::ProstCodec::default();
             let path = http::uri::PathAndQuery::from_static(
-                "/multieko2.uctovnictvo.Uctovnictvo/PostUctovnictvo",
+                "/KompAC.uctovnictvo.Uctovnictvo/PostUctovnictvo",
             );
             let mut req = request.into_request();
             req.extensions_mut()
                 .insert(
                     GrpcMethod::new(
-                        "multieko2.uctovnictvo.Uctovnictvo",
+                        "KompAC.uctovnictvo.Uctovnictvo",
                         "PostUctovnictvo",
                     ),
                 );
@@ -221,13 +221,13 @@ pub mod uctovnictvo_client {
                 })?;
             let codec = tonic::codec::ProstCodec::default();
             let path = http::uri::PathAndQuery::from_static(
-                "/multieko2.uctovnictvo.Uctovnictvo/GetUctovnictvo",
+                "/KompAC.uctovnictvo.Uctovnictvo/GetUctovnictvo",
             );
             let mut req = request.into_request();
             req.extensions_mut()
                 .insert(
                     GrpcMethod::new(
-                        "multieko2.uctovnictvo.Uctovnictvo",
+                        "KompAC.uctovnictvo.Uctovnictvo",
                         "GetUctovnictvo",
                     ),
                 );
@@ -250,13 +250,13 @@ pub mod uctovnictvo_client {
                 })?;
             let codec = tonic::codec::ProstCodec::default();
             let path = http::uri::PathAndQuery::from_static(
-                "/multieko2.uctovnictvo.Uctovnictvo/GetUctovnictvoCount",
+                "/KompAC.uctovnictvo.Uctovnictvo/GetUctovnictvoCount",
             );
             let mut req = request.into_request();
             req.extensions_mut()
                 .insert(
                     GrpcMethod::new(
-                        "multieko2.uctovnictvo.Uctovnictvo",
+                        "KompAC.uctovnictvo.Uctovnictvo",
                         "GetUctovnictvoCount",
                     ),
                 );
@@ -279,13 +279,13 @@ pub mod uctovnictvo_client {
                 })?;
             let codec = tonic::codec::ProstCodec::default();
             let path = http::uri::PathAndQuery::from_static(
-                "/multieko2.uctovnictvo.Uctovnictvo/GetUctovnictvoByPosition",
+                "/KompAC.uctovnictvo.Uctovnictvo/GetUctovnictvoByPosition",
             );
             let mut req = request.into_request();
             req.extensions_mut()
                 .insert(
                     GrpcMethod::new(
-                        "multieko2.uctovnictvo.Uctovnictvo",
+                        "KompAC.uctovnictvo.Uctovnictvo",
                         "GetUctovnictvoByPosition",
                     ),
                 );
@@ -308,13 +308,13 @@ pub mod uctovnictvo_client {
                 })?;
             let codec = tonic::codec::ProstCodec::default();
             let path = http::uri::PathAndQuery::from_static(
-                "/multieko2.uctovnictvo.Uctovnictvo/PutUctovnictvo",
+                "/KompAC.uctovnictvo.Uctovnictvo/PutUctovnictvo",
             );
             let mut req = request.into_request();
             req.extensions_mut()
                 .insert(
                     GrpcMethod::new(
-                        "multieko2.uctovnictvo.Uctovnictvo",
+                        "KompAC.uctovnictvo.Uctovnictvo",
                         "PutUctovnictvo",
                     ),
                 );
@@ -447,7 +447,7 @@ pub mod uctovnictvo_server {
         }
         fn call(&mut self, req: http::Request<B>) -> Self::Future {
             match req.uri().path() {
-                "/multieko2.uctovnictvo.Uctovnictvo/PostUctovnictvo" => {
+                "/KompAC.uctovnictvo.Uctovnictvo/PostUctovnictvo" => {
                     #[allow(non_camel_case_types)]
                     struct PostUctovnictvoSvc<T: Uctovnictvo>(pub Arc<T>);
                     impl<
@@ -492,7 +492,7 @@ pub mod uctovnictvo_server {
                     };
                     Box::pin(fut)
                 }
-                "/multieko2.uctovnictvo.Uctovnictvo/GetUctovnictvo" => {
+                "/KompAC.uctovnictvo.Uctovnictvo/GetUctovnictvo" => {
                     #[allow(non_camel_case_types)]
                     struct GetUctovnictvoSvc<T: Uctovnictvo>(pub Arc<T>);
                     impl<
@@ -537,7 +537,7 @@ pub mod uctovnictvo_server {
                     };
                     Box::pin(fut)
                 }
-                "/multieko2.uctovnictvo.Uctovnictvo/GetUctovnictvoCount" => {
+                "/KompAC.uctovnictvo.Uctovnictvo/GetUctovnictvoCount" => {
                     #[allow(non_camel_case_types)]
                     struct GetUctovnictvoCountSvc<T: Uctovnictvo>(pub Arc<T>);
                     impl<
@@ -583,7 +583,7 @@ pub mod uctovnictvo_server {
                     };
                     Box::pin(fut)
                 }
-                "/multieko2.uctovnictvo.Uctovnictvo/GetUctovnictvoByPosition" => {
+                "/KompAC.uctovnictvo.Uctovnictvo/GetUctovnictvoByPosition" => {
                     #[allow(non_camel_case_types)]
                     struct GetUctovnictvoByPositionSvc<T: Uctovnictvo>(pub Arc<T>);
                     impl<
@@ -634,7 +634,7 @@ pub mod uctovnictvo_server {
                     };
                     Box::pin(fut)
                 }
-                "/multieko2.uctovnictvo.Uctovnictvo/PutUctovnictvo" => {
+                "/KompAC.uctovnictvo.Uctovnictvo/PutUctovnictvo" => {
                     #[allow(non_camel_case_types)]
                     struct PutUctovnictvoSvc<T: Uctovnictvo>(pub Arc<T>);
                     impl<
@@ -714,7 +714,7 @@ pub mod uctovnictvo_server {
         }
     }
     /// Generated gRPC service name
-    pub const SERVICE_NAME: &str = "multieko2.uctovnictvo.Uctovnictvo";
+    pub const SERVICE_NAME: &str = "KompAC.uctovnictvo.Uctovnictvo";
     impl<T> tonic::server::NamedService for UctovnictvoServer<T> {
         const NAME: &'static str = SERVICE_NAME;
     }

search/src/lib.rs

@@ -11,11 +11,11 @@ use tantivy::schema::{IndexRecordOption, Value};
 use tantivy::{Index, TantivyDocument, Term};
 use tonic::{Request, Response, Status};
 
-use common::proto::multieko2::search::{
+use common::proto::KompAC::search::{
     search_response::Hit, SearchRequest, SearchResponse,
 };
-pub use common::proto::multieko2::search::searcher_server::SearcherServer;
+pub use common::proto::KompAC::search::searcher_server::SearcherServer;
-use common::proto::multieko2::search::searcher_server::Searcher;
+use common::proto::KompAC::search::searcher_server::Searcher;
 use common::search::register_slovak_tokenizers;
 use sqlx::{PgPool, Row};
 use tracing::info;

server/src/auth/docs/first_reg.txt

@@ -1,7 +1,7 @@
 ❯ grpcurl -plaintext -d '{
   "username": "testuser2",
   "email": "test2@example.com"
-}' localhost:50051 multieko2.auth.AuthService/Register
+}' localhost:50051 KompAC.auth.AuthService/Register
 {
   "id": "5fa9bbce-85e0-4b06-8364-b561770c2fdd",
   "username": "testuser2",

server/src/auth/docs/reg_log.txt

@@ -3,7 +3,7 @@
   "email": "test3@example.com",
   "password": "your_password",
   "password_confirmation": "your_password"
-}' localhost:50051 multieko2.auth.AuthService/Register
+}' localhost:50051 KompAC.auth.AuthService/Register
 {
   "id": "96d2fd35-b39d-4c05-916a-66134453d34c",
   "username": "testuser3",
@@ -12,14 +12,14 @@
 }
 ❯ grpcurl -plaintext -d '{
   "identifier": "testuser3"
-}' localhost:50051 multieko2.auth.AuthService/Login
+}' localhost:50051 KompAC.auth.AuthService/Login
 ERROR:
   Code: Unauthenticated
   Message: Invalid credentials
 ❯ grpcurl -plaintext -d '{
   "identifier": "testuser3",
   "password": "your_password"
-}' localhost:50051 multieko2.auth.AuthService/Login
+}' localhost:50051 KompAC.auth.AuthService/Login
 {
   "accessToken": "eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9.eyJzdWIiOiI5NmQyZmQzNS1iMzlkLTRjMDUtOTE2YS02NjEzNDQ1M2QzNGMiLCJleHAiOjE3NDI5ODE2MTAsInJvbGUiOiJhY2NvdW50YW50In0.78VIR3X4QZohzeI5x3xmkmqcICTusOC6PELPohMV-k8",
   "tokenType": "Bearer",
@@ -30,7 +30,7 @@ ERROR:
 ❯ grpcurl -plaintext -d '{
   "username": "testuser4",
   "email": "test4@example.com"
-}' localhost:50051 multieko2.auth.AuthService/Register
+}' localhost:50051 KompAC.auth.AuthService/Register
 {
   "id": "413d7ecc-f231-48af-8c5a-566b1dc2bf0b",
   "username": "testuser4",
@@ -39,7 +39,7 @@ ERROR:
 }
 ❯ grpcurl -plaintext -d '{
   "identifier": "test4@example.com"
-}' localhost:50051 multieko2.auth.AuthService/Login
+}' localhost:50051 KompAC.auth.AuthService/Login
 {
   "accessToken": "eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9.eyJzdWIiOiI0MTNkN2VjYy1mMjMxLTQ4YWYtOGM1YS01NjZiMWRjMmJmMGIiLCJleHAiOjE3NDI5ODE3MDEsInJvbGUiOiJhY2NvdW50YW50In0.4Hzu3tTZRNGHnBSgeCbGy2tFTl8EzpPdXBhcW8kuIc8",
   "tokenType": "Bearer",
@@ -47,5 +47,5 @@ ERROR:
   "userId": "413d7ecc-f231-48af-8c5a-566b1dc2bf0b",
   "role": "accountant"
 }
-╭─     ~/Doc/pr/multieko2/server     auth ······ ✔
+╭─     ~/Doc/pr/KompAC/server     auth ······ ✔
 ╰─

server/src/auth/docs/role_added.txt

@@ -3,7 +3,7 @@
   "email": "default@example.com",
   "password": "password",
   "password_confirmation": "password"
-}' localhost:50051 multieko2.auth.AuthService/Register
+}' localhost:50051 KompAC.auth.AuthService/Register
 {
   "id": "73017288-af41-49d8-b4cb-2ac2109b38a1",
   "username": "testuser_default_role",
@@ -16,7 +16,7 @@
   "password": "password",
   "password_confirmation": "password",
   "role": "admin"
-}' localhost:50051 multieko2.auth.AuthService/Register
+}' localhost:50051 KompAC.auth.AuthService/Register
 {
   "id": "9437e318-818b-4c34-822d-c2d6601b835e",
   "username": "testuser_admin_role",
@@ -29,9 +29,9 @@
   "password": "password",
   "password_confirmation": "password",
   "role": "invalid_role_name"
-}' localhost:50051 multieko2.auth.AuthService/Register
+}' localhost:50051 KompAC.auth.AuthService/Register
 ERROR:
   Code: InvalidArgument
   Message: Invalid role specified: 'invalid_role_name'
-╭─     ~/Doc/pr/multieko2/server     main +3 !1 
+╭─     ~/Doc/pr/KompAC/server     main +3 !1 
 ╰─

server/src/auth/handlers/login.rs

@@ -3,7 +3,7 @@ use bcrypt::verify;
 use tonic::{Response, Status};
 use crate::db::PgPool;
 use crate::auth::logic::jwt; // Fixed import path
-use common::proto::multieko2::auth::{LoginRequest, LoginResponse};
+use common::proto::KompAC::auth::{LoginRequest, LoginResponse};
 
 pub async fn login(
     pool: &PgPool,

server/src/auth/handlers/register.rs

@@ -1,7 +1,7 @@
 // src/auth/handlers/register.rs
 use bcrypt::{hash, DEFAULT_COST};
 use tonic::{Response, Status};
-use common::proto::multieko2::auth::{RegisterRequest, AuthResponse};
+use common::proto::KompAC::auth::{RegisterRequest, AuthResponse};
 use crate::db::PgPool;
 use crate::auth::models::AuthError;
 

server/src/server/run.rs

@@ -4,7 +4,7 @@ use tonic_reflection::server::Builder as ReflectionBuilder;
 use tokio::sync::mpsc;
 use crate::indexer::{indexer_task, IndexCommand};
 
-use common::proto::multieko2::FILE_DESCRIPTOR_SET;
+use common::proto::KompAC::FILE_DESCRIPTOR_SET;
 use crate::server::services::{
     TableStructureHandler,
     TableDefinitionService,
@@ -12,7 +12,7 @@ use crate::server::services::{
     TableScriptService,
     AuthServiceImpl
 };
-use common::proto::multieko2::{
+use common::proto::KompAC::{
     table_structure::table_structure_service_server::TableStructureServiceServer,
     table_definition::table_definition_server::TableDefinitionServer,
     tables_data::tables_data_server::TablesDataServer,

server/src/server/services/auth_service.rs

@@ -1,6 +1,6 @@
 // src/server/services/auth_service.rs
 use tonic::{Request, Response, Status};
-use common::proto::multieko2::auth::{
+use common::proto::KompAC::auth::{
     auth_service_server::AuthService,
     RegisterRequest, AuthResponse,
     LoginRequest, LoginResponse

server/src/server/services/table_definition_service.rs

@@ -1,6 +1,6 @@
 // src/server/services/table_definition_service.rs
 use tonic::{Request, Response, Status};
-use common::proto::multieko2::{
+use common::proto::KompAC::{
     common::Empty,
     table_definition::{
         table_definition_server::TableDefinition,

server/src/server/services/table_script_service.rs

@@ -1,6 +1,6 @@
 // src/server/services/table_script_service.rs
 use tonic::{Request, Response, Status};
-use common::proto::multieko2::table_script::{
+use common::proto::KompAC::table_script::{
     table_script_server::TableScript,
     PostTableScriptRequest, TableScriptResponse
 };

server/src/server/services/table_structure_service.rs

@@ -1,8 +1,8 @@
 // src/server/services/table_structure_service.rs
 use tonic::{Request, Response, Status};
 // Correct the import path for the TableStructureService trait
-use common::proto::multieko2::table_structure::table_structure_service_server::TableStructureService;
+use common::proto::KompAC::table_structure::table_structure_service_server::TableStructureService;
-use common::proto::multieko2::table_structure::{
+use common::proto::KompAC::table_structure::{
     GetTableStructureRequest,
     TableStructureResponse,
 };

server/src/server/services/tables_data_service.rs

@@ -5,9 +5,9 @@ use tonic::{Request, Response, Status};
 use tokio::sync::mpsc;
 use crate::indexer::IndexCommand;
 
-use common::proto::multieko2::tables_data::tables_data_server::TablesData;
+use common::proto::KompAC::tables_data::tables_data_server::TablesData;
-use common::proto::multieko2::common::CountResponse;
+use common::proto::KompAC::common::CountResponse;
-use common::proto::multieko2::tables_data::{
+use common::proto::KompAC::tables_data::{
     PostTableDataRequest, PostTableDataResponse,
     PutTableDataRequest, PutTableDataResponse,
     DeleteTableDataRequest, DeleteTableDataResponse,

server/src/steel/docs/pushing_using_steel.txt

@@ -3,7 +3,7 @@
   "target_column": "idea_name",
   "script": "(begin (define idea_name \"aaa\") idea_name)",
   "description": "Set idea_name to Awesome Idea"
-}' localhost:50051 multieko2.table_script.TableScript/PostTableScript
+}' localhost:50051 KompAC.table_script.TableScript/PostTableScript
 {
   "id": "7"
 }
@@ -17,7 +17,7 @@
     "is_feasible": "true",
     "last_updated": "2025-03-11T12:34:56Z"
   }
-}' localhost:50051 multieko2.tables_data.TablesData/PostTableData
+}' localhost:50051 KompAC.tables_data.TablesData/PostTableData
 ERROR:
   Code: InvalidArgument
   Message: Validation failed for 'idea_name'. Expected: 'aaa', Received: 'sdfsfs'
@@ -31,7 +31,7 @@ ERROR:
     "is_feasible": "true",
     "last_updated": "2025-03-11T12:34:56Z"
   }
-}' localhost:50051 multieko2.tables_data.TablesData/PostTableData
+}' localhost:50051 KompAC.tables_data.TablesData/PostTableData
 {
   "success": true,
   "message": "Data inserted successfully",

server/src/steel/docs/script_refering_different_table.txt

@@ -6,7 +6,7 @@ Creation of the tables:
     {"name": "yearly_goal", "field_type": "text"}
   ],
   "profile_name": "finance"
-}' localhost:50051 multieko2.table_definition.TableDefinition/PostTableDefinition
+}' localhost:50051 KompAC.table_definition.TableDefinition/PostTableDefinition
 {
   "success": true,
   "sql": "CREATE TABLE \"2025_department\" (\n    id BIGSERIAL PRIMARY KEY,\n    deleted BOOLEAN NOT NULL DEFAULT FALSE,\n    \"yearly_goal\" TEXT,\n    created_at TIMESTAMPTZ DEFAULT CURRENT_TIMESTAMP\n)\n"
@@ -22,7 +22,7 @@ Creation of the tables:
   "links": [
     {"linked_table_name": "2025_department", "required": true}
   ]
-}' localhost:50051 multieko2.table_definition.TableDefinition/PostTableDefinition
+}' localhost:50051 KompAC.table_definition.TableDefinition/PostTableDefinition
 {
   "success": true,
   "sql": "CREATE TABLE \"2025_project\" (\n    id BIGSERIAL PRIMARY KEY,\n    deleted BOOLEAN NOT NULL DEFAULT FALSE,\n    \"department_id\" BIGINT NOT NULL REFERENCES \"2025_department\"(id),\n    \"name\" TEXT,\n    \"budget_estimate\" TEXT,\n    created_at TIMESTAMPTZ DEFAULT CURRENT_TIMESTAMP\n)\nCREATE INDEX idx_2025_project_department_fk ON \"2025_project\" (\"department_id\")\nCREATE INDEX idx_2025_project_name ON \"2025_project\" (\"name\")"

server/src/steel/server/execution.rs

@@ -88,7 +88,6 @@ pub async fn execute_script(
 
     for (key, value) in &context.row_data {
         // Register both @ prefixed and bare variable names
-        define_script.push_str(&format!("(define {} \"{}\")\n", key, value));
         define_script.push_str(&format!("(define @{} \"{}\")\n", key, value));
     }
 

server/src/table_definition/docs/delete_tables.txt

@@ -15,7 +15,7 @@
   "indexes": ["company_name", "is_active"],
   "profile_name": "default",
   "linked_table_name": ""
-}' localhost:50051 multieko2.table_definition.TableDefinition/PostTableDefinition
+}' localhost:50051 KompAC.table_definition.TableDefinition/PostTableDefinition
 ERROR:
   Code: NotFound
   Message: Linked table not found in profile
@@ -35,12 +35,12 @@ ERROR:
   ],
   "indexes": ["company_name", "is_active"],
   "profile_name": "default"
-}' localhost:50051 multieko2.table_definition.TableDefinition/PostTableDefinition
+}' localhost:50051 KompAC.table_definition.TableDefinition/PostTableDefinition
 {
   "success": true,
   "sql": "CREATE TABLE \"2025_company_data1\" (\n    id BIGSERIAL PRIMARY KEY,\n    deleted BOOLEAN NOT NULL DEFAULT FALSE,\n    firma TEXT NOT NULL,\n    \"company_name\" TEXT,\n    \"textfield\" TEXT,\n    \"textfield2\" TEXT,\n    \"textfield3\" TEXT,\n    \"headquarters_psc\" TEXT,\n    \"contact_phone\" VARCHAR(15),\n    \"office_address\" TEXT,\n    \"support_email\" VARCHAR(255),\n    \"is_active\" BOOLEAN,\n    \"last_updated\" TIMESTAMPTZ,\n    created_at TIMESTAMPTZ DEFAULT CURRENT_TIMESTAMP\n)\nCREATE INDEX idx_2025_company_data1_firma ON \"2025_company_data1\" (firma)\nCREATE INDEX idx_2025_company_data1_company_name ON \"2025_company_data1\" (\"company_name\")\nCREATE INDEX idx_2025_company_data1_is_active ON \"2025_company_data1\" (\"is_active\")"
 }
-❯ grpcurl -plaintext -d '{}' localhost:50051 multieko2.table_definition.TableDefinition/GetProfileTree
+❯ grpcurl -plaintext -d '{}' localhost:50051 KompAC.table_definition.TableDefinition/GetProfileTree
 {
   "profiles": [
     {
@@ -56,12 +56,12 @@ ERROR:
 ❯ grpcurl -plaintext -d '{
   "profile_name": "default",
   "table_name": "2025_company_data1"
-}' localhost:50051 multieko2.table_definition.TableDefinition/DeleteTable
+}' localhost:50051 KompAC.table_definition.TableDefinition/DeleteTable
 {
   "success": true,
   "message": "Table '2025_company_data1' and its definition were successfully removed"
 }
-❯ grpcurl -plaintext -d '{}' localhost:50051 multieko2.table_definition.TableDefinition/GetProfileTree
+❯ grpcurl -plaintext -d '{}' localhost:50051 KompAC.table_definition.TableDefinition/GetProfileTree
 {}
-╭─     ~/Doc/pr/multieko2/server     main ⇡1 ········· ✔
+╭─     ~/Doc/pr/KompAC/server     main ⇡1 ········· ✔
 ╰─

server/src/table_definition/docs/eg.txt

@@ -1,4 +1,4 @@
-❯ grpcurl -plaintext -d '{}' localhost:50051 multieko2.table_definition.TableDefinition/GetProfileTree
+❯ grpcurl -plaintext -d '{}' localhost:50051 KompAC.table_definition.TableDefinition/GetProfileTree
 {
   "profiles": [
     {
@@ -80,12 +80,12 @@
   "indexes": ["column1", "columnd"],
   "profile_name": "new_profile",
   "linked_table_name": "2025_multi_dependent_table3"
-}' localhost:50051 multieko2.table_definition.TableDefinition/PostTableDefinition
+}' localhost:50051 KompAC.table_definition.TableDefinition/PostTableDefinition
 {
   "success": true,
   "sql": "CREATE TABLE \"2025_multi_dependent_table5\" (\n    id BIGSERIAL PRIMARY KEY,\n    deleted BOOLEAN NOT NULL DEFAULT FALSE,\n    firma TEXT NOT NULL,\n    \"multi_dependent_table3_id\" BIGINT NOT NULL REFERENCES \"2025_multi_dependent_table3\"(id),\n    \"2025_column1\" TEXT,\n    \"2025_columnx\" TEXT,\n    \"2025_columny\" TEXT,\n    \"2025_columnz\" TEXT,\n    \"2025_columna\" TEXT,\n    \"2025_columnb\" TEXT,\n    \"2025_columnc\" TEXT,\n    \"2025_columnd\" TEXT,\n    \"2025_column2\" INTEGER,\n    created_at TIMESTAMPTZ DEFAULT CURRENT_TIMESTAMP\n)\nCREATE INDEX idx_2025_multi_dependent_table5_firma ON \"2025_multi_dependent_table5\" (firma)\nCREATE INDEX idx_2025_multi_dependent_table5_multi_dependent_table3_id ON \"2025_multi_dependent_table5\" (\"multi_dependent_table3_id\")\nCREATE INDEX idx_2025_multi_dependent_table5_2025_column1 ON \"2025_multi_dependent_table5\" (\"2025_column1\")\nCREATE INDEX idx_2025_multi_dependent_table5_2025_columnd ON \"2025_multi_dependent_table5\" (\"2025_columnd\")"
 }
-❯ grpcurl -plaintext -d '{}' localhost:50051 multieko2.table_definition.TableDefinition/GetProfileTree
+❯ grpcurl -plaintext -d '{}' localhost:50051 KompAC.table_definition.TableDefinition/GetProfileTree
 {
   "profiles": [
     {

server/src/table_definition/docs/push_new_table.txt

@@ -1,4 +1,4 @@
-❯ grpcurl -plaintext -d '{}' localhost:50051 multieko2.table_definition.TableDefinition/GetProfileTree
+❯ grpcurl -plaintext -d '{}' localhost:50051 KompAC.table_definition.TableDefinition/GetProfileTree
 {
   "profiles": [
     {
@@ -44,12 +44,12 @@
   ],
   "indexes": ["firma", "mesto"],
   "profile_name": "default"
-}' localhost:50051 multieko2.table_definition.TableDefinition/PostTableDefinition
+}' localhost:50051 KompAC.table_definition.TableDefinition/PostTableDefinition
 {
   "success": true,
   "sql": "CREATE TABLE \"2025_adresar6\" (\n    id BIGSERIAL PRIMARY KEY,\n    deleted BOOLEAN NOT NULL DEFAULT FALSE,\n    \"firma\" TEXT,\n    \"kz\" TEXT,\n    \"drc\" TEXT,\n    \"ulica\" TEXT,\n    \"psc\" TEXT,\n    \"mesto\" TEXT,\n    \"stat\" TEXT,\n    \"banka\" TEXT,\n    \"ucet\" TEXT,\n    \"skladm\" TEXT,\n    \"ico\" TEXT,\n    \"kontakt\" TEXT,\n    \"telefon\" VARCHAR(15),\n    \"skladu\" TEXT,\n    \"fax\" TEXT,\n    created_at TIMESTAMPTZ DEFAULT CURRENT_TIMESTAMP\n)\nCREATE INDEX idx_2025_adresar6_firma ON \"2025_adresar6\" (\"firma\")\nCREATE INDEX idx_2025_adresar6_mesto ON \"2025_adresar6\" (\"mesto\")"
 }
-❯ grpcurl -plaintext -d '{}' localhost:50051 multieko2.table_definition.TableDefinition/GetProfileTree
+❯ grpcurl -plaintext -d '{}' localhost:50051 KompAC.table_definition.TableDefinition/GetProfileTree
 {
   "profiles": [
     {
@@ -154,4 +154,4 @@ grpcurl -plaintext -d '{
     {"linked_table_name": "2025_shipping_provider", "required": false},
     {"linked_table_name": "2025_ecom_product", "required": false}
   ]
-}' localhost:50051 multieko2.table_definition.TableDefinition/PostTableDefinition
+}' localhost:50051 KompAC.table_definition.TableDefinition/PostTableDefinition

server/src/table_definition/handlers/delete_table.rs

@@ -1,7 +1,7 @@
 // src/table_definition/handlers/delete_table.rs
 use tonic::Status;
 use sqlx::PgPool;
-use common::proto::multieko2::table_definition::{DeleteTableRequest, DeleteTableResponse};
+use common::proto::KompAC::table_definition::{DeleteTableRequest, DeleteTableResponse};
 
 pub async fn delete_table(
     db_pool: &PgPool,

server/src/table_definition/handlers/get_profile_tree.rs

@@ -1,7 +1,7 @@
 // src/table_definition/handlers/get_profile_tree.rs
 use tonic::{Request, Response, Status};
 use sqlx::PgPool;
-use common::proto::multieko2::{
+use common::proto::KompAC::{
     common::Empty,
     table_definition::{
         ProfileTreeResponse,

server/src/table_definition/handlers/post_table_definition.rs

@@ -3,7 +3,7 @@
 use tonic::Status;
 use sqlx::{PgPool, Transaction, Postgres};
 use serde_json::json;
-use common::proto::multieko2::table_definition::{PostTableDefinitionRequest, TableDefinitionResponse};
+use common::proto::KompAC::table_definition::{PostTableDefinitionRequest, TableDefinitionResponse};
 
 const PREDEFINED_FIELD_TYPES: &[(&str, &str)] = &[
     ("text", "TEXT"),

server/src/table_script/docs/push_script_to_db.txt

@@ -4,7 +4,7 @@ This is how we can push script into the database, now its stored after a push in
   "target_column": "fax",
   "script": "(set! fax telefon)",
   "description": "Copy telefon value to fax column"
-}' localhost:50051 multieko2.table_script.TableScript/PostTableScript
+}' localhost:50051 KompAC.table_script.TableScript/PostTableScript
 {
   "id": "2"
 }

server/src/table_script/handlers/post_table_script.rs

@@ -3,7 +3,7 @@
 
 use tonic::Status;
 use sqlx::{PgPool, Error as SqlxError};
-use common::proto::multieko2::table_script::{PostTableScriptRequest, TableScriptResponse};
+use common::proto::KompAC::table_script::{PostTableScriptRequest, TableScriptResponse};
 use serde_json::Value;
 use steel_decimal::SteelDecimal;
 use regex::Regex;

server/src/table_structure/docs/response.txt

@@ -4,7 +4,7 @@ grpcurl -plaintext \
     "table_name": "2025_customer"
   }' \
   localhost:50051 \
-  multieko2.table_structure.TableStructureService/GetTableStructure
+  KompAC.table_structure.TableStructureService/GetTableStructure
 {
   "columns": [
     {

server/src/table_structure/handlers/table_structure.rs

@@ -1,5 +1,5 @@
 // src/table_structure/handlers/table_structure.rs
-use common::proto::multieko2::table_structure::{
+use common::proto::KompAC::table_structure::{
     GetTableStructureRequest, TableColumn, TableStructureResponse,
 };
 use sqlx::PgPool;

server/src/tables_data/docs/get_by_position.txt

@@ -2,7 +2,7 @@ grpcurl -plaintext -d '{
   "profile_name": "default",
   "table_name": "2025_adresar",
   "position": 1
-}' localhost:50051 multieko2.tables_data.TablesData/GetTableDataByPosition
+}' localhost:50051 KompAC.tables_data.TablesData/GetTableDataByPosition
 {
   "data": {
     "banka": "New Banka",

server/src/tables_data/docs/get_data.txt

@@ -1,6 +1,6 @@
 Valid get request:
 
-grpcurl -plaintext -d '{"profile_name": "default", "table_name": "2025_adresar", "id": 2}' localhost:50051 multieko2.tables_data.TablesData/GetTableData
+grpcurl -plaintext -d '{"profile_name": "default", "table_name": "2025_adresar", "id": 2}' localhost:50051 KompAC.tables_data.TablesData/GetTableData
 
 {
   "data": {
@@ -26,7 +26,7 @@ grpcurl -plaintext -d '{"profile_name": "default", "table_name": "2025_adresar",
 
 Request of a deleted data:
 
-grpcurl -plaintext -d '{"profile_name": "default", "table_name": "2025_adresar", "id": 1}' localhost:50051 multieko2.tables_data.TablesData/GetTableData
+grpcurl -plaintext -d '{"profile_name": "default", "table_name": "2025_adresar", "id": 1}' localhost:50051 KompAC.tables_data.TablesData/GetTableData
 
 ERROR:
   Code: NotFound

server/src/tables_data/docs/get_data_count.txt

@@ -1,4 +1,4 @@
-grpcurl -plaintext -d '{"profile_name": "default", "table_name": "2025_adresar"}' localhost:50051 multieko2.tables_data.TablesData/GetTableDataCount
+grpcurl -plaintext -d '{"profile_name": "default", "table_name": "2025_adresar"}' localhost:50051 KompAC.tables_data.TablesData/GetTableDataCount
 
 {
   "count": "1"

server/src/tables_data/docs/post_data.txt

@@ -1,4 +1,4 @@
-❯ grpcurl -plaintext -d '{}' localhost:50051 multieko2.table_definition.TableDefinition/GetProfileTree
+❯ grpcurl -plaintext -d '{}' localhost:50051 KompAC.table_definition.TableDefinition/GetProfileTree
 {
   "profiles": [
     {
@@ -26,7 +26,7 @@
     "support_email": "support@acmecorp.com",
     "is_active": "true"
   }
-}' localhost:50051 multieko2.tables_data.TablesData/PostTableData
+}' localhost:50051 KompAC.tables_data.TablesData/PostTableData
 {
   "success": true,
   "message": "Data inserted successfully",

server/src/tables_data/docs/put_data.txt

@@ -14,7 +14,7 @@
     "support_email": "updated-support@acmecorp.com",
     "is_active": "false"
   }
-}' localhost:50051 multieko2.tables_data.TablesData/PutTableData
+}' localhost:50051 KompAC.tables_data.TablesData/PutTableData
 {
   "success": true,
   "message": "Data updated successfully",
@@ -28,7 +28,7 @@
     "firma": "1",
     "is_active": "true"
   }
-}' localhost:50051 multieko2.tables_data.TablesData/PutTableData
+}' localhost:50051 KompAC.tables_data.TablesData/PutTableData
 {
   "success": true,
   "message": "Data updated successfully",

server/src/tables_data/handlers/delete_table_data.rs

@@ -1,7 +1,7 @@
 // src/tables_data/handlers/delete_table_data.rs
 use tonic::Status;
 use sqlx::PgPool;
-use common::proto::multieko2::tables_data::{DeleteTableDataRequest, DeleteTableDataResponse};
+use common::proto::KompAC::tables_data::{DeleteTableDataRequest, DeleteTableDataResponse};
 use crate::shared::schema_qualifier::qualify_table_name_for_data; // Import schema qualifier
 
 pub async fn delete_table_data(

server/src/tables_data/handlers/get_table_data.rs

@@ -3,7 +3,7 @@
 use tonic::Status;
 use sqlx::{PgPool, Row};
 use std::collections::HashMap;
-use common::proto::multieko2::tables_data::{GetTableDataRequest, GetTableDataResponse};
+use common::proto::KompAC::tables_data::{GetTableDataRequest, GetTableDataResponse};
 use crate::shared::schema_qualifier::qualify_table_name_for_data;
 
 pub async fn get_table_data(

server/src/tables_data/handlers/get_table_data_by_position.rs

@@ -1,7 +1,7 @@
 // src/tables_data/handlers/get_table_data_by_position.rs
 use tonic::Status;
 use sqlx::PgPool;
-use common::proto::multieko2::tables_data::{
+use common::proto::KompAC::tables_data::{
     GetTableDataByPositionRequest, GetTableDataRequest, GetTableDataResponse
 };
 use super::get_table_data;

server/src/tables_data/handlers/get_table_data_count.rs

@@ -1,8 +1,8 @@
 // src/tables_data/handlers/get_table_data_count.rs
 use tonic::Status;
 use sqlx::PgPool;
-use common::proto::multieko2::common::CountResponse;
+use common::proto::KompAC::common::CountResponse;
-use common::proto::multieko2::tables_data::GetTableDataCountRequest;
+use common::proto::KompAC::tables_data::GetTableDataCountRequest;
 use crate::shared::schema_qualifier::qualify_table_name_for_data; // 1. IMPORT THE FUNCTION
 
 pub async fn get_table_data_count(

server/src/tables_data/handlers/post_table_data.rs

@@ -4,7 +4,7 @@ use tonic::Status;
 use sqlx::{PgPool, Arguments};
 use sqlx::postgres::PgArguments;
 use chrono::{DateTime, Utc};
-use common::proto::multieko2::tables_data::{PostTableDataRequest, PostTableDataResponse};
+use common::proto::KompAC::tables_data::{PostTableDataRequest, PostTableDataResponse};
 use std::collections::HashMap;
 use std::sync::Arc;
 use prost_types::value::Kind;

server/src/tables_data/handlers/put_table_data.rs

@@ -4,8 +4,8 @@ use tonic::Status;
 use sqlx::{PgPool, Arguments, Row};
 use sqlx::postgres::PgArguments;
 use chrono::{DateTime, Utc};
-use common::proto::multieko2::tables_data::{PutTableDataRequest, PutTableDataResponse};
+use common::proto::KompAC::tables_data::{PutTableDataRequest, PutTableDataResponse};
-use std::collections::HashMap;
+
 use std::sync::Arc;
 use prost_types::value::Kind;
 use rust_decimal::Decimal;

server/tests/table_definition/post_table_definition_test.rs

@@ -1,7 +1,7 @@
 // tests/table_definition/post_table_definition_test.rs
 
 // Keep all your normal use statements
-use common::proto::multieko2::table_definition::{
+use common::proto::KompAC::table_definition::{
     ColumnDefinition, PostTableDefinitionRequest, TableLink,
 };
 use rstest::{fixture, rstest};

server/tests/table_script/comprehensive_error_scenarios_tests.rs

@@ -2,7 +2,7 @@
 
 use crate::common::setup_isolated_db;
 use server::table_script::handlers::post_table_script::post_table_script;  // Fixed import
-use common::proto::multieko2::table_script::PostTableScriptRequest;
+use common::proto::KompAC::table_script::PostTableScriptRequest;
 use rstest::*;
 use serde_json::json;
 use sqlx::PgPool;

server/tests/table_script/mathematical_operations_tests.rs

@@ -2,7 +2,7 @@
 
 use crate::common::setup_isolated_db;
 use server::table_script::handlers::post_table_script::post_table_script;  // Fixed import
-use common::proto::multieko2::table_script::PostTableScriptRequest;
+use common::proto::KompAC::table_script::PostTableScriptRequest;
 use rstest::*;
 use serde_json::json;
 use sqlx::PgPool;

server/tests/table_script/post_scripts_integration_tests.rs

@@ -2,7 +2,7 @@
 
 use crate::common::setup_isolated_db;
 use server::table_script::handlers::post_table_script::post_table_script;
-use common::proto::multieko2::table_script::{PostTableScriptRequest, TableScriptResponse};
+use common::proto::KompAC::table_script::{PostTableScriptRequest, TableScriptResponse};
 use serde_json::json;
 use sqlx::PgPool;
 

server/tests/table_script/prohibited_types_test.rs

@@ -2,7 +2,7 @@
 
 use crate::common::setup_isolated_db;
 use server::table_script::handlers::post_table_script::post_table_script;
-use common::proto::multieko2::table_script::PostTableScriptRequest;
+use common::proto::KompAC::table_script::PostTableScriptRequest;
 use serde_json::json;
 use sqlx::PgPool;
 

server/tests/table_script/type_safety_comprehensive_tests.rs

@@ -2,7 +2,7 @@
 
 use crate::common::setup_isolated_db;
 use server::table_script::handlers::post_table_script::post_table_script;
-use common::proto::multieko2::table_script::PostTableScriptRequest;
+use common::proto::KompAC::table_script::PostTableScriptRequest;
 use rstest::*;
 use serde_json::json;
 use sqlx::PgPool;

server/tests/tables_data/delete/delete_table_data_test.rs

@@ -13,10 +13,10 @@ use rand::Rng;
 use rand::distr::Alphanumeric; // Corrected import
 
 // Common imports from other modules
-use common::proto::multieko2::table_definition::{
+use common::proto::KompAC::table_definition::{
     PostTableDefinitionRequest, ColumnDefinition as TableColumnDefinition, TableLink,
 };
-use common::proto::multieko2::tables_data::{
+use common::proto::KompAC::tables_data::{
     DeleteTableDataRequest, DeleteTableDataResponse, PostTableDataRequest, PutTableDataRequest,
 };
 use server::indexer::IndexCommand;

server/tests/tables_data/get/get_table_data_by_position_test.rs

@@ -2,8 +2,8 @@
 use rstest::{fixture, rstest};
 use tonic;
 use sqlx::PgPool;
-use common::proto::multieko2::tables_data::GetTableDataByPositionRequest;
+use common::proto::KompAC::tables_data::GetTableDataByPositionRequest;
-use common::proto::multieko2::table_definition::{PostTableDefinitionRequest, ColumnDefinition};
+use common::proto::KompAC::table_definition::{PostTableDefinitionRequest, ColumnDefinition};
 use server::table_definition::handlers::post_table_definition;
 use server::tables_data::handlers::get_table_data_by_position;
 use crate::common::setup_test_db;

server/tests/tables_data/get/get_table_data_count_test.rs

@@ -2,9 +2,9 @@
 use rstest::{fixture, rstest};
 use tonic;
 use sqlx::PgPool;
-use common::proto::multieko2::tables_data::GetTableDataCountRequest;
+use common::proto::KompAC::tables_data::GetTableDataCountRequest;
-use common::proto::multieko2::table_definition::{PostTableDefinitionRequest, ColumnDefinition};
+use common::proto::KompAC::table_definition::{PostTableDefinitionRequest, ColumnDefinition};
-use common::proto::multieko2::table_definition::TableLink;
+use common::proto::KompAC::table_definition::TableLink;
 use server::tables_data::handlers::get_table_data_count;
 use server::table_definition::handlers::post_table_definition;
 use crate::common::setup_test_db;

server/tests/tables_data/get/get_table_data_test.rs

@@ -1,7 +1,7 @@
 // tests/tables_data/handlers/get_table_data_test.rs
 use rstest::{fixture, rstest};
 use server::tables_data::handlers::get_table_data;
-use common::proto::multieko2::tables_data::GetTableDataRequest;
+use common::proto::KompAC::tables_data::GetTableDataRequest;
 use crate::common::setup_test_db;
 use sqlx::{PgPool, Row};
 use tonic;
@@ -15,10 +15,10 @@ use rust_decimal::Decimal;
 use rust_decimal_macros::dec;
 use server::table_definition::handlers::post_table_definition;
 use server::tables_data::handlers::post_table_data;
-use common::proto::multieko2::table_definition::{
+use common::proto::KompAC::table_definition::{
     PostTableDefinitionRequest, ColumnDefinition as TableColumnDefinition, TableLink
 };
-use common::proto::multieko2::tables_data::PostTableDataRequest;
+use common::proto::KompAC::tables_data::PostTableDataRequest;
 use prost_types::Value;
 use prost_types::value::Kind;
 use tokio::sync::mpsc;

server/tests/tables_data/post/post_table_data_steel_decimal_test.rs

@@ -1,7 +1,7 @@
 // tests/tables_data/post/post_table_data_steel_decimal_test.rs
 
 use sqlx::PgPool;
-use common::proto::multieko2::{
+use common::proto::KompAC::{
     table_definition::{PostTableDefinitionRequest, ColumnDefinition},
     table_script::PostTableScriptRequest,
     tables_data::PostTableDataRequest,

server/tests/tables_data/post/post_table_data_test.rs

@@ -4,9 +4,9 @@ use sqlx::PgPool;
 use std::collections::HashMap;
 use prost_types::Value;
 use prost_types::value::Kind;
-use common::proto::multieko2::tables_data::{PostTableDataRequest, PostTableDataResponse};
+use common::proto::KompAC::tables_data::{PostTableDataRequest, PostTableDataResponse};
-use common::proto::multieko2::table_definition::TableLink;
+use common::proto::KompAC::table_definition::TableLink;
-use common::proto::multieko2::table_definition::{
+use common::proto::KompAC::table_definition::{
     PostTableDefinitionRequest, ColumnDefinition as TableColumnDefinition
 };
 use server::tables_data::handlers::post_table_data;

server/tests/tables_data/put/put_table_data_steel_decimal_test.rs

@@ -1,7 +1,7 @@
 // tests/tables_data/put/put_table_data_steel_decimal_test.rs
 
 use sqlx::PgPool;
-use common::proto::multieko2::{
+use common::proto::KompAC::{
     table_definition::{PostTableDefinitionRequest, ColumnDefinition},
     table_script::PostTableScriptRequest,
     tables_data::{PostTableDataRequest, PutTableDataRequest},

server/tests/tables_data/put/put_table_data_test.rs

@@ -4,10 +4,10 @@ use rstest::{fixture, rstest};
 use sqlx::{PgPool, Row};
 use std::collections::HashMap;
 use prost_types::{value::Kind, Value};
-use common::proto::multieko2::table_definition::{
+use common::proto::KompAC::table_definition::{
     PostTableDefinitionRequest, ColumnDefinition as TableColumnDefinition, TableLink,
 };
-use common::proto::multieko2::tables_data::{
+use common::proto::KompAC::tables_data::{
     PostTableDataRequest, PutTableDataRequest,
 };
 use server::table_definition::handlers::post_table_definition;