TODO ACCOUNTING GUI NEEDS VERIFICATION AND REVIEW TESTING

komp-app/src/grpc.rs

@@ -9,8 +9,17 @@ use common::proto::komp_ac::analytics::analytics_service_client::AnalyticsServic
 use common::proto::komp_ac::ecb::ecb_service_client::EcbServiceClient;
 use common::proto::komp_ac::search2::search2_client::Search2Client;
 use common::proto::komp_ac::accounting::{
-    Account, EnsureAccountRequest, GetJournalRequest, Journal, SearchJournalsRequest,
+    Account, AccountingPeriod, AccountingStatus, ApproveProfileRequest,
-    SearchJournalsResponse, accounting_client::AccountingClient,
+    CloseAccountingPeriodRequest, ConfigureAccountingPeriodRequest, EnsureAccountRequest,
+    GetAccountingStatusRequest, GetJournalRequest, GetProfileApprovalRequest,
+    GetTrialBalanceRequest, GetTrialBalanceResponse, Journal,
+    ListAccountingPeriodsRequest, ListAccountingPeriodsResponse,
+    ListOpeningBalanceAccountsRequest, ListOpeningBalanceAccountsResponse,
+    ListPeriodBalancesRequest, ListPeriodBalancesResponse, ListUnbalancedJournalsRequest,
+    ListUnbalancedJournalsResponse, MapOpeningBalanceAccountRequest,
+    OpeningBalanceAccountMapping, ProfileApproval, ReopenAccountingPeriodRequest,
+    SearchJournalsRequest, SearchJournalsResponse, UnmapOpeningBalanceAccountRequest,
+    UnmapOpeningBalanceAccountResponse, accounting_client::AccountingClient,
 };
 use common::proto::komp_ac::common::Empty;
 use common::proto::komp_ac::document_data::{
@@ -227,6 +236,105 @@ impl GrpcClient {
         Ok(response.into_inner())
     }
 
+    pub async fn get_accounting_status(
+        &mut self,
+        profile_name: String,
+    ) -> Result<AccountingStatus> {
+        let request = self.authenticated_request(GetAccountingStatusRequest { profile_name })?;
+        Ok(self.accounting_client.get_accounting_status(request).await
+            .context("gRPC GetAccountingStatus call failed")?.into_inner())
+    }
+
+    pub async fn list_unbalanced_journals(
+        &mut self,
+        request: ListUnbalancedJournalsRequest,
+    ) -> Result<ListUnbalancedJournalsResponse> {
+        let request = self.authenticated_request(request)?;
+        Ok(self.accounting_client.list_unbalanced_journals(request).await
+            .context("gRPC ListUnbalancedJournals call failed")?.into_inner())
+    }
+
+    pub async fn configure_accounting_period(
+        &mut self,
+        request: ConfigureAccountingPeriodRequest,
+    ) -> Result<AccountingPeriod> {
+        let request = self.authenticated_request(request)?;
+        Ok(self.accounting_client.configure_accounting_period(request).await
+            .context("gRPC ConfigureAccountingPeriod call failed")?.into_inner())
+    }
+
+    pub async fn close_accounting_period(&mut self, period_id: i64) -> Result<AccountingPeriod> {
+        let request = self.authenticated_request(CloseAccountingPeriodRequest { period_id })?;
+        Ok(self.accounting_client.close_accounting_period(request).await
+            .context("gRPC CloseAccountingPeriod call failed")?.into_inner())
+    }
+
+    pub async fn reopen_accounting_period(&mut self, period_id: i64) -> Result<AccountingPeriod> {
+        let request = self.authenticated_request(ReopenAccountingPeriodRequest { period_id })?;
+        Ok(self.accounting_client.reopen_accounting_period(request).await
+            .context("gRPC ReopenAccountingPeriod call failed")?.into_inner())
+    }
+
+    pub async fn approve_profile(&mut self, profile_name: String) -> Result<ProfileApproval> {
+        let request = self.authenticated_request(ApproveProfileRequest { profile_name })?;
+        Ok(self.accounting_client.approve_profile(request).await
+            .context("gRPC ApproveProfile call failed")?.into_inner())
+    }
+
+    pub async fn get_profile_approval(&mut self, profile_name: String) -> Result<ProfileApproval> {
+        let request = self.authenticated_request(GetProfileApprovalRequest { profile_name })?;
+        Ok(self.accounting_client.get_profile_approval(request).await
+            .context("gRPC GetProfileApproval call failed")?.into_inner())
+    }
+
+    pub async fn list_accounting_periods(
+        &mut self,
+        profile_name: String,
+    ) -> Result<ListAccountingPeriodsResponse> {
+        let request = self.authenticated_request(ListAccountingPeriodsRequest { profile_name })?;
+        Ok(self.accounting_client.list_accounting_periods(request).await
+            .context("gRPC ListAccountingPeriods call failed")?.into_inner())
+    }
+
+    pub async fn list_period_balances(&mut self, period_id: i64) -> Result<ListPeriodBalancesResponse> {
+        let request = self.authenticated_request(ListPeriodBalancesRequest { period_id })?;
+        Ok(self.accounting_client.list_period_balances(request).await
+            .context("gRPC ListPeriodBalances call failed")?.into_inner())
+    }
+
+    pub async fn get_trial_balance(&mut self, period_id: i64) -> Result<GetTrialBalanceResponse> {
+        let request = self.authenticated_request(GetTrialBalanceRequest { period_id })?;
+        Ok(self.accounting_client.get_trial_balance(request).await
+            .context("gRPC GetTrialBalance call failed")?.into_inner())
+    }
+
+    pub async fn map_opening_balance_account(
+        &mut self,
+        request: MapOpeningBalanceAccountRequest,
+    ) -> Result<OpeningBalanceAccountMapping> {
+        let request = self.authenticated_request(request)?;
+        Ok(self.accounting_client.map_opening_balance_account(request).await
+            .context("gRPC MapOpeningBalanceAccount call failed")?.into_inner())
+    }
+
+    pub async fn unmap_opening_balance_account(
+        &mut self,
+        request: UnmapOpeningBalanceAccountRequest,
+    ) -> Result<UnmapOpeningBalanceAccountResponse> {
+        let request = self.authenticated_request(request)?;
+        Ok(self.accounting_client.unmap_opening_balance_account(request).await
+            .context("gRPC UnmapOpeningBalanceAccount call failed")?.into_inner())
+    }
+
+    pub async fn list_opening_balance_accounts(
+        &mut self,
+        target_period_id: i64,
+    ) -> Result<ListOpeningBalanceAccountsResponse> {
+        let request = self.authenticated_request(ListOpeningBalanceAccountsRequest { target_period_id })?;
+        Ok(self.accounting_client.list_opening_balance_accounts(request).await
+            .context("gRPC ListOpeningBalanceAccounts call failed")?.into_inner())
+    }
+
     // Fetch validation rules for a table. Absence of a field in response = no validation.
     pub async fn get_table_validation(
         &mut self,