timeular reader

Pembaca Waktu

Sudahkah Anda membeli pelacak Timeular yang mahal dan tidak ingin membayar lebih untuk aplikasi miliknya? Proyek ini untuk Anda. Dengan Timeular Reader Anda dapat menghubungkan pelacak Anda ke aplikasi pelacakan waktu favorit Anda.

Penggunaan

Pertama jalankan perintah dengan --setup flag, ini akan menghasilkan konfigurasi dan memungkinkan Anda memberi label pada sisi perangkat Anda.

 timeular-reader --setup

Anda tidak perlu mengatur semua sisi, tekan q pada sisi yang tidak ingin Anda gunakan dan config akan dihasilkan dengan yang Anda atur.

Setelah pengaturan awal Anda dapat memodifikasi config.toml

Untuk mengontrol verbositas keluaran, Anda dapat meneruskan --verbose atau -v , Anda dapat menambahkan beberapa -vvv untuk membuatnya lebih bertele-tele.

Ada juga mode --quiet , -q untuk membisukan semua output.

Beralih

Untuk mendapatkan id proyek dan id ruang kerja Anda, di panel kiri di bawah Kelola, klik Proyek. Kemudian klik nama proyek yang ingin Anda gunakan. Urlnya akan terlihat seperti ini https://track.toggl.com/{workspace_id}/projects/{project_id}/team

jam

Untuk menghasilkan kunci api, buka pengaturan profil Anda di kanan atas. Setelah menggulir ke bawah Anda akan melihat opsi untuk menghasilkan Kunci API.

Untuk mendapatkan id ruang kerja Anda, di kanan atas, klik Ruang Kerja Anda, buka Kelola lalu pengaturan, Anda harus memiliki id ruang kerja di url. Seharusnya terlihat seperti ini https://app.clockify.me/workspaces/{workspace_id}/settings

Catatan id proyek bersifat opsional

Untuk mendapatkan id proyek Anda di sisi kiri, klik proyek, lalu klik proyek Anda. Url akan berisi id proyek. Seharusnya terlihat seperti ini https://app.clockify.me/projects/{project_id}/edit

Haharu

TODO

Trago

TODO

Membuat penangan Anda sendiri

Pertama, Anda perlu membuat mod baru dan mendaftarkannya di sini, sebut saja example .

Anda membuat mod dengan membuat file src/handler/example.rs dan menambahkan pub mod example; ke dalam file yang ditautkan di atas. example.rs harus memiliki fungsi publik yang disebut async create_handler(setup: bool) , dan fungsi tersebut harus mengembalikan struct yang mengimplementasikan Handler Implementasinya memerlukan anotasi #[async_trait]

Kemungkinan besar mod Anda memerlukan beberapa konfigurasi. Anda dapat mengimplementasikan semuanya di file example.rs utama, tetapi agar tetap bersih saya sarankan mendeklarasikan new mod config . Mod konfigurasi akan bertanggung jawab untuk membuat konfigurasi default dan menyimpannya ke file konfigurasi utama config.toml .

Pertama kita perlu menambahkan pub mod config; ke example.rs dan buat file src/handler/example/config.rs . Di config.rs kita perlu membuat struct yang akan menampung semua data konfigurasi yang kita perlukan, sebut saja ExampleConfig .

Turunannya diperlukan

 # [ derive ( Serialize , Deserialize , Clone , Debug ) ]
pub struct ExampleConfig {
    base_url : String ,
    api_key : String ,
}

Kita kemudian perlu mengimplementasikan Default dan crate::config::Config . Implementasi Default dapat membuat struct dengan hal-hal yang tidak banyak berubah, seperti url basis API. Misalnya:

 impl Default for ExampleConfig {
    fn default ( ) -> Self {
        ExampleConfig {
            base_url : String :: from ( "https://api.example.com" ) ,
            api_key : String :: new ( ) ,
        }
    }
}

Implementasi crate::config::Config boleh kosong, ini hanya tentang mewarisi tipe dan masa pakainya, bisa terlihat seperti ini:

 impl < ' de > Config < ' de > for ExampleConfig { }

Jika Anda ingin menyimpan konfigurasi Anda sebagai file konfigurasi utama, Anda harus memiliki kunci unik untuk menyimpannya.

Untuk kenyamanan, Anda dapat menerapkan metode untuk mendapatkan dan memperbarui konfigurasi (dari/ke file). Jika tidak, Anda harus memanggil crate::config::get_config , dan crate::config::update_config . Fungsi-fungsi ini dapat terlihat seperti ini:

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

Setelah itu kita perlu mendaftarkan handler baru. Di src/handler.rs Anda perlu menambahkan Example mod kami ke enum Handlers dan menetapkan nomornya.

pub enum Handlers {
    Toggl = 1,
    Clockify = 2,
    Traggo = 3,
    Hackaru = 4,
+   Example = 5,
}

maka kita perlu menyesuaikan 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(()),
    }
}

sama di 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(()),
        }
    }

Hal terakhir yang harus dilakukan adalah menyesuaikan metode pabrik, di 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),
    }
}

Saya telah menambahkan contoh pelacak ke repositori, Anda dapat mendasarkan modul Anda pada itu.

Membangun

Jalankan saja

 cargo build