Sie haben den teuren Timeular-Tracker gekauft und möchten nicht noch zusätzlich für die proprietäre App bezahlen? Dieses Projekt ist für Sie. Mit Timeular Reader können Sie Ihren Tracker mit Ihrer bevorzugten Zeiterfassungs-App verbinden.
Führen Sie zunächst den Befehl mit dem Flag --setup aus. Dadurch wird eine Konfiguration generiert und Sie können die Seiten Ihres Geräts beschriften.
timeular-reader --setupSie müssen nicht alle Seiten einrichten. Drücken Sie q auf einer Seite, die Sie nicht verwenden möchten, und die Konfiguration wird mit den von Ihnen eingerichteten erstellt.
Nach der Ersteinrichtung können Sie config.toml ändern
Um die Ausführlichkeit der Ausgabe zu steuern, können Sie --verbose oder -v übergeben. Sie können mehrere -vvv hinzufügen, um die Ausführlichkeit zu erhöhen.
Es gibt auch den Modus --quiet und -q , um alle Ausgaben stummzuschalten.
Um Ihre Projekt-ID und Arbeitsbereichs-ID zu erhalten, klicken Sie im linken Bereich unter „Verwalten“ auf „Projekte“. Klicken Sie dann auf den Projektnamen, den Sie verwenden möchten. Die URL sollte wie folgt aussehen: https://track.toggl.com/{workspace_id}/projects/{project_id}/team
Um Ihren API-Schlüssel zu generieren, gehen Sie zu Ihren Profileinstellungen oben rechts. Nachdem Sie nach unten gescrollt haben, sehen Sie eine Option zum Generieren eines API-Schlüssels.
Um Ihre Workspace-ID zu erhalten, klicken Sie oben rechts auf „Ihr Workspace“, gehen Sie zu „Verwalten“ und dann zu „Einstellungen“. Die URL sollte die Workspace-ID enthalten. Es sollte etwa so aussehen: https://app.clockify.me/workspaces/{workspace_id}/settings
Beachten Sie, dass die Projekt-ID optional ist
Um Ihre Projekt-ID auf der linken Seite zu erhalten, klicken Sie auf „Projekte“ und dann auf Ihre Projekte. Die URL enthält die Projekt-ID. Sollte etwa so aussehen: https://app.clockify.me/projects/{project_id}/edit
TODO
TODO
Zuerst müssen Sie einen neuen Mod erstellen und ihn hier registrieren. Nennen wir ihn example .
Sie erstellen den Mod, indem Sie eine Datei src/handler/example.rs erstellen und pub mod example; in die oben verlinkte Datei einfügen. Die example.rs muss eine öffentliche Funktion namens async create_handler(setup: bool) haben und diese Funktion muss eine Struktur zurückgeben, die Handler implementiert. Die Implementierung benötigt die Annotation #[async_trait]
Es ist sehr wahrscheinlich, dass Ihr Mod einige Konfigurationen erfordert. Sie können alles in der Hauptdatei example.rs implementieren, aber um sie sauber zu halten, empfehle ich die Deklaration einer neuen Mod config . Der Konfigurations-Mod ist dafür verantwortlich, eine Standardkonfiguration zu erstellen und diese in der Hauptkonfigurationsdatei config.toml zu speichern.
Zuerst müssen wir pub mod config; zu example.rs und erstellen Sie die Datei src/handler/example/config.rs . In config.rs müssen wir eine Struktur erstellen, die alle benötigten Konfigurationsdaten enthält. Nennen wir sie ExampleConfig .
Die Ableitungen sind notwendig
# [ derive ( Serialize , Deserialize , Clone , Debug ) ]
pub struct ExampleConfig {
base_url : String ,
api_key : String ,
} Anschließend müssen wir Default und crate::config::Config implementieren. Die Default kann die Struktur mit den Dingen erstellen, die sich nicht wesentlich ändern, wie z. B. einer API-Basis-URL. Zum Beispiel:
impl Default for ExampleConfig {
fn default ( ) -> Self {
ExampleConfig {
base_url : String :: from ( "https://api.example.com" ) ,
api_key : String :: new ( ) ,
}
}
} Die crate::config::Config -Implementierung kann leer sein, es geht nur um die Vererbung des Typs und einer Lebensdauer, sie kann so aussehen:
impl < ' de > Config < ' de > for ExampleConfig { }Wenn Sie Ihre Konfiguration in der Hauptkonfigurationsdatei speichern möchten, benötigen Sie einen eindeutigen Schlüssel, unter dem sie gespeichert wird.
Der Einfachheit halber können Sie Methoden zum Abrufen und Aktualisieren der Konfiguration (von/in eine Datei) implementieren. Andernfalls müssen Sie crate::config::get_config und crate::config::update_config aufrufen. Diese Funktionen können so aussehen:
const CONFIG_KEY : & str = "example" ; pub fn create_config ( ) -> ExampleConfig { crate :: config :: get_config :: < ExampleConfig > ( CONFIG_KEY ) } pub fn update_config ( config : & ExampleConfig ) { crate :: config :: update_config ( CONFIG_KEY , config ) ; }
Danach müssen wir den neuen Handler registrieren. In src/handler.rs müssen Sie unser Mod- Example zur Handlers -Enumeration hinzufügen und ihm eine Nummer zuweisen.
pub enum Handlers {
Toggl = 1,
Clockify = 2,
Traggo = 3,
Hackaru = 4,
+ Example = 5,
} dann müssen wir TryFrom anpassen:
fn try_from(v: u8) -> Result {
match v {
x if x == Handlers::Toggl as u8 => Ok(Handlers::Toggl),
x if x == Handlers::Clockify as u8 => Ok(Handlers::Clockify),
x if x == Handlers::Traggo as u8 => Ok(Handlers::Traggo),
x if x == Handlers::Hackaru as u8 => Ok(Handlers::Hackaru),
+ x if x == Handlers::Example as u8 => Ok(Handlers::Example),
_ => Err(()),
}
} dasselbe in TryFrom<&String> :
fn try_from(v: &String) -> Result {
match v.as_str() {
"toggl" => Ok(Handlers::Toggl),
"clockify" => Ok(Handlers::Clockify),
"traggo" => Ok(Handlers::Traggo),
"hackaru" => Ok(Handlers::Hackaru),
+ "example" => Ok(Handlers::Example),
_ => Err(()),
}
}
Als letztes müssen Sie die Factory-Methode in get_handler anpassen:
pub async fn get_handler(setup: bool, config: &TimeularConfig) -> Box {
match config.handler.as_str() {
"toggl" => Box::new(toggl::create_handler(setup).await),
"hackaru" => Box::new(hackaru::create_handler(setup).await),
"clockify" => Box::new(clockify::create_handler(setup).await),
"traggo" => Box::new(traggo::create_handler(setup).await),
+ "example" => Box::new(example::create_handler(setup).await),
_ => Box::new(example::create_handler(setup).await),
}
} Ich habe den Beispiel-Tracker zum Repository hinzugefügt, Sie können Ihr Modul darauf aufbauen.
Einfach laufen
cargo build
