rzerres/advotrackerd
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

README.md update

Browse Source 
Signed-off-by: Ralf Zerres <ralf.zerres@networkx.de>
This commit is contained in:
Ralf Zerres
2019-11-08 15:59:59 +01:00
parent dc78de28d0
commit 45c03b086e
5 changed files with 172 additions and 34 deletions
Download Patch File Download Diff File Expand all files Collapse all files

14
README.md
View File

@@ -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,
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
---

21
locales/main.json
View File

@@ -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"
}
}

2
src/lib.rs
View File

@@ -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 {

167
src/main.rs
View File

@@ -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 ...",
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::<Environment>() {
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::<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(())
}

2
tests/integration_test.rs
View File

@@ -2,6 +2,6 @@
#[test]
fn integration_add_two() {
assert_eq!(4, advotracker::add_two(2));
assert_eq!(4, advotracker_backend::add_two(2));
}