taler-rust

setup.rs (5649B)

---

 /*
   This file is part of TALER
   Copyright (C) 2026 Taler Systems SA
 
   TALER is free software; you can redistribute it and/or modify it under the
   terms of the GNU Affero General Public License as published by the Free Software
   Foundation; either version 3, or (at your option) any later version.
 
   TALER is distributed in the hope that it will be useful, but WITHOUT ANY
   WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
   A PARTICULAR PURPOSE.  See the GNU Affero General Public License for more details.
 
   You should have received a copy of the GNU Affero General Public License along with
   TALER; see the file COPYING.  If not, see <http://www.gnu.org/licenses/>
 */
 
 use anyhow::Context;
 use sqlx::PgPool;
 use taler_common::config::Config;
 use tracing::{debug, error, info, warn};
 
 use crate::{
     config::{SetupCfg, WiseBalance},
     db::{initialize_sync_state, reset_sync_state},
     wise_api::client::Client,
 };
 
 pub async fn setup(
     cfg: &Config,
     pool: &PgPool,
     client: &http_client::Client,
     reset: bool,
 ) -> anyhow::Result<()> {
     let cfg = SetupCfg::parse(cfg)?;
     let client = Client::new(client, cfg.api, &cfg.token);
 
     info!(target: "setup", "Check API access and configuration");
     let mut ready = true;
 
     // Check profile
     let profiles = client.profiles().await?;
     let profiles_fmt = std::fmt::from_fn(|w| {
         for p in &profiles {
             write!(w, "\n{} {:?} '{}'", p.id, p.ty, p.full_name)?;
         }
         Ok(())
     });
     if let Some(id) = cfg.profile_id {
         if let Some(profile) = profiles.iter().find(|it| it.id == id) {
             debug!(target: "setup", "PROFILE_ID {id} in config is one of:{profiles_fmt}");
             match &cfg.name {
                 Some(name) => {
                     if name != profile.full_name {
                         warn!(
                             target: "setup",
                             "Expected NAME '{name}' from config got '{}' from server",
                             profile.full_name
                         )
                     } else {
                         debug!(target: "setup", "NAME {name} from config match server")
                     }
                 }
                 None => {
                     error!(target: "setup", "Missing NAME got '{}' from server", profile.full_name);
                     ready = false;
                 }
             }
         } else {
             error!(target: "setup", "Unknown PROFILE_ID {id} in config, must be one of:{profiles_fmt}");
             ready = false;
         }
     } else {
         error!(target: "setup", "Missing PROFILE_ID in config, must be one of:{profiles_fmt}");
         ready = false;
     }
 
     if let Some(profile_id) = cfg.profile_id {
         // Check accounts
         let accounts = client.borderless_accounts(profile_id).await?;
         let account = accounts
             .iter()
             .find(|it| it.profile_id == profile_id)
             .context("Missing Wise account for configured profile")?;
 
         let balances_fmt = std::fmt::from_fn(|w| {
             for balance in &account.balances {
                 if let Some(payto) = balance.bank_details.account() {
                     write!(w, "\n{} {} ({payto})", balance.id, balance.currency)?;
                 }
             }
             Ok(())
         });
         info!(target: "setup", "Supported balances are: {balances_fmt}");
 
         if cfg.balances.is_empty() {
             error!(target: "setup", "No balances are configured");
             ready = false;
         }
         for WiseBalance {
             id,
             currency,
             payto,
         } in &cfg.balances
         {
             let Some(balance) = account.balances.iter().find(|b| b.id == u64::from(*id)) else {
                 error!(target: "setup", "Unknown balance {id} {currency}");
                 ready = false;
                 continue;
             };
             if balance.currency != *currency {
                 error!(target: "setup", "Balance {id} in config use currency {currency} expected {}", balance.currency);
                 ready = false;
             }
             match balance.bank_details.account() {
                 Some(account) if account == *payto => {}
                 Some(account) => {
                     error!(target: "setup", "Balance {id} in config use payto ({payto}) expected ({account})");
                     ready = false;
                 }
                 None => {
                     error!(target: "setup", "Balance {id} in config use payto ({payto}) but it's not supported");
                     ready = false;
                 }
             }
         }
     }
 
     if !ready {
         error!(target: "setup", "Setup failed, config need editing");
         std::process::exit(6);
     }
 
     let profile_id = cfg.profile_id.context("Missing PROFILE_ID")?;
     let balances = client.standard_balances(profile_id).await?;
     for configured in &cfg.balances {
         let remote = balances
             .iter()
             .find(|remote| {
                 remote.id == u64::from(configured.id) && remote.currency == configured.currency
             })
             .with_context(|| {
                 format!(
                     "Missing Wise balance {} {}",
                     configured.id, configured.currency
                 )
             })?;
         initialize_sync_state(pool, configured.id, remote.creation_time).await?;
     }
     if reset {
         reset_sync_state(pool).await?;
         info!(target: "setup", "Synchronization state reset to balance creation");
     }
     info!(target: "setup", "Setup finished");
     Ok(())
 }