From 45c03b086ebfd1de221eb0dd6083e0b6699d2945 Mon Sep 17 00:00:00 2001 From: Ralf Zerres Date: Fri, 8 Nov 2019 15:59:59 +0100 Subject: [PATCH] README.md update Signed-off-by: Ralf Zerres --- README.md | 14 ++-- locales/main.json | 21 ++++- src/lib.rs | 2 +- src/main.rs | 167 ++++++++++++++++++++++++++++++++------ tests/integration_test.rs | 2 +- 5 files changed, 172 insertions(+), 34 deletions(-) diff --git a/README.md b/README.md index 12ea2db..44d9793 100755 --- a/README.md +++ b/README.md @@ -4,11 +4,11 @@ -# AdvoTracker - Hotline tool für Advokaten # +# AdvoTracker - Backend # AdvoTracker unterstützt Anwälte bei der Erfassung von Mandatsdaten zu einer Online-Beratung. -Das Tool wurde als multi-Pattform Anwendung konzipiert. +Dieses crate implementiert das Backend. Als Programmiersprache wird *RUST* verwendet. Die Implementierung der GUI Elemente erfolgt mit der Klassenbibliothek *OrbTk*. @@ -18,15 +18,19 @@ Als Dokumentationsquellen wird auf die offiziellen Projektseiten [Rust Book][^1] # Internationalisierung # AdvoTracker wurde mit Unterstützung der Mehrsprachenfähigkeit implementiert. -Existieren für die im Betriebssystem verwendeten Sprache (Umgebungsvariable LOCALE) bereits übersetzungen, -werden diese in allen Dialogen verwendet. +Existieren für aktive Umgebung defnierte Sprache (Umgebungsvariable LOCALE) Übersetzungen, +werden diese in allen Dialogen verwendet. Andernfalls erfolgen alle Ausgaben in englischer Sprache +, die als default-Wert (LANG = C) hinterlegt ist. ## Übersetzungen für neue Sprachen ## +### derzeit: crate locales * Übersetzungen für weiter Sprachen als JSON Dateien im Unerordner ./locales/*.json z.B. für Französisch: advotracker_fr.json +### todo: crate fluent + Die zu verwendende Sprache wird aus der in der Umgebungsvariable des Betriebssystems hinterlegten Sprache ausgewählt. @@ -38,7 +42,7 @@ This work is licensed under a [Creative Common License 4.0][License-CC_BY] ![Creative Common Logo][Logo-CC_BY] -© 2019 Networkx GmbH +© 2019 Ralf Zerres, Networkx GmbH --- diff --git a/locales/main.json b/locales/main.json index 69a08a1..5d50827 100644 --- a/locales/main.json +++ b/locales/main.json @@ -10,10 +10,15 @@ "de": "Anwender nicht gefunden: $email, $id", "en": "User not found: $email, $id" }, - "main.start": { - "de-DE.UTF-8": "Programmlogik starten", + "main.started": { + "de_DE.UTF-8": "Programmlogik starten", "de": "Programmlogik starten", - "en": "Starting program logic" + "en": "Program logic started" + }, + "main.finished": { + "de_DE.UTF-8": "Programmlogik beendet", + "de": "Programmlogik beendet", + "en": "Program logic finished" }, "parse.arguments": { "de_DE.UTF-8": "Programmargumente prüfen", @@ -54,5 +59,15 @@ "de_DE.UTF-8": "Datenbank-Treiber", "de": "Datenbank-Treiber", "en": "database driver" + }, + "state.started": { + "de_DE.UTF-8": "gestartet", + "de": "gestartet", + "en": "started" + }, + "state.finished": { + "de_DE.UTF-8": "beendet", + "de": "beended", + "en": "finished" } } diff --git a/src/lib.rs b/src/lib.rs index 568da09..2c1910c 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -15,7 +15,7 @@ fn internal_adder(a: i32, b: i32) -> i32 { /// # Examples /// /// ``` -/// assert_eq!(4, advotracker::add_two(2)); +/// assert_eq!(4, advotracker_backend::add_two(2)); /// ``` pub fn add_two(a: i32) -> i32 { diff --git a/src/main.rs b/src/main.rs index f550424..c2d984e 100644 --- a/src/main.rs +++ b/src/main.rs @@ -1,7 +1,7 @@ /* advotracker infrastructure. * * Copyright 2019 Ralf Zerres - * SPDX-License-Identifier: 0BSD + * SPDX-License-Identifier: (0BSD or MIT) */ // Rust nightly supports procedural macros! @@ -10,11 +10,18 @@ //use clap::{ArgMatches, Arg, App, SubCommand}; use clap::ArgMatches; + use serde::Deserialize; use std::{env, process}; use dotenv::dotenv; use locales::t; -use tracing::{debug, info, instrument, span, Level}; +//use tracing::{debug, info, instrument, span, Level}; +//use tracing::{debug, info, instrument, Level, Metadata, span::{Id, Attributes, Record}, trace}; +//use tracing::{debug, instrument, span::*, trace, Level}; +use tracing::{debug, instrument, trace, Level}; + +//use diesel::prelude::*; +//use diesel::sqlite::SqliteConnection; #[derive(Deserialize, Debug)] struct Environment { @@ -26,11 +33,27 @@ struct Args { my_conifg: String, verbose: String, } + +pub struct AdvoTrackerSubscriber; + +impl tracing::Subscriber for AdvoTrackerSubscriber{ + fn new_span(&self, _: &Attributes) -> Id { Id::from_u64(0) } + fn record(&self, _: &Id, _: &Record) {} + fn event(&self, _: &tracing::Event) {} + fn record_follows_from(&self, _: &Id, _: &Id) {} + fn enabled(&self, _: &Metadata) -> bool { false } + fn enter(&self, _: &Id) {} + fn exit(&self, _: &Id) {} +} + +impl AdvoTrackerSubscriber { + fn new() -> Self { AdvoTrackerSubscriber } +} */ #[instrument] fn run_subcommand(matches: &ArgMatches) -> Result<(), String> { - info!("inside run_subcommand"); + //info!("inside run_subcommand"); match matches.subcommand() { ("config", Some(cmd)) => run_config(cmd), ("test", Some(cmd)) => run_test(cmd), @@ -39,14 +62,14 @@ fn run_subcommand(matches: &ArgMatches) -> Result<(), String> { } fn run_config(matches: &ArgMatches) -> Result<(), String> { - info!("inside run_config"); + //info!("inside run_config"); let _input = matches.value_of("FILE").unwrap(); Ok(()) } fn run_test(matches: &ArgMatches) -> Result<(), String> { - info!("inside run_test"); + //info!("inside run_test"); if let Some(matches) = matches.subcommand_matches("test") { if matches.is_present("debug") { @@ -63,38 +86,72 @@ fn run_test(matches: &ArgMatches) -> Result<(), String> { //[context_attribute::context] //#[throw] //fn main(args: Args) throw { -fn main() { +fn main() -> std::io::Result<()> { //initialize tracing eco-system use tracing_subscriber::fmt; - let span = span!(Level::TRACE, "advotracker_main"); + //let advotracker_subscriber = AdvoTrackerSubscriber::new(); + //tracing::subscriber::set_global_default(advotracker_subscriber) + // .expect("setting tracing default failed"); + + let span = tracing::span!(Level::TRACE, "advotracker_main"); let _enter = span.enter(); let subscriber = fmt::Subscriber::builder() .with_env_filter("advotracker=trace") .finish(); tracing::subscriber::with_default(subscriber, || { - // get testing environment (.env) + // get system environment + let mut lang = env::var("LANG").unwrap_or("en".to_string()); + let mut res = t!("parse.environment", lang); + let mut state = t!("state.started", lang); debug!( - message = "Reading Environment ...", - finished = "no!" + message = ?res, + state = ?state + ); + trace!( + target: "advotracker", + environment = "system", + lang = ?lang ); + // get testing environment (.env) dotenv().ok(); - let mut lang = env::var("LANG").unwrap_or("en".to_string()); match envy::from_env::() { Ok(environment) => { if environment.test_lang != lang { lang = environment.test_lang; } }, - Err(e) => println!("Couldn't read LANG ({:#?})", e), - }; - let res = t!("parse.environment", lang); - info!(target: "advotracker_event", "{}", res); - info!(target: "advotracker_event", "{}", lang); + //Err(e) => { debug!( message = "No Lang", "{}", e); } + Err(e) => { debug!(target: "advotracker", "{}", e); } + //error = "{:#?}", e" + } + res = t!("parse.environment", lang); + trace!( + target: "advotracker", + environment = "envy", + lang = ?lang + ); + //info!(target: "advotracker", "{}", res); + //info!(target: "advotracker", "{}", lang); + state = t!("state.finished", lang); + debug!( + message = ?res, + state = ?state + ); // handle commandline arguments with clap (relative path to cli.yml) - let res = t!("parse.arguments", lang); - info!(target: "advotracker_event", "{}", res); + res = t!("parse.arguments", lang); + state = t!("state.started", lang); + //info!(target: "advotracker", "{}", res); + debug!( + message = ?res, + state = ?state, + ); + trace!( + target: "advotracker", + process = ?res, + state = ?state + ); let yaml = clap::load_yaml!("cli.yml"); let matches = clap::App::from_yaml(yaml) @@ -110,11 +167,11 @@ fn main() { let verbose = matches.occurrences_of("verbose"); if verbose > 0 { - let res_name = t!("config.name.configfile", lang); + let mut res_name = t!("config.name.configfile", lang); println!("{}: {}", res_name, config); - let res_name = t!("config.name.dbdriver", lang); + res_name = t!("config.name.dbdriver", lang); println!("{}: {}", res_name, dbdriver); - let res_name = t!("config.name.verbositylevel", lang); + res_name = t!("config.name.verbositylevel", lang); println!("{}: {}", res_name, matches.occurrences_of("verbose")); } @@ -122,8 +179,17 @@ fn main() { for (key, value) in env::vars() { println!("{}={}", key, value); } - println!("\n"); } + state = t!("state.finished", lang); + trace!( + target: "advotracker", + process = ?res, + state = ?state + ); + debug!( + message = ?res, + state = ?state + ); // handle subcommands if let Err(e) = run_subcommand(&matches) { @@ -132,7 +198,60 @@ fn main() { } // Starting the program logic - let res = t!("main.start", lang); - println!("{}", &res); + res = t!("main.started", lang); + //info!(target: "advotracker", "{}", res); + trace!( + target: "advotracker", + process = ?res, + state = ?state + ); + + //use advotracker_backend::*; + //use advotracker_backend::schema::users::dsl::*; + + /* + let connection = establish_connection(); + + trace!( + target: "advotracker", + process = "Sqlite3", + status = "connected", + ); + */ + + /* + //User::table.load(&connection); + //user::belonging_to(users).load(&connection); + use advotracker_backend::models::*; + + + let results = users + //.filter(published.eq(true)) + .limit(5) + .load::(&connection) + .expect("Error loading users"); + + println!("Displaying {} users", results.len()); + for user in results { + println!("{}", user.user_id); + println!("----------\n"); + println!("{}", user.first_name); + println!("{}", user.last_name); + println!("{}", user.alias); + println!("{}", user.email); + } + + state = t!("state.finished", lang); + res = t!("main.finished", lang); + //info!(target: "advotracker", "{}", res); + trace!( + target: "advotracker", + process = ?res, + state = ?state + ); + */ + }); + + Ok(()) } diff --git a/tests/integration_test.rs b/tests/integration_test.rs index fbc9f92..9d925a2 100644 --- a/tests/integration_test.rs +++ b/tests/integration_test.rs @@ -2,6 +2,6 @@ #[test] fn integration_add_two() { - assert_eq!(4, advotracker::add_two(2)); + assert_eq!(4, advotracker_backend::add_two(2)); }