Você comprou o caro rastreador Timeular e não quer pagar além disso pelo aplicativo de propriedade? Este projeto é para você. Com o Timeular Reader você pode conectar seu rastreador ao seu aplicativo de controle de tempo favorito.
Primeiro execute o comando com o sinalizador --setup , isso irá gerar a configuração e permitir que você rotule as laterais do seu dispositivo.
timeular-reader --setupVocê não precisa configurar todos os lados, pressione q no lado que você não deseja usar e a configuração será gerada com aqueles que você configurou.
Após a configuração inicial, você pode modificar config.toml
Para controlar a verbosidade da saída, você pode passar --verbose ou -v , você pode adicionar vários -vvv para torná-lo mais detalhado.
Há também o modo --quiet , -q para silenciar todas as saídas.
Para obter o ID do projeto e o ID do espaço de trabalho, no painel esquerdo em Gerenciar, clique em Projetos. Em seguida, clique no nome do projeto que deseja usar. O URL deve ser semelhante a este https://track.toggl.com/{workspace_id}/projects/{project_id}/team
Para gerar sua chave de API, acesse as configurações do seu perfil no canto superior direito. Depois de rolar para baixo, você verá uma opção para gerar uma chave de API.
Para obter o ID do seu espaço de trabalho, no canto superior direito, clique em Seu espaço de trabalho, vá para Gerenciar e depois configurações, você deve ter o ID do espaço de trabalho no URL. Deve ser algo como isto https://app.clockify.me/workspaces/{workspace_id}/settings
Observe que o ID do projeto é opcional
Para obter o ID do seu projeto no lado esquerdo, clique em projetos e, em seguida, clique nos seus projetos. O URL conterá o ID do projeto. Deve ser algo como isto https://app.clockify.me/projects/{project_id}/edit
PENDÊNCIA
PENDÊNCIA
Primeiro você precisa criar um novo mod e registrá-lo aqui, vamos chamá-lo de example .
Você cria o mod criando um arquivo src/handler/example.rs e adicionando pub mod example; no arquivo vinculado acima. O example.rs deve ter uma função pública chamada async create_handler(setup: bool) , e essa função deve retornar uma estrutura que implemente Handler A implementação precisa da anotação #[async_trait]
É mais provável que seu mod exija alguma configuração. Você pode implementar tudo no arquivo example.rs principal, mas para mantê-lo limpo, recomendo declarar new mod config . O mod de configuração será responsável por criar uma configuração padrão e salvá-la no arquivo de configuração principal config.toml .
Primeiro precisamos adicionar pub mod config; para example.rs e crie o arquivo src/handler/example/config.rs . No config.rs precisamos criar uma estrutura que conterá todos os dados de configuração que precisaremos, vamos chamá-la de ExampleConfig .
As derivadas são necessárias
# [ derive ( Serialize , Deserialize , Clone , Debug ) ]
pub struct ExampleConfig {
base_url : String ,
api_key : String ,
} Precisamos então implementar Default e crate::config::Config . A implementação Default pode criar a estrutura com coisas que não mudam muito, como um URL base de API. Por exemplo:
impl Default for ExampleConfig {
fn default ( ) -> Self {
ExampleConfig {
base_url : String :: from ( "https://api.example.com" ) ,
api_key : String :: new ( ) ,
}
}
} A implementação crate::config::Config pode estar vazia, trata-se apenas de herdar o tipo e uma vida inteira, pode ser assim:
impl < ' de > Config < ' de > for ExampleConfig { }Se quiser salvar sua configuração no arquivo de configuração principal, você precisa ter uma chave exclusiva na qual ela será salva.
Por conveniência, você pode implementar métodos para obter e atualizar a configuração (de/para um arquivo). Caso contrário, você terá que chamar crate::config::get_config e crate::config::update_config . Essas funções podem ser assim:
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 ) ; }
Depois disso precisamos registrar o novo manipulador. Em src/handler.rs você precisa adicionar nosso Example de mod ao enum Handlers e atribuir-lhe um número.
pub enum Handlers {
Toggl = 1,
Clockify = 2,
Traggo = 3,
Hackaru = 4,
+ Example = 5,
} então precisamos ajustar TryFrom :
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(()),
}
} o mesmo em 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(()),
}
}
A última coisa a fazer é ajustar o método de fábrica, em get_handler :
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),
}
} Eu adicionei o rastreador de exemplo ao repositório, você pode basear seu módulo nele.
Simplesmente execute
cargo build
