Vous avez acheté le cher tracker Timeular et vous ne voulez pas payer en plus pour leur application propriétaire ? Ce projet est pour vous. Avec Timeular Reader, vous pouvez connecter votre tracker à votre application de suivi du temps préférée.
Exécutez d’abord la commande avec l’indicateur --setup , cela générera une configuration et vous permettra d’étiqueter les côtés de votre appareil.
timeular-reader --setupVous n'êtes pas obligé de configurer tous les côtés, appuyez sur q sur un côté que vous ne souhaitez pas utiliser et la configuration sera générée avec ceux que vous avez configurés.
Après la configuration initiale, vous pouvez modifier config.toml
Pour contrôler la verbosité de la sortie, vous pouvez passer --verbose ou -v , vous pouvez ajouter plusieurs -vvv pour le rendre plus détaillé.
Il existe également le mode --quiet , -q pour désactiver toutes les sorties.
Pour obtenir votre identifiant de projet et votre identifiant d'espace de travail, dans le panneau de gauche sous Gérer, cliquez sur Projets. Cliquez ensuite sur le nom du projet que vous souhaitez utiliser. L'URL devrait ressembler à ceci https://track.toggl.com/{workspace_id}/projects/{project_id}/team
Pour générer votre clé API, accédez aux paramètres de votre profil en haut à droite. Après avoir fait défiler vers le bas, vous verrez une option pour générer une clé API.
Pour obtenir l'identifiant de votre espace de travail, en haut à droite, cliquez sur Votre espace de travail, accédez à Gérer puis paramètres, vous devriez avoir l'identifiant de l'espace de travail dans l'URL. Cela devrait ressembler à ceci https://app.clockify.me/workspaces/{workspace_id}/settings
Notez que l'identifiant du projet est facultatif
Pour obtenir l'identifiant de votre projet sur le côté gauche, cliquez sur projets, puis cliquez sur vos projets. L'URL contiendra l'identifiant du projet. Cela devrait ressembler à ceci https://app.clockify.me/projects/{project_id}/edit
FAIRE
FAIRE
Vous devez d’abord créer un nouveau mod et l’enregistrer ici, appelons-le example .
Vous créez le mod en créant un fichier src/handler/example.rs et en ajoutant pub mod example; dans le fichier lié ci-dessus. Le example.rs doit avoir une fonction publique appelée async create_handler(setup: bool) , et cette fonction doit renvoyer une structure qui implémente Handler L'implémentation nécessite une annotation #[async_trait]
Il est fort probable que votre mod nécessitera une certaine configuration. Vous pouvez tout implémenter dans le fichier principal example.rs , mais pour le garder propre, je recommande de déclarer new mod config . Le mod de configuration sera chargé de créer une configuration par défaut et de la sauvegarder dans le fichier de configuration principal config.toml .
Nous devons d’abord ajouter pub mod config; vers example.rs et créez le fichier src/handler/example/config.rs . Dans config.rs nous devons créer une structure qui contiendra toutes les données de configuration dont nous aurons besoin, appelons-la ExampleConfig .
Les dérivés sont nécessaires
# [ derive ( Serialize , Deserialize , Clone , Debug ) ]
pub struct ExampleConfig {
base_url : String ,
api_key : String ,
} Nous devons ensuite implémenter Default et crate::config::Config . L'implémentation Default peut créer la structure avec des éléments qui ne changent pas beaucoup, comme une URL de base d'API. Par exemple:
impl Default for ExampleConfig {
fn default ( ) -> Self {
ExampleConfig {
base_url : String :: from ( "https://api.example.com" ) ,
api_key : String :: new ( ) ,
}
}
} L'implémentation crate::config::Config peut être vide, il s'agit simplement d'hériter du type et d'une durée de vie, elle peut ressembler à ceci :
impl < ' de > Config < ' de > for ExampleConfig { }Si vous souhaitez enregistrer votre configuration dans le fichier de configuration principal, vous devez disposer d'une clé unique sous laquelle elle sera enregistrée.
Pour plus de commodité, vous pouvez implémenter des méthodes pour obtenir et mettre à jour la configuration (depuis/vers un fichier). Sinon, vous devrez appeler crate::config::get_config et crate::config::update_config . Ces fonctions peuvent ressembler à ceci :
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 ) ;
} Après cela, nous devons enregistrer le nouveau gestionnaire. Dans src/handler.rs vous devez ajouter notre Example de mod à l'énumération Handlers et lui attribuer un numéro.
pub enum Handlers {
Toggl = 1,
Clockify = 2,
Traggo = 3,
Hackaru = 4,
+ Example = 5,
} alors nous devons ajuster TryFrom<u8> :
fn try_from(v: u8) -> Result<Self, Self::Error> {
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(()),
}
} pareil dans TryFrom<&String> :
fn try_from(v: &String) -> Result<Self, Self::Error> {
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(()),
}
}
La dernière chose à faire est d'ajuster la méthode factory, dans get_handler :
pub async fn get_handler(setup: bool, config: &TimeularConfig) -> Box<dyn Handler> {
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),
}
}J'ai ajouté l'exemple de tracker au référentiel, vous pouvez baser votre module sur cela.
Exécutez simplement
cargo build
