advotracker/crates/advotracker_client/src/main.rs

/*
 * advotracker - Hotline tackingtool for Advocats
 *
 * Copyright 2020 Ralf Zerres <ralf.zerres@networkx.de>
 * SPDX-License-Identifier: (0BSD or MIT)
 */

// suppress creation of a new console window on window
#![windows_subsystem = "windows"]

//use chrono::{Local, DateTime};
use dotenv::dotenv;
use cfg_if::cfg_if;
use serde::Deserialize;
use std::env;
//use std::process;
use substring::Substring;
use tracing::{info, trace, Level};

use orbtk::{
    prelude::*,
    theme_default::{THEME_DEFAULT, THEME_DEFAULT_COLORS_DARK, THEME_DEFAULT_FONTS},
    theming::config::ThemeConfig,
};

#[cfg(target_os = "windows")]
use orbtk::theme_fluent::{THEME_FLUENT, THEME_FLUENT_COLORS_DARK, THEME_FLUENT_FONTS};

// The Main view
use advotracker_client::widgets::main_view;

// get the macro (t!) accessing the internationalization strings
include!(concat!(env!("OUT_DIR"), "/i18n.rs"));

mod parse_args;

/// define valid environment variables provided via .env files
/// located in the current call directory
/// this is primarily used in testing scenarios (eg. debugging)
#[derive(Debug, Deserialize)]
struct Environment {
    lang: Lang,
    test_lang: String,
    rust_log: String,
}

// Style extension
static DEFAULT_DARK_EXT: &str = include_str!("../assets/advotracker/default_dark.ron");
cfg_if! {
    if #[cfg(windows)] {
        static FLUENT_DARK_EXT: &str = include_str!("../assets/advotracker/fluent_dark.ron");
        static FLUENT_LIGHT_EXT: &str = include_str!("../assets/advotracker/fluent_light.ron");
    }
}

// German localization file.
static ADVOTRACKER_DE_DE: &str = include_str!("../assets/advotracker/advotracker_de_DE.ron");

/// Get the active language environment.
fn get_lang() -> String {
    // get system environment
    let mut lang = env::var("LANG").unwrap_or_else(|_| "en".to_string());
    lang = lang.substring(0,2).to_string();   // "de_DE.UTF-8" -> "de"
    info!("GUI-Language: preset to {:?}", lang);

    // testing environment: read from .env file
    dotenv().ok();
    match envy::from_env::<Environment>() {
        Ok(environment) => {
            if environment.test_lang != lang { lang = environment.test_lang; }
        },
        Err(e) => { info!(target: "advotracker", "{}", e) }
    }
    trace!(target: "advotracker", lang = ?lang);

    // return the active language
    lang
}

cfg_if! {
    if #[cfg(windows)] {
        /// Extend and register theme assets.
        fn theme() -> Theme {
            register_default_fonts(Theme::from_config(
                ThemeConfig::from(DEFAULT_DARK_EXT)
                    .extend(ThemeConfig::from(THEME_DEFAULT))
                    .extend(ThemeConfig::from(THEME_DEFAULT_COLORS_DARK))
                    .extend(ThemeConfig::from(THEME_DEFAULT_FONTS)),
            ))
        }
        fn theme_fluent() -> Theme {
            register_fluent_fonts(Theme::from_config(
                ThemeConfig::from(FLUENT_DARK_EXT)
                    .extend(ThemeConfig::from(THEME_FLUENT))
                    .extend(ThemeConfig::from(THEME_FLUENT_COLORS_DARK))
                    .extend(ThemeConfig::from(THEME_FLUENT_FONTS)),
            ))
            // register_fluent_fonts(Theme::from_config(
            //     ThemeConfig::from(FLUENT_LIGHT_EXT)
            //         .extend(ThemeConfig::from(THEME_FLUENT))
            //         .extend(ThemeConfig::from(THEME_FLUENT_COLORS_DARK))
            //         .extend(ThemeConfig::from(THEME_FLUENT_FONTS)),
        }
    } else {
        /// Extend and register theme assets.
        fn theme() -> Theme {
            register_default_fonts(Theme::from_config(
                ThemeConfig::from(DEFAULT_DARK_EXT)
                    .extend(ThemeConfig::from(THEME_DEFAULT))
                    .extend(ThemeConfig::from(THEME_DEFAULT_COLORS_DARK))
                    .extend(ThemeConfig::from(THEME_DEFAULT_FONTS)),
           ))
        }
    }
}

fn main() -> Result<(), Box<dyn std::error::Error>> {
    use parse_args::parse_args;
    use tracing_subscriber::fmt;
    use viperus::Viperus;

    let machine_kind = if cfg!(unix) {
        "unix"
    } else if cfg!(windows) {
        "windows"
    } else {
        "unknown/unsupported"
    };

    // respect dotenv environment (e.g for testing)
    // -> overwrites the preset default values
    let rust_log = dotenv::var("RUST_LOG").unwrap_or_else(|_| String::from("None"));

    // initialize the tracing subsystem
    // a drop in replacement for classical logging
    // reference: https://tokio.rs/blog/2019-08-tracing/
    let span = tracing::span!(Level::TRACE, "advotracker");
    let _enter = span.enter();
    let collector = fmt::Subscriber::builder()
        .with_env_filter(&rust_log)
        //.with_max_level(tracing::Level::DEBUG)
        .finish();

    tracing::subscriber::with_default(collector, || {
        // get system environment
        //let lang = get_lang();
        let lang = Lang::De("de");

        let mut state = t!(state_started => lang);
        let mut res = t!(parse_environment => lang);
        trace!(target: "advotracker", process = ?res, state = ?state);
        trace!(target: "advotracker", environment = "system", lang = ?lang);
        trace!(target: "advotracker", machine = ?&machine_kind);

        // how to handle unimplemented lang resources??
        res = t!(parse_environment => lang);
        trace!(target: "advotracker", environment = "envy", lang = ?lang);
        state = t!(state_finished => lang);
        trace!(target: "advotracker", process = ?res, state = ?state);

        // initialize viperus structure
        let mut viperus = Viperus::new();

        // parse commandline arguments
        res = t!(parse_arguments => lang);
        state = t!(state_started => lang);
        trace!(target: "advotracker", process = ?res, state = ?state);

        let _ = parse_args(&mut viperus);
        state = t!(state_finished => lang);
        trace!(target: "advotracker", process = ?res, state = ?state);

        // type conversion (viperus String -> u64)
        let test_policy_number = viperus.get::<String>("test_policy_number").unwrap().parse::<u64>().unwrap();
        trace!(target: "advotracker", test_policy_number = ?test_policy_number);

        // main tasks
        res = t!(main_started => lang);
        state = t!(state_started => lang);
        trace!(target: "advotracker", process = ?res, state = ?state);

        // use this only if you want to run it as web application.
        orbtk::initialize();

        // Preset localization and language from given environment.
        // if no dictionary is set for the chosen default language
        // the content of the text property will be drawn.
        let localization = RonLocalization::create()
            .language("de")
            .dictionary("de_DE", ADVOTRACKER_DE_DE)
            .build();

        Application::from_name("nwx.advotracker")
            .localization(localization)
            .theme(theme())
            .window(|ctx| {
                Window::new()
                    .title("AdvoTracker - DirectCall")
                    .position((500.0, 100.0))
                    .size(800.0, 620.0)
                    //.min_width(460.0)
                    //.min_height(380.0)
                    .resizeable(true)
                    .child(main_view::MainView::new().build(ctx))
                    .build(ctx)
            })
            .run();

        state = t!(state_finished => lang);
        res = t!(main_finished => lang);
        trace!(target: "advotracker", process = ?res, state = ?state);
    });

    Ok(())
}

#[cfg(test)]
mod tests {
    #[test]
    fn it_works() {
        assert_eq!(2 + 2, 4);
    }
}