README.md update

Signed-off-by: Ralf Zerres <ralf.zerres@networkx.de>

README.md

@@ -4,11 +4,11 @@
 <!-- markdown-toc start - Don't edit this section. Run M-x markdown-toc-generate-toc again -->
 <!-- markdown-toc end -->
 
-# 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,
+Existieren für aktive Umgebung defnierte Sprache (Umgebungsvariable LOCALE) Übersetzungen,
-werden diese in allen Dialogen verwendet.
+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
 
 ---
 

locales/main.json

@@ -10,10 +10,15 @@
     "de": "Anwender nicht gefunden: $email, $id",
     "en": "User not found: $email, $id"
   },
-  "main.start": {
+  "main.started": {
-    "de-DE.UTF-8": "Programmlogik starten",
+    "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"
   }
 }

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 {

src/main.rs

@@ -1,7 +1,7 @@
 /* advotracker infrastructure.
  *
  * Copyright 2019 Ralf Zerres <ralf.zerres@networkx.de>
- * 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 ...",
+            message = ?res,
-            finished = "no!"
+            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::<Environment>() {
             Ok(environment) => {
                 if environment.test_lang != lang { lang = environment.test_lang; }
             },
-            Err(e) => println!("Couldn't read LANG ({:#?})", e),
+            //Err(e) => { debug!( message = "No Lang", "{}", e); }
-        };
+            Err(e) => { debug!(target: "advotracker", "{}", e); }
-        let res = t!("parse.environment", lang);
+            //error = "{:#?}", e"
-        info!(target: "advotracker_event", "{}", res);
+        }
-        info!(target: "advotracker_event", "{}", lang);
+        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);
+        res = t!("parse.arguments", lang);
-        info!(target: "advotracker_event", "{}", res);
+        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);
+        res = t!("main.started", lang);
-        println!("{}", &res);
+        //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::<User>(&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(())
 }

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