From 7a3b5aa6a3bd556dac87b372f28725091ff744b8 Mon Sep 17 00:00:00 2001 From: David Rousselie Date: Mon, 17 Jan 2022 19:54:49 +0100 Subject: [PATCH] Refactor modules --- src/contextswitch.rs | 49 ----------------------- src/contextswitch/api.rs | 17 ++++++++ src/contextswitch/mod.rs | 4 ++ src/{ => contextswitch}/taskwarrior.rs | 44 +++++++++++++++++++-- src/lib.rs | 54 +++++--------------------- src/main.rs | 2 +- src/routes/health_check.rs | 5 +++ src/routes/mod.rs | 5 +++ src/routes/tasks.rs | 38 ++++++++++++++++++ tests/task.rs | 14 +++---- tests/test_helper.rs | 2 +- 11 files changed, 126 insertions(+), 108 deletions(-) delete mode 100644 src/contextswitch.rs create mode 100644 src/contextswitch/api.rs create mode 100644 src/contextswitch/mod.rs rename src/{ => contextswitch}/taskwarrior.rs (76%) create mode 100644 src/routes/health_check.rs create mode 100644 src/routes/mod.rs create mode 100644 src/routes/tasks.rs diff --git a/src/contextswitch.rs b/src/contextswitch.rs deleted file mode 100644 index f5187c2..0000000 --- a/src/contextswitch.rs +++ /dev/null @@ -1,49 +0,0 @@ -use crate::taskwarrior; -use contextswitch_types::{ContextSwitchMetadata, Task}; -use std::io::Error; - -impl TryFrom<&taskwarrior::Task> for Task { - type Error = std::io::Error; - - fn try_from(task: &taskwarrior::Task) -> Result { - let cs_metadata = task.contextswitch.as_ref().map_or( - Ok(None), - |cs_string| -> Result, serde_json::Error> { - if cs_string.is_empty() || cs_string == "{}" { - Ok(None) - } else { - Some(serde_json::from_str(cs_string)).transpose() - } - }, - )?; - - Ok(Task { - uuid: task.uuid, - id: task.id, - entry: task.entry, - modified: task.modified, - status: task.status, - description: task.description.clone(), - //urgency: task.urgency, - due: task.due, - end: task.end, - parent: task.parent, - project: task.project.clone(), - recur: task.recur, - tags: task.tags.clone(), - contextswitch: cs_metadata, - }) - } -} - -pub fn export(filters: Vec<&str>) -> Result, Error> { - let tasks: Result, Error> = taskwarrior::export(filters)? - .iter() - .map(Task::try_from) - .collect(); - tasks -} - -pub async fn add(add_args: Vec<&str>) -> Result { - taskwarrior::add(add_args).await -} diff --git a/src/contextswitch/api.rs b/src/contextswitch/api.rs new file mode 100644 index 0000000..70a0bdc --- /dev/null +++ b/src/contextswitch/api.rs @@ -0,0 +1,17 @@ +use crate::contextswitch::taskwarrior; +use contextswitch_types::Task; +use std::io::Error; + +#[tracing::instrument(level = "debug")] +pub fn list_tasks(filters: Vec<&str>) -> Result, Error> { + let tasks: Result, Error> = taskwarrior::list_tasks(filters)? + .iter() + .map(Task::try_from) + .collect(); + tasks +} + +#[tracing::instrument(level = "debug")] +pub async fn add_task(add_args: Vec<&str>) -> Result { + taskwarrior::add_task(add_args).await +} diff --git a/src/contextswitch/mod.rs b/src/contextswitch/mod.rs new file mode 100644 index 0000000..dba2f42 --- /dev/null +++ b/src/contextswitch/mod.rs @@ -0,0 +1,4 @@ +mod api; +pub mod taskwarrior; + +pub use api::*; diff --git a/src/taskwarrior.rs b/src/contextswitch/taskwarrior.rs similarity index 76% rename from src/taskwarrior.rs rename to src/contextswitch/taskwarrior.rs index cec4dc9..1404786 100644 --- a/src/taskwarrior.rs +++ b/src/contextswitch/taskwarrior.rs @@ -1,5 +1,7 @@ use chrono::{DateTime, Utc}; use configparser::ini::Ini; +use contextswitch_types::ContextSwitchMetadata; +use contextswitch_types::Task; use regex::Regex; use serde::{Deserialize, Serialize}; use serde_json; @@ -13,7 +15,7 @@ use tracing::debug; use uuid::Uuid; #[derive(Debug, Serialize, Deserialize, PartialEq)] -pub struct Task { +pub struct TaskwarriorTask { pub uuid: Uuid, pub id: u64, #[serde(with = "contextswitch_types::tw_date_format")] @@ -47,6 +49,40 @@ pub struct Task { pub contextswitch: Option, } +impl TryFrom<&TaskwarriorTask> for Task { + type Error = std::io::Error; + + fn try_from(task: &TaskwarriorTask) -> Result { + let cs_metadata = task.contextswitch.as_ref().map_or( + Ok(None), + |cs_string| -> Result, serde_json::Error> { + if cs_string.is_empty() || cs_string == "{}" { + Ok(None) + } else { + Some(serde_json::from_str(cs_string)).transpose() + } + }, + )?; + + Ok(Task { + uuid: task.uuid, + id: task.id, + entry: task.entry, + modified: task.modified, + status: task.status, + description: task.description.clone(), + //urgency: task.urgency, + due: task.due, + end: task.end, + parent: task.parent, + project: task.project.clone(), + recur: task.recur, + tags: task.tags.clone(), + contextswitch: cs_metadata, + }) + } +} + fn write_default_config(data_location: &str) -> String { let mut taskrc = Ini::new(); taskrc.setstr("default", "data.location", Some(data_location)); @@ -100,17 +136,17 @@ pub fn load_config(task_data_location: Option<&str>) -> String { } #[tracing::instrument(level = "debug")] -pub fn export(filters: Vec<&str>) -> Result, Error> { +pub fn list_tasks(filters: Vec<&str>) -> Result, Error> { let args = [filters, vec!["export"]].concat(); let export_output = Command::new("task").args(args).output()?; - let tasks: Vec = serde_json::from_slice(&export_output.stdout)?; + let tasks: Vec = serde_json::from_slice(&export_output.stdout)?; Ok(tasks) } #[tracing::instrument(level = "debug")] -pub async fn add(add_args: Vec<&str>) -> Result { +pub async fn add_task(add_args: Vec<&str>) -> Result { lazy_static! { static ref RE: Regex = Regex::new(r"Created task (?P\d+).").unwrap(); static ref LOCK: Mutex = Mutex::new(0); diff --git a/src/lib.rs b/src/lib.rs index deff222..8819b58 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -1,10 +1,6 @@ -use actix_web::{dev::Server, http, middleware, web, App, HttpResponse, HttpServer}; -use contextswitch_types::TaskDefinition; +use actix_web::{dev::Server, http, middleware, web, App, HttpServer}; use listenfd::ListenFd; -use serde::Deserialize; -use serde_json::json; use std::env; -use std::io::Error; use std::net::TcpListener; use tracing_actix_web::TracingLogger; @@ -13,42 +9,7 @@ extern crate lazy_static; pub mod contextswitch; pub mod observability; -pub mod taskwarrior; - -#[derive(Deserialize)] -struct TaskQuery { - filter: Option, -} - -#[tracing::instrument(level = "debug", skip_all, fields(filter = %task_query.filter.as_ref().unwrap_or(&"".to_string())))] -async fn list_tasks(task_query: web::Query) -> Result { - let filter = task_query - .filter - .as_ref() - .map_or(vec![], |filter| filter.split(' ').collect()); - let tasks = contextswitch::export(filter)?; - - Ok(HttpResponse::Ok() - .content_type("application/json") - .body(serde_json::to_string(&tasks)?)) -} - -#[tracing::instrument(level = "debug", skip_all, fields(definition = %task_definition.definition))] -async fn add_task(task_definition: web::Json) -> Result { - let task_id = contextswitch::add(task_definition.definition.split(' ').collect()).await?; - - Ok(HttpResponse::Ok() - .content_type("application/json") - .body(json!({ "id": task_id }).to_string())) -} - -async fn option_task() -> HttpResponse { - HttpResponse::Ok().finish() -} - -async fn health_check() -> HttpResponse { - HttpResponse::Ok().finish() -} +pub mod routes; pub fn run(listener: TcpListener) -> Result { let cs_front_base_url = @@ -66,10 +27,13 @@ pub fn run(listener: TcpListener) -> Result { )) .add(("Access-Control-Allow-Headers", "content-type".as_bytes())), ) - .route("/ping", web::get().to(health_check)) - .route("/tasks", web::get().to(list_tasks)) - .route("/tasks", web::post().to(add_task)) - .route("/tasks", web::method(http::Method::OPTIONS).to(option_task)) + .route("/ping", web::get().to(routes::ping)) + .route("/tasks", web::get().to(routes::list_tasks)) + .route("/tasks", web::post().to(routes::add_task)) + .route( + "/tasks", + web::method(http::Method::OPTIONS).to(routes::option_task), + ) }) .keep_alive(60) .shutdown_timeout(60); diff --git a/src/main.rs b/src/main.rs index f1629f6..75dcede 100644 --- a/src/main.rs +++ b/src/main.rs @@ -2,7 +2,7 @@ extern crate dotenv; extern crate listenfd; use contextswitch_api::observability::{get_subscriber, init_subscriber}; -use contextswitch_api::{run, taskwarrior}; +use contextswitch_api::{contextswitch::taskwarrior, run}; use dotenv::dotenv; use std::env; use std::net::TcpListener; diff --git a/src/routes/health_check.rs b/src/routes/health_check.rs new file mode 100644 index 0000000..d6cb8bd --- /dev/null +++ b/src/routes/health_check.rs @@ -0,0 +1,5 @@ +use actix_web::HttpResponse; + +pub async fn ping() -> HttpResponse { + HttpResponse::Ok().finish() +} diff --git a/src/routes/mod.rs b/src/routes/mod.rs new file mode 100644 index 0000000..d25595d --- /dev/null +++ b/src/routes/mod.rs @@ -0,0 +1,5 @@ +mod health_check; +mod tasks; + +pub use health_check::*; +pub use tasks::*; diff --git a/src/routes/tasks.rs b/src/routes/tasks.rs new file mode 100644 index 0000000..f85b2f1 --- /dev/null +++ b/src/routes/tasks.rs @@ -0,0 +1,38 @@ +use crate::contextswitch; +use actix_web::{web, HttpResponse}; +use contextswitch_types::TaskDefinition; +use serde::Deserialize; +use serde_json::json; +use std::io::Error; + +#[derive(Deserialize)] +pub struct TaskQuery { + filter: Option, +} + +#[tracing::instrument(level = "debug", skip_all, fields(filter = %task_query.filter.as_ref().unwrap_or(&"".to_string())))] +pub async fn list_tasks(task_query: web::Query) -> Result { + let filter = task_query + .filter + .as_ref() + .map_or(vec![], |filter| filter.split(' ').collect()); + let tasks = contextswitch::list_tasks(filter)?; + + Ok(HttpResponse::Ok() + .content_type("application/json") + .body(serde_json::to_string(&tasks)?)) +} + +#[tracing::instrument(level = "debug", skip_all, fields(definition = %task_definition.definition))] +pub async fn add_task(task_definition: web::Json) -> Result { + let task_id = contextswitch::add_task(task_definition.definition.split(' ').collect()).await?; + + Ok(HttpResponse::Ok() + .content_type("application/json") + .body(json!({ "id": task_id }).to_string())) +} + +#[tracing::instrument(level = "debug")] +pub fn option_task() -> HttpResponse { + HttpResponse::Ok().finish() +} diff --git a/tests/task.rs b/tests/task.rs index 09c29be..b7ec35c 100644 --- a/tests/task.rs +++ b/tests/task.rs @@ -1,6 +1,6 @@ pub mod test_helper; -use contextswitch_api::taskwarrior; +use contextswitch_api::contextswitch::taskwarrior; use contextswitch_types::Task; use contextswitch_types::TaskDefinition; use rstest::*; @@ -9,11 +9,11 @@ use test_helper::app_address; #[rstest] #[tokio::test] async fn list_tasks(app_address: &str) { - let task_id = taskwarrior::add(vec!["test", "list_tasks", "contextswitch:'{\"test\": 1}'"]) - .await - .unwrap(); + let task_id = + taskwarrior::add_task(vec!["test", "list_tasks", "contextswitch:'{\"test\": 1}'"]) + .await + .unwrap(); - println!("LIST TASKS ID: {}", task_id); let tasks: Vec = reqwest::Client::new() .get(&format!("{}/tasks?filter={}", &app_address, task_id)) .send() @@ -43,10 +43,8 @@ async fn add_task(app_address: &str) { .json() .await .expect("Cannot parse JSON result"); - println!("ADD RESPONSE: {:?}", response); let new_task_id = response["id"].as_u64().unwrap(); - let tasks = taskwarrior::export(vec![&new_task_id.to_string()]).unwrap(); - println!("TASKS={:?}", tasks); + let tasks = taskwarrior::list_tasks(vec![&new_task_id.to_string()]).unwrap(); assert_eq!(tasks.len(), 1); assert_eq!(tasks[0].id, new_task_id); diff --git a/tests/test_helper.rs b/tests/test_helper.rs index 8f1a119..a417a99 100644 --- a/tests/test_helper.rs +++ b/tests/test_helper.rs @@ -1,5 +1,5 @@ +use contextswitch_api::contextswitch::taskwarrior; use contextswitch_api::observability::{get_subscriber, init_subscriber}; -use contextswitch_api::taskwarrior; use mktemp::Temp; use rstest::*; use std::fs;