taler-rust

config.rs (6195B)

---

 /*
   This file is part of TALER
   Copyright (C) 2025, 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 std::time::Duration;
 
 use compact_str::{CompactString, format_compact};
 use taler_api::{
     Serve,
     config::{ApiCfg, DbCfg},
 };
 use taler_common::{
     config::{Config, ValueErr},
     map_config,
     types::{amount::Currency, payto::PaytoURI},
 };
 use url::Url;
 
 use crate::payto::{CyclosAccount, CyclosId, FullCyclosPayto};
 
 #[derive(Debug, Clone, Copy)]
 pub enum AccountType {
     Exchange,
     Normal,
 }
 
 pub fn parse_db_cfg(cfg: &Config) -> Result<DbCfg, ValueErr> {
     DbCfg::parse(cfg.section("cyclosdb-postgres"))
 }
 
 pub fn parse_account_payto(cfg: &Config, main: &MainCfg) -> Result<FullCyclosPayto, ValueErr> {
     let sect = cfg.section("cyclos");
     let id = sect.parse("cyclos account id", "ACCOUNT_ID").require()?;
     let name = sect.str("NAME").require()?;
 
     Ok(FullCyclosPayto::new(
         CyclosAccount {
             id,
             root: main.root.clone(),
         },
         &name,
     ))
 }
 
 /// Cyclos main config
 pub struct MainCfg {
     pub currency: Currency,
     pub url: Url,
     pub root: CompactString,
 }
 
 impl MainCfg {
     pub fn parse(cfg: &Config) -> Result<Self, ValueErr> {
         let sect = cfg.section("cyclos");
         let url = sect.base_url("CYCLOS_URL").require()?;
         let root = format_compact!(
             "{}{}",
             url.host_str().unwrap_or_default(),
             url.path().trim_end_matches('/')
         );
         Ok(Self {
             currency: sect.parse("currency", "CURRENCY").require()?,
             url,
             root,
         })
     }
 }
 
 /// Cyclos API config
 pub struct HostCfg {
     pub api_url: Url,
     pub username: String,
     pub password: String,
 }
 
 impl HostCfg {
     pub fn parse(cfg: &Config, main: &MainCfg) -> Result<Self, ValueErr> {
         let sect = cfg.section("cyclos-worker");
         Ok(Self {
             username: sect.str("USERNAME").require()?,
             api_url: main.url.join("api/").unwrap(),
             password: sect.str("PASSWORD").require()?,
         })
     }
 }
 
 /// taler-cyclos httpd config
 pub struct ServeCfg {
     pub payto: PaytoURI,
     pub currency: Currency,
     pub root: CompactString,
     pub serve: Serve,
     pub wire_gateway: Option<ApiCfg>,
     pub revenue: Option<ApiCfg>,
 }
 
 impl ServeCfg {
     pub fn parse(cfg: &Config) -> Result<Self, ValueErr> {
         let main = MainCfg::parse(cfg)?;
         let payto = parse_account_payto(cfg, &main)?;
 
         let sect = cfg.section("cyclos-httpd");
 
         let serve = Serve::parse(sect)?;
 
         let wire_gateway = ApiCfg::parse(cfg.section("cyclos-httpd-wire-gateway-api"))?;
         let revenue = ApiCfg::parse(cfg.section("cyclos-httpd-revenue-api"))?;
 
         Ok(Self {
             payto: payto.as_payto(),
             currency: main.currency,
             root: main.root,
             serve,
             wire_gateway,
             revenue,
         })
     }
 }
 
 /// taler-cyclos setup config
 pub struct SetupCfg {
     pub currency: Currency,
     pub root: Url,
     pub host: HostCfg,
     pub id: Option<CyclosId>,
     pub name: Option<String>,
     pub account_type_id: Option<CyclosId>,
     pub payment_type_id: Option<CyclosId>,
 }
 
 impl SetupCfg {
     pub fn parse(cfg: &Config) -> Result<Self, ValueErr> {
         let main = MainCfg::parse(cfg)?;
         let main_s = cfg.section("cyclos");
         let worker_s = cfg.section("cyclos-worker");
         Ok(Self {
             id: main_s.parse("cyclos account id", "ACCOUNT_ID").opt()?,
             account_type_id: worker_s
                 .parse("cyclos account type id", "ACCOUNT_TYPE_ID")
                 .opt()?,
             payment_type_id: worker_s
                 .parse("cyclos payment type id", "PAYMENT_TYPE_ID")
                 .opt()?,
             name: main_s.str("NAME").opt()?,
             host: HostCfg::parse(cfg, &main)?,
             currency: main.currency,
             root: main.url,
         })
     }
 }
 
 /// taler-cyclos worker config
 pub struct WorkerCfg {
     pub currency: Currency,
     pub root: CompactString,
     pub frequency: Duration,
     pub host: HostCfg,
     pub account_type: AccountType,
     pub account_type_id: CyclosId,
     pub payment_type_id: CyclosId,
 }
 
 impl WorkerCfg {
     pub fn parse(cfg: &Config) -> Result<Self, ValueErr> {
         let main = MainCfg::parse(cfg)?;
         let sect = cfg.section("cyclos-worker");
         Ok(Self {
             frequency: sect.duration("FREQUENCY").require()?,
             account_type: map_config!(sect, "account type", "ACCOUNT_TYPE",
                 "exchange" => { Ok(AccountType::Exchange) },
                 "normal" => { Ok(AccountType::Normal) }
             )
             .require()?,
             account_type_id: sect
                 .parse("cyclos account type id", "ACCOUNT_TYPE_ID")
                 .require()?,
             payment_type_id: sect
                 .parse("cyclos payment type id", "PAYMENT_TYPE_ID")
                 .require()?,
             host: HostCfg::parse(cfg, &main)?,
             currency: main.currency,
             root: main.root,
         })
     }
 }
 
 /// cyclos-harness config
 pub struct HarnessCfg {
     pub worker: WorkerCfg,
     pub username: String,
     pub password: String,
 }
 
 impl HarnessCfg {
     pub fn parse(cfg: &Config) -> Result<Self, ValueErr> {
         let worker = WorkerCfg::parse(cfg)?;
 
         let sect = cfg.section("cyclos-harness");
 
         Ok(Self {
             worker,
             username: sect.str("USERNAME").require()?,
             password: sect.str("PASSWORD").require()?,
         })
     }
 }