advotracker/advotracker/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"]

//#[macro_use]
//extern crate lazy_static;

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

use orbtk::prelude::*;

// The Main view
use advotracker::{
    callbacks::policycheck_state::PolicyCheckState,
    widgets::main_view,
};

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: String,
    test_lang: String,
    rust_log: String,
}

// German localization file.
static ADVOTRACKER_DE_DE: &str = include_str!("../resources/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("C".to_string());

    // 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);
    lang
}

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 subscriber = fmt::Subscriber::builder()
        .with_env_filter(&rust_log)
        //.with_max_level(tracing::Level::DEBUG)
        .finish();

    tracing::subscriber::with_default(subscriber, || {
        // get system environment
        let lang = get_lang();

        let mut state = t!("state.started", lang);
        let mut res = t!("parse.environment", lang);
        trace!(target: "advotracker", message = ?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", message = ?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);

        // 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();

        // if no dictionary is set for the default language e.g. english the content of the text property will drawn.
        let localization = RonLocalization::create()
            .language("en_US")
            .dictionary("de_DE", ADVOTRACKER_DE_DE)
            .build();

        Application::from_name("nwx.advotracker")
            .theme(PolicyCheckState::theme())
            .localization(localization)
            .window(|ctx| {
                Window::new()
                    .title("AdvoTracker - DirectCall")
                    .position((500.0, 100.0))
                    .size(580.0, 320.0)
                    //.min_width(460.0)
                    //.min_height(180.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);
    }
}