use reqwest;
use super::{configuration, Error};
use crate::apis::ResponseContent;
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum AddDependenciesForTaskError {
Status400(crate::models::ErrorResponse),
Status401(crate::models::ErrorResponse),
Status403(crate::models::ErrorResponse),
Status404(crate::models::ErrorResponse),
Status500(crate::models::ErrorResponse),
UnknownValue(serde_json::Value),
}
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum AddDependentsForTaskError {
Status400(crate::models::ErrorResponse),
Status401(crate::models::ErrorResponse),
Status403(crate::models::ErrorResponse),
Status404(crate::models::ErrorResponse),
Status500(crate::models::ErrorResponse),
UnknownValue(serde_json::Value),
}
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum AddFollowersForTaskError {
Status400(crate::models::ErrorResponse),
Status401(crate::models::ErrorResponse),
Status403(crate::models::ErrorResponse),
Status404(crate::models::ErrorResponse),
Status500(crate::models::ErrorResponse),
UnknownValue(serde_json::Value),
}
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum AddProjectForTaskError {
Status400(crate::models::ErrorResponse),
Status401(crate::models::ErrorResponse),
Status403(crate::models::ErrorResponse),
Status404(crate::models::ErrorResponse),
Status500(crate::models::ErrorResponse),
UnknownValue(serde_json::Value),
}
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum AddTagForTaskError {
Status400(crate::models::ErrorResponse),
Status401(crate::models::ErrorResponse),
Status403(crate::models::ErrorResponse),
Status404(crate::models::ErrorResponse),
Status500(crate::models::ErrorResponse),
UnknownValue(serde_json::Value),
}
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum CreateSubtaskForTaskError {
Status400(crate::models::ErrorResponse),
Status401(crate::models::ErrorResponse),
Status403(crate::models::ErrorResponse),
Status404(crate::models::ErrorResponse),
Status500(crate::models::ErrorResponse),
UnknownValue(serde_json::Value),
}
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum CreateTaskError {
Status400(crate::models::ErrorResponse),
Status401(crate::models::ErrorResponse),
Status403(crate::models::ErrorResponse),
Status404(crate::models::ErrorResponse),
Status500(crate::models::ErrorResponse),
UnknownValue(serde_json::Value),
}
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum DeleteTaskError {
Status400(crate::models::ErrorResponse),
Status401(crate::models::ErrorResponse),
Status403(crate::models::ErrorResponse),
Status404(crate::models::ErrorResponse),
Status500(crate::models::ErrorResponse),
UnknownValue(serde_json::Value),
}
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum DuplicateTaskError {
Status400(crate::models::ErrorResponse),
Status401(crate::models::ErrorResponse),
Status403(crate::models::ErrorResponse),
Status404(crate::models::ErrorResponse),
Status500(crate::models::ErrorResponse),
UnknownValue(serde_json::Value),
}
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum GetDependenciesForTaskError {
Status400(crate::models::ErrorResponse),
Status401(crate::models::ErrorResponse),
Status403(crate::models::ErrorResponse),
Status404(crate::models::ErrorResponse),
Status500(crate::models::ErrorResponse),
UnknownValue(serde_json::Value),
}
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum GetDependentsForTaskError {
Status400(crate::models::ErrorResponse),
Status401(crate::models::ErrorResponse),
Status403(crate::models::ErrorResponse),
Status404(crate::models::ErrorResponse),
Status500(crate::models::ErrorResponse),
UnknownValue(serde_json::Value),
}
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum GetSubtasksForTaskError {
Status400(crate::models::ErrorResponse),
Status401(crate::models::ErrorResponse),
Status403(crate::models::ErrorResponse),
Status404(crate::models::ErrorResponse),
Status500(crate::models::ErrorResponse),
UnknownValue(serde_json::Value),
}
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum GetTaskError {
Status400(crate::models::ErrorResponse),
Status401(crate::models::ErrorResponse),
Status403(crate::models::ErrorResponse),
Status404(crate::models::ErrorResponse),
Status500(crate::models::ErrorResponse),
UnknownValue(serde_json::Value),
}
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum GetTasksError {
Status400(crate::models::ErrorResponse),
Status401(crate::models::ErrorResponse),
Status403(crate::models::ErrorResponse),
Status404(crate::models::ErrorResponse),
Status500(crate::models::ErrorResponse),
UnknownValue(serde_json::Value),
}
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum GetTasksForProjectError {
Status400(crate::models::ErrorResponse),
Status401(crate::models::ErrorResponse),
Status403(crate::models::ErrorResponse),
Status404(crate::models::ErrorResponse),
Status500(crate::models::ErrorResponse),
UnknownValue(serde_json::Value),
}
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum GetTasksForSectionError {
Status400(crate::models::ErrorResponse),
Status401(crate::models::ErrorResponse),
Status403(crate::models::ErrorResponse),
Status404(crate::models::ErrorResponse),
Status500(crate::models::ErrorResponse),
UnknownValue(serde_json::Value),
}
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum GetTasksForTagError {
Status400(crate::models::ErrorResponse),
Status401(crate::models::ErrorResponse),
Status403(crate::models::ErrorResponse),
Status404(crate::models::ErrorResponse),
Status500(crate::models::ErrorResponse),
UnknownValue(serde_json::Value),
}
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum GetTasksForUserTaskListError {
Status400(crate::models::ErrorResponse),
Status401(crate::models::ErrorResponse),
Status403(crate::models::ErrorResponse),
Status404(crate::models::ErrorResponse),
Status500(crate::models::ErrorResponse),
UnknownValue(serde_json::Value),
}
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum RemoveDependenciesForTaskError {
Status400(crate::models::ErrorResponse),
Status401(crate::models::ErrorResponse),
Status403(crate::models::ErrorResponse),
Status404(crate::models::ErrorResponse),
Status500(crate::models::ErrorResponse),
UnknownValue(serde_json::Value),
}
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum RemoveDependentsForTaskError {
Status400(crate::models::ErrorResponse),
Status401(crate::models::ErrorResponse),
Status403(crate::models::ErrorResponse),
Status404(crate::models::ErrorResponse),
Status500(crate::models::ErrorResponse),
UnknownValue(serde_json::Value),
}
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum RemoveFollowerForTaskError {
Status400(crate::models::ErrorResponse),
Status401(crate::models::ErrorResponse),
Status403(crate::models::ErrorResponse),
Status404(crate::models::ErrorResponse),
Status500(crate::models::ErrorResponse),
UnknownValue(serde_json::Value),
}
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum RemoveProjectForTaskError {
Status400(crate::models::ErrorResponse),
Status401(crate::models::ErrorResponse),
Status403(crate::models::ErrorResponse),
Status404(crate::models::ErrorResponse),
Status500(crate::models::ErrorResponse),
UnknownValue(serde_json::Value),
}
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum RemoveTagForTaskError {
Status400(crate::models::ErrorResponse),
Status401(crate::models::ErrorResponse),
Status403(crate::models::ErrorResponse),
Status404(crate::models::ErrorResponse),
Status500(crate::models::ErrorResponse),
UnknownValue(serde_json::Value),
}
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum SearchTasksForWorkspaceError {
Status400(crate::models::ErrorResponse),
Status401(crate::models::ErrorResponse),
Status403(crate::models::ErrorResponse),
Status404(crate::models::ErrorResponse),
Status500(crate::models::ErrorResponse),
UnknownValue(serde_json::Value),
}
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum SetParentForTaskError {
Status400(crate::models::ErrorResponse),
Status401(crate::models::ErrorResponse),
Status403(crate::models::ErrorResponse),
Status404(crate::models::ErrorResponse),
Status500(crate::models::ErrorResponse),
UnknownValue(serde_json::Value),
}
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum UpdateTaskError {
Status400(crate::models::ErrorResponse),
Status401(crate::models::ErrorResponse),
Status403(crate::models::ErrorResponse),
Status404(crate::models::ErrorResponse),
Status500(crate::models::ErrorResponse),
UnknownValue(serde_json::Value),
}
pub async fn add_dependencies_for_task(
configuration: &configuration::Configuration,
task_gid: &str,
inline_object40: crate::models::InlineObject40,
opt_pretty: Option<bool>,
opt_fields: Option<Vec<String>>,
) -> Result<crate::models::InlineResponse2001, Error<AddDependenciesForTaskError>> {
let local_var_client = &configuration.client;
let local_var_uri_str = format!(
"{}/tasks/{task_gid}/addDependencies",
configuration.base_path,
task_gid = crate::apis::urlencode(task_gid)
);
let mut local_var_req_builder = local_var_client.post(local_var_uri_str.as_str());
if let Some(ref local_var_str) = opt_pretty {
local_var_req_builder =
local_var_req_builder.query(&[("opt_pretty", &local_var_str.to_string())]);
}
if let Some(ref local_var_str) = opt_fields {
local_var_req_builder = local_var_req_builder.query(&[(
"opt_fields",
&local_var_str
.into_iter()
.map(|p| p.to_string())
.collect::<Vec<String>>()
.join(",")
.to_string(),
)]);
}
if let Some(ref local_var_user_agent) = configuration.user_agent {
local_var_req_builder =
local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
}
if let Some(ref local_var_token) = configuration.oauth_access_token {
local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
};
if let Some(ref local_var_token) = configuration.bearer_access_token {
local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
};
local_var_req_builder = local_var_req_builder.json(&inline_object40);
let local_var_req = local_var_req_builder.build()?;
let local_var_resp = local_var_client.execute(local_var_req).await?;
let local_var_status = local_var_resp.status();
let local_var_content = local_var_resp.text().await?;
if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
serde_json::from_str(&local_var_content).map_err(Error::from)
} else {
let local_var_entity: Option<AddDependenciesForTaskError> =
serde_json::from_str(&local_var_content).ok();
let local_var_error = ResponseContent {
status: local_var_status,
content: local_var_content,
entity: local_var_entity,
};
Err(Error::ResponseError(local_var_error))
}
}
pub async fn add_dependents_for_task(
configuration: &configuration::Configuration,
task_gid: &str,
inline_object42: crate::models::InlineObject42,
opt_pretty: Option<bool>,
opt_fields: Option<Vec<String>>,
) -> Result<crate::models::InlineResponse20023, Error<AddDependentsForTaskError>> {
let local_var_client = &configuration.client;
let local_var_uri_str = format!(
"{}/tasks/{task_gid}/addDependents",
configuration.base_path,
task_gid = crate::apis::urlencode(task_gid)
);
let mut local_var_req_builder = local_var_client.post(local_var_uri_str.as_str());
if let Some(ref local_var_str) = opt_pretty {
local_var_req_builder =
local_var_req_builder.query(&[("opt_pretty", &local_var_str.to_string())]);
}
if let Some(ref local_var_str) = opt_fields {
local_var_req_builder = local_var_req_builder.query(&[(
"opt_fields",
&local_var_str
.into_iter()
.map(|p| p.to_string())
.collect::<Vec<String>>()
.join(",")
.to_string(),
)]);
}
if let Some(ref local_var_user_agent) = configuration.user_agent {
local_var_req_builder =
local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
}
if let Some(ref local_var_token) = configuration.oauth_access_token {
local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
};
if let Some(ref local_var_token) = configuration.bearer_access_token {
local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
};
local_var_req_builder = local_var_req_builder.json(&inline_object42);
let local_var_req = local_var_req_builder.build()?;
let local_var_resp = local_var_client.execute(local_var_req).await?;
let local_var_status = local_var_resp.status();
let local_var_content = local_var_resp.text().await?;
if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
serde_json::from_str(&local_var_content).map_err(Error::from)
} else {
let local_var_entity: Option<AddDependentsForTaskError> =
serde_json::from_str(&local_var_content).ok();
let local_var_error = ResponseContent {
status: local_var_status,
content: local_var_content,
entity: local_var_entity,
};
Err(Error::ResponseError(local_var_error))
}
}
pub async fn add_followers_for_task(
configuration: &configuration::Configuration,
task_gid: &str,
inline_object48: crate::models::InlineObject48,
opt_pretty: Option<bool>,
opt_fields: Option<Vec<String>>,
) -> Result<crate::models::InlineResponse2001, Error<AddFollowersForTaskError>> {
let local_var_client = &configuration.client;
let local_var_uri_str = format!(
"{}/tasks/{task_gid}/addFollowers",
configuration.base_path,
task_gid = crate::apis::urlencode(task_gid)
);
let mut local_var_req_builder = local_var_client.post(local_var_uri_str.as_str());
if let Some(ref local_var_str) = opt_pretty {
local_var_req_builder =
local_var_req_builder.query(&[("opt_pretty", &local_var_str.to_string())]);
}
if let Some(ref local_var_str) = opt_fields {
local_var_req_builder = local_var_req_builder.query(&[(
"opt_fields",
&local_var_str
.into_iter()
.map(|p| p.to_string())
.collect::<Vec<String>>()
.join(",")
.to_string(),
)]);
}
if let Some(ref local_var_user_agent) = configuration.user_agent {
local_var_req_builder =
local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
}
if let Some(ref local_var_token) = configuration.oauth_access_token {
local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
};
if let Some(ref local_var_token) = configuration.bearer_access_token {
local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
};
local_var_req_builder = local_var_req_builder.json(&inline_object48);
let local_var_req = local_var_req_builder.build()?;
let local_var_resp = local_var_client.execute(local_var_req).await?;
let local_var_status = local_var_resp.status();
let local_var_content = local_var_resp.text().await?;
if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
serde_json::from_str(&local_var_content).map_err(Error::from)
} else {
let local_var_entity: Option<AddFollowersForTaskError> =
serde_json::from_str(&local_var_content).ok();
let local_var_error = ResponseContent {
status: local_var_status,
content: local_var_content,
entity: local_var_entity,
};
Err(Error::ResponseError(local_var_error))
}
}
pub async fn add_project_for_task(
configuration: &configuration::Configuration,
task_gid: &str,
inline_object44: crate::models::InlineObject44,
opt_pretty: Option<bool>,
opt_fields: Option<Vec<String>>,
) -> Result<crate::models::InlineResponse2001, Error<AddProjectForTaskError>> {
let local_var_client = &configuration.client;
let local_var_uri_str = format!(
"{}/tasks/{task_gid}/addProject",
configuration.base_path,
task_gid = crate::apis::urlencode(task_gid)
);
let mut local_var_req_builder = local_var_client.post(local_var_uri_str.as_str());
if let Some(ref local_var_str) = opt_pretty {
local_var_req_builder =
local_var_req_builder.query(&[("opt_pretty", &local_var_str.to_string())]);
}
if let Some(ref local_var_str) = opt_fields {
local_var_req_builder = local_var_req_builder.query(&[(
"opt_fields",
&local_var_str
.into_iter()
.map(|p| p.to_string())
.collect::<Vec<String>>()
.join(",")
.to_string(),
)]);
}
if let Some(ref local_var_user_agent) = configuration.user_agent {
local_var_req_builder =
local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
}
if let Some(ref local_var_token) = configuration.oauth_access_token {
local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
};
if let Some(ref local_var_token) = configuration.bearer_access_token {
local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
};
local_var_req_builder = local_var_req_builder.json(&inline_object44);
let local_var_req = local_var_req_builder.build()?;
let local_var_resp = local_var_client.execute(local_var_req).await?;
let local_var_status = local_var_resp.status();
let local_var_content = local_var_resp.text().await?;
if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
serde_json::from_str(&local_var_content).map_err(Error::from)
} else {
let local_var_entity: Option<AddProjectForTaskError> =
serde_json::from_str(&local_var_content).ok();
let local_var_error = ResponseContent {
status: local_var_status,
content: local_var_content,
entity: local_var_entity,
};
Err(Error::ResponseError(local_var_error))
}
}
pub async fn add_tag_for_task(
configuration: &configuration::Configuration,
task_gid: &str,
inline_object46: crate::models::InlineObject46,
opt_pretty: Option<bool>,
opt_fields: Option<Vec<String>>,
) -> Result<crate::models::InlineResponse2001, Error<AddTagForTaskError>> {
let local_var_client = &configuration.client;
let local_var_uri_str = format!(
"{}/tasks/{task_gid}/addTag",
configuration.base_path,
task_gid = crate::apis::urlencode(task_gid)
);
let mut local_var_req_builder = local_var_client.post(local_var_uri_str.as_str());
if let Some(ref local_var_str) = opt_pretty {
local_var_req_builder =
local_var_req_builder.query(&[("opt_pretty", &local_var_str.to_string())]);
}
if let Some(ref local_var_str) = opt_fields {
local_var_req_builder = local_var_req_builder.query(&[(
"opt_fields",
&local_var_str
.into_iter()
.map(|p| p.to_string())
.collect::<Vec<String>>()
.join(",")
.to_string(),
)]);
}
if let Some(ref local_var_user_agent) = configuration.user_agent {
local_var_req_builder =
local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
}
if let Some(ref local_var_token) = configuration.oauth_access_token {
local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
};
if let Some(ref local_var_token) = configuration.bearer_access_token {
local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
};
local_var_req_builder = local_var_req_builder.json(&inline_object46);
let local_var_req = local_var_req_builder.build()?;
let local_var_resp = local_var_client.execute(local_var_req).await?;
let local_var_status = local_var_resp.status();
let local_var_content = local_var_resp.text().await?;
if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
serde_json::from_str(&local_var_content).map_err(Error::from)
} else {
let local_var_entity: Option<AddTagForTaskError> =
serde_json::from_str(&local_var_content).ok();
let local_var_error = ResponseContent {
status: local_var_status,
content: local_var_content,
entity: local_var_entity,
};
Err(Error::ResponseError(local_var_error))
}
}
pub async fn create_subtask_for_task(
configuration: &configuration::Configuration,
task_gid: &str,
inline_object38: crate::models::InlineObject38,
opt_pretty: Option<bool>,
opt_fields: Option<Vec<String>>,
) -> Result<crate::models::InlineResponse2016, Error<CreateSubtaskForTaskError>> {
let local_var_client = &configuration.client;
let local_var_uri_str = format!(
"{}/tasks/{task_gid}/subtasks",
configuration.base_path,
task_gid = crate::apis::urlencode(task_gid)
);
let mut local_var_req_builder = local_var_client.post(local_var_uri_str.as_str());
if let Some(ref local_var_str) = opt_pretty {
local_var_req_builder =
local_var_req_builder.query(&[("opt_pretty", &local_var_str.to_string())]);
}
if let Some(ref local_var_str) = opt_fields {
local_var_req_builder = local_var_req_builder.query(&[(
"opt_fields",
&local_var_str
.into_iter()
.map(|p| p.to_string())
.collect::<Vec<String>>()
.join(",")
.to_string(),
)]);
}
if let Some(ref local_var_user_agent) = configuration.user_agent {
local_var_req_builder =
local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
}
if let Some(ref local_var_token) = configuration.oauth_access_token {
local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
};
if let Some(ref local_var_token) = configuration.bearer_access_token {
local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
};
local_var_req_builder = local_var_req_builder.json(&inline_object38);
let local_var_req = local_var_req_builder.build()?;
let local_var_resp = local_var_client.execute(local_var_req).await?;
let local_var_status = local_var_resp.status();
let local_var_content = local_var_resp.text().await?;
if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
serde_json::from_str(&local_var_content).map_err(Error::from)
} else {
let local_var_entity: Option<CreateSubtaskForTaskError> =
serde_json::from_str(&local_var_content).ok();
let local_var_error = ResponseContent {
status: local_var_status,
content: local_var_content,
entity: local_var_entity,
};
Err(Error::ResponseError(local_var_error))
}
}
pub async fn create_task(
configuration: &configuration::Configuration,
inline_object35: crate::models::InlineObject35,
opt_pretty: Option<bool>,
opt_fields: Option<Vec<String>>,
) -> Result<crate::models::InlineResponse2016, Error<CreateTaskError>> {
let local_var_client = &configuration.client;
let local_var_uri_str = format!("{}/tasks", configuration.base_path);
let mut local_var_req_builder = local_var_client.post(local_var_uri_str.as_str());
if let Some(ref local_var_str) = opt_pretty {
local_var_req_builder =
local_var_req_builder.query(&[("opt_pretty", &local_var_str.to_string())]);
}
if let Some(ref local_var_str) = opt_fields {
local_var_req_builder = local_var_req_builder.query(&[(
"opt_fields",
&local_var_str
.into_iter()
.map(|p| p.to_string())
.collect::<Vec<String>>()
.join(",")
.to_string(),
)]);
}
if let Some(ref local_var_user_agent) = configuration.user_agent {
local_var_req_builder =
local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
}
if let Some(ref local_var_token) = configuration.oauth_access_token {
local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
};
if let Some(ref local_var_token) = configuration.bearer_access_token {
local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
};
local_var_req_builder = local_var_req_builder.json(&inline_object35);
let local_var_req = local_var_req_builder.build()?;
let local_var_resp = local_var_client.execute(local_var_req).await?;
let local_var_status = local_var_resp.status();
let local_var_content = local_var_resp.text().await?;
if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
serde_json::from_str(&local_var_content).map_err(Error::from)
} else {
let local_var_entity: Option<CreateTaskError> =
serde_json::from_str(&local_var_content).ok();
let local_var_error = ResponseContent {
status: local_var_status,
content: local_var_content,
entity: local_var_entity,
};
Err(Error::ResponseError(local_var_error))
}
}
pub async fn delete_task(
configuration: &configuration::Configuration,
task_gid: &str,
opt_pretty: Option<bool>,
opt_fields: Option<Vec<String>>,
) -> Result<crate::models::InlineResponse2001, Error<DeleteTaskError>> {
let local_var_client = &configuration.client;
let local_var_uri_str = format!(
"{}/tasks/{task_gid}",
configuration.base_path,
task_gid = crate::apis::urlencode(task_gid)
);
let mut local_var_req_builder = local_var_client.delete(local_var_uri_str.as_str());
if let Some(ref local_var_str) = opt_pretty {
local_var_req_builder =
local_var_req_builder.query(&[("opt_pretty", &local_var_str.to_string())]);
}
if let Some(ref local_var_str) = opt_fields {
local_var_req_builder = local_var_req_builder.query(&[(
"opt_fields",
&local_var_str
.into_iter()
.map(|p| p.to_string())
.collect::<Vec<String>>()
.join(",")
.to_string(),
)]);
}
if let Some(ref local_var_user_agent) = configuration.user_agent {
local_var_req_builder =
local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
}
if let Some(ref local_var_token) = configuration.oauth_access_token {
local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
};
if let Some(ref local_var_token) = configuration.bearer_access_token {
local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
};
let local_var_req = local_var_req_builder.build()?;
let local_var_resp = local_var_client.execute(local_var_req).await?;
let local_var_status = local_var_resp.status();
let local_var_content = local_var_resp.text().await?;
if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
serde_json::from_str(&local_var_content).map_err(Error::from)
} else {
let local_var_entity: Option<DeleteTaskError> =
serde_json::from_str(&local_var_content).ok();
let local_var_error = ResponseContent {
status: local_var_status,
content: local_var_content,
entity: local_var_entity,
};
Err(Error::ResponseError(local_var_error))
}
}
pub async fn duplicate_task(
configuration: &configuration::Configuration,
task_gid: &str,
inline_object37: crate::models::InlineObject37,
opt_pretty: Option<bool>,
opt_fields: Option<Vec<String>>,
) -> Result<crate::models::InlineResponse2007, Error<DuplicateTaskError>> {
let local_var_client = &configuration.client;
let local_var_uri_str = format!(
"{}/tasks/{task_gid}/duplicate",
configuration.base_path,
task_gid = crate::apis::urlencode(task_gid)
);
let mut local_var_req_builder = local_var_client.post(local_var_uri_str.as_str());
if let Some(ref local_var_str) = opt_pretty {
local_var_req_builder =
local_var_req_builder.query(&[("opt_pretty", &local_var_str.to_string())]);
}
if let Some(ref local_var_str) = opt_fields {
local_var_req_builder = local_var_req_builder.query(&[(
"opt_fields",
&local_var_str
.into_iter()
.map(|p| p.to_string())
.collect::<Vec<String>>()
.join(",")
.to_string(),
)]);
}
if let Some(ref local_var_user_agent) = configuration.user_agent {
local_var_req_builder =
local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
}
if let Some(ref local_var_token) = configuration.oauth_access_token {
local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
};
if let Some(ref local_var_token) = configuration.bearer_access_token {
local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
};
local_var_req_builder = local_var_req_builder.json(&inline_object37);
let local_var_req = local_var_req_builder.build()?;
let local_var_resp = local_var_client.execute(local_var_req).await?;
let local_var_status = local_var_resp.status();
let local_var_content = local_var_resp.text().await?;
if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
serde_json::from_str(&local_var_content).map_err(Error::from)
} else {
let local_var_entity: Option<DuplicateTaskError> =
serde_json::from_str(&local_var_content).ok();
let local_var_error = ResponseContent {
status: local_var_status,
content: local_var_content,
entity: local_var_entity,
};
Err(Error::ResponseError(local_var_error))
}
}
pub async fn get_dependencies_for_task(
configuration: &configuration::Configuration,
task_gid: &str,
opt_pretty: Option<bool>,
opt_fields: Option<Vec<String>>,
limit: Option<i32>,
offset: Option<&str>,
) -> Result<crate::models::InlineResponse20023, Error<GetDependenciesForTaskError>> {
let local_var_client = &configuration.client;
let local_var_uri_str = format!(
"{}/tasks/{task_gid}/dependencies",
configuration.base_path,
task_gid = crate::apis::urlencode(task_gid)
);
let mut local_var_req_builder = local_var_client.get(local_var_uri_str.as_str());
if let Some(ref local_var_str) = opt_pretty {
local_var_req_builder =
local_var_req_builder.query(&[("opt_pretty", &local_var_str.to_string())]);
}
if let Some(ref local_var_str) = opt_fields {
local_var_req_builder = local_var_req_builder.query(&[(
"opt_fields",
&local_var_str
.into_iter()
.map(|p| p.to_string())
.collect::<Vec<String>>()
.join(",")
.to_string(),
)]);
}
if let Some(ref local_var_str) = limit {
local_var_req_builder =
local_var_req_builder.query(&[("limit", &local_var_str.to_string())]);
}
if let Some(ref local_var_str) = offset {
local_var_req_builder =
local_var_req_builder.query(&[("offset", &local_var_str.to_string())]);
}
if let Some(ref local_var_user_agent) = configuration.user_agent {
local_var_req_builder =
local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
}
if let Some(ref local_var_token) = configuration.oauth_access_token {
local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
};
if let Some(ref local_var_token) = configuration.bearer_access_token {
local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
};
let local_var_req = local_var_req_builder.build()?;
let local_var_resp = local_var_client.execute(local_var_req).await?;
let local_var_status = local_var_resp.status();
let local_var_content = local_var_resp.text().await?;
if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
serde_json::from_str(&local_var_content).map_err(Error::from)
} else {
let local_var_entity: Option<GetDependenciesForTaskError> =
serde_json::from_str(&local_var_content).ok();
let local_var_error = ResponseContent {
status: local_var_status,
content: local_var_content,
entity: local_var_entity,
};
Err(Error::ResponseError(local_var_error))
}
}
pub async fn get_dependents_for_task(
configuration: &configuration::Configuration,
task_gid: &str,
opt_pretty: Option<bool>,
opt_fields: Option<Vec<String>>,
limit: Option<i32>,
offset: Option<&str>,
) -> Result<crate::models::InlineResponse20023, Error<GetDependentsForTaskError>> {
let local_var_client = &configuration.client;
let local_var_uri_str = format!(
"{}/tasks/{task_gid}/dependents",
configuration.base_path,
task_gid = crate::apis::urlencode(task_gid)
);
let mut local_var_req_builder = local_var_client.get(local_var_uri_str.as_str());
if let Some(ref local_var_str) = opt_pretty {
local_var_req_builder =
local_var_req_builder.query(&[("opt_pretty", &local_var_str.to_string())]);
}
if let Some(ref local_var_str) = opt_fields {
local_var_req_builder = local_var_req_builder.query(&[(
"opt_fields",
&local_var_str
.into_iter()
.map(|p| p.to_string())
.collect::<Vec<String>>()
.join(",")
.to_string(),
)]);
}
if let Some(ref local_var_str) = limit {
local_var_req_builder =
local_var_req_builder.query(&[("limit", &local_var_str.to_string())]);
}
if let Some(ref local_var_str) = offset {
local_var_req_builder =
local_var_req_builder.query(&[("offset", &local_var_str.to_string())]);
}
if let Some(ref local_var_user_agent) = configuration.user_agent {
local_var_req_builder =
local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
}
if let Some(ref local_var_token) = configuration.oauth_access_token {
local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
};
if let Some(ref local_var_token) = configuration.bearer_access_token {
local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
};
let local_var_req = local_var_req_builder.build()?;
let local_var_resp = local_var_client.execute(local_var_req).await?;
let local_var_status = local_var_resp.status();
let local_var_content = local_var_resp.text().await?;
if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
serde_json::from_str(&local_var_content).map_err(Error::from)
} else {
let local_var_entity: Option<GetDependentsForTaskError> =
serde_json::from_str(&local_var_content).ok();
let local_var_error = ResponseContent {
status: local_var_status,
content: local_var_content,
entity: local_var_entity,
};
Err(Error::ResponseError(local_var_error))
}
}
pub async fn get_subtasks_for_task(
configuration: &configuration::Configuration,
task_gid: &str,
opt_pretty: Option<bool>,
opt_fields: Option<Vec<String>>,
limit: Option<i32>,
offset: Option<&str>,
) -> Result<crate::models::InlineResponse20023, Error<GetSubtasksForTaskError>> {
let local_var_client = &configuration.client;
let local_var_uri_str = format!(
"{}/tasks/{task_gid}/subtasks",
configuration.base_path,
task_gid = crate::apis::urlencode(task_gid)
);
let mut local_var_req_builder = local_var_client.get(local_var_uri_str.as_str());
if let Some(ref local_var_str) = opt_pretty {
local_var_req_builder =
local_var_req_builder.query(&[("opt_pretty", &local_var_str.to_string())]);
}
if let Some(ref local_var_str) = opt_fields {
local_var_req_builder = local_var_req_builder.query(&[(
"opt_fields",
&local_var_str
.into_iter()
.map(|p| p.to_string())
.collect::<Vec<String>>()
.join(",")
.to_string(),
)]);
}
if let Some(ref local_var_str) = limit {
local_var_req_builder =
local_var_req_builder.query(&[("limit", &local_var_str.to_string())]);
}
if let Some(ref local_var_str) = offset {
local_var_req_builder =
local_var_req_builder.query(&[("offset", &local_var_str.to_string())]);
}
if let Some(ref local_var_user_agent) = configuration.user_agent {
local_var_req_builder =
local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
}
if let Some(ref local_var_token) = configuration.oauth_access_token {
local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
};
if let Some(ref local_var_token) = configuration.bearer_access_token {
local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
};
let local_var_req = local_var_req_builder.build()?;
let local_var_resp = local_var_client.execute(local_var_req).await?;
let local_var_status = local_var_resp.status();
let local_var_content = local_var_resp.text().await?;
if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
serde_json::from_str(&local_var_content).map_err(Error::from)
} else {
let local_var_entity: Option<GetSubtasksForTaskError> =
serde_json::from_str(&local_var_content).ok();
let local_var_error = ResponseContent {
status: local_var_status,
content: local_var_content,
entity: local_var_entity,
};
Err(Error::ResponseError(local_var_error))
}
}
pub async fn get_task(
configuration: &configuration::Configuration,
task_gid: &str,
opt_pretty: Option<bool>,
opt_fields: Option<Vec<String>>,
) -> Result<crate::models::InlineResponse2016, Error<GetTaskError>> {
let local_var_client = &configuration.client;
let local_var_uri_str = format!(
"{}/tasks/{task_gid}",
configuration.base_path,
task_gid = crate::apis::urlencode(task_gid)
);
let mut local_var_req_builder = local_var_client.get(local_var_uri_str.as_str());
if let Some(ref local_var_str) = opt_pretty {
local_var_req_builder =
local_var_req_builder.query(&[("opt_pretty", &local_var_str.to_string())]);
}
if let Some(ref local_var_str) = opt_fields {
local_var_req_builder = local_var_req_builder.query(&[(
"opt_fields",
&local_var_str
.into_iter()
.map(|p| p.to_string())
.collect::<Vec<String>>()
.join(",")
.to_string(),
)]);
}
if let Some(ref local_var_user_agent) = configuration.user_agent {
local_var_req_builder =
local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
}
if let Some(ref local_var_token) = configuration.oauth_access_token {
local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
};
if let Some(ref local_var_token) = configuration.bearer_access_token {
local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
};
let local_var_req = local_var_req_builder.build()?;
let local_var_resp = local_var_client.execute(local_var_req).await?;
let local_var_status = local_var_resp.status();
let local_var_content = local_var_resp.text().await?;
if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
serde_json::from_str(&local_var_content).map_err(Error::from)
} else {
let local_var_entity: Option<GetTaskError> = serde_json::from_str(&local_var_content).ok();
let local_var_error = ResponseContent {
status: local_var_status,
content: local_var_content,
entity: local_var_entity,
};
Err(Error::ResponseError(local_var_error))
}
}
pub async fn get_tasks(
configuration: &configuration::Configuration,
opt_pretty: Option<bool>,
opt_fields: Option<Vec<String>>,
limit: Option<i32>,
offset: Option<&str>,
assignee: Option<&str>,
project: Option<&str>,
section: Option<&str>,
workspace: Option<&str>,
completed_since: Option<String>,
modified_since: Option<String>,
) -> Result<crate::models::InlineResponse20023, Error<GetTasksError>> {
let local_var_client = &configuration.client;
let local_var_uri_str = format!("{}/tasks", configuration.base_path);
let mut local_var_req_builder = local_var_client.get(local_var_uri_str.as_str());
if let Some(ref local_var_str) = opt_pretty {
local_var_req_builder =
local_var_req_builder.query(&[("opt_pretty", &local_var_str.to_string())]);
}
if let Some(ref local_var_str) = opt_fields {
local_var_req_builder = local_var_req_builder.query(&[(
"opt_fields",
&local_var_str
.into_iter()
.map(|p| p.to_string())
.collect::<Vec<String>>()
.join(",")
.to_string(),
)]);
}
if let Some(ref local_var_str) = limit {
local_var_req_builder =
local_var_req_builder.query(&[("limit", &local_var_str.to_string())]);
}
if let Some(ref local_var_str) = offset {
local_var_req_builder =
local_var_req_builder.query(&[("offset", &local_var_str.to_string())]);
}
if let Some(ref local_var_str) = assignee {
local_var_req_builder =
local_var_req_builder.query(&[("assignee", &local_var_str.to_string())]);
}
if let Some(ref local_var_str) = project {
local_var_req_builder =
local_var_req_builder.query(&[("project", &local_var_str.to_string())]);
}
if let Some(ref local_var_str) = section {
local_var_req_builder =
local_var_req_builder.query(&[("section", &local_var_str.to_string())]);
}
if let Some(ref local_var_str) = workspace {
local_var_req_builder =
local_var_req_builder.query(&[("workspace", &local_var_str.to_string())]);
}
if let Some(ref local_var_str) = completed_since {
local_var_req_builder =
local_var_req_builder.query(&[("completed_since", &local_var_str.to_string())]);
}
if let Some(ref local_var_str) = modified_since {
local_var_req_builder =
local_var_req_builder.query(&[("modified_since", &local_var_str.to_string())]);
}
if let Some(ref local_var_user_agent) = configuration.user_agent {
local_var_req_builder =
local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
}
if let Some(ref local_var_token) = configuration.oauth_access_token {
local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
};
if let Some(ref local_var_token) = configuration.bearer_access_token {
local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
};
let local_var_req = local_var_req_builder.build()?;
let local_var_resp = local_var_client.execute(local_var_req).await?;
let local_var_status = local_var_resp.status();
let local_var_content = local_var_resp.text().await?;
if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
serde_json::from_str(&local_var_content).map_err(Error::from)
} else {
let local_var_entity: Option<GetTasksError> = serde_json::from_str(&local_var_content).ok();
let local_var_error = ResponseContent {
status: local_var_status,
content: local_var_content,
entity: local_var_entity,
};
Err(Error::ResponseError(local_var_error))
}
}
pub async fn get_tasks_for_project(
configuration: &configuration::Configuration,
project_gid: &str,
opt_pretty: Option<bool>,
opt_fields: Option<Vec<String>>,
limit: Option<i32>,
offset: Option<&str>,
) -> Result<crate::models::InlineResponse20023, Error<GetTasksForProjectError>> {
let local_var_client = &configuration.client;
let local_var_uri_str = format!(
"{}/projects/{project_gid}/tasks",
configuration.base_path,
project_gid = crate::apis::urlencode(project_gid)
);
let mut local_var_req_builder = local_var_client.get(local_var_uri_str.as_str());
if let Some(ref local_var_str) = opt_pretty {
local_var_req_builder =
local_var_req_builder.query(&[("opt_pretty", &local_var_str.to_string())]);
}
if let Some(ref local_var_str) = opt_fields {
local_var_req_builder = local_var_req_builder.query(&[(
"opt_fields",
&local_var_str
.into_iter()
.map(|p| p.to_string())
.collect::<Vec<String>>()
.join(",")
.to_string(),
)]);
}
if let Some(ref local_var_str) = limit {
local_var_req_builder =
local_var_req_builder.query(&[("limit", &local_var_str.to_string())]);
}
if let Some(ref local_var_str) = offset {
local_var_req_builder =
local_var_req_builder.query(&[("offset", &local_var_str.to_string())]);
}
if let Some(ref local_var_user_agent) = configuration.user_agent {
local_var_req_builder =
local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
}
if let Some(ref local_var_token) = configuration.oauth_access_token {
local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
};
if let Some(ref local_var_token) = configuration.bearer_access_token {
local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
};
let local_var_req = local_var_req_builder.build()?;
let local_var_resp = local_var_client.execute(local_var_req).await?;
let local_var_status = local_var_resp.status();
let local_var_content = local_var_resp.text().await?;
if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
serde_json::from_str(&local_var_content).map_err(Error::from)
} else {
let local_var_entity: Option<GetTasksForProjectError> =
serde_json::from_str(&local_var_content).ok();
let local_var_error = ResponseContent {
status: local_var_status,
content: local_var_content,
entity: local_var_entity,
};
Err(Error::ResponseError(local_var_error))
}
}
pub async fn get_tasks_for_section(
configuration: &configuration::Configuration,
section_gid: &str,
opt_pretty: Option<bool>,
opt_fields: Option<Vec<String>>,
limit: Option<i32>,
offset: Option<&str>,
) -> Result<crate::models::InlineResponse20023, Error<GetTasksForSectionError>> {
let local_var_client = &configuration.client;
let local_var_uri_str = format!(
"{}/sections/{section_gid}/tasks",
configuration.base_path,
section_gid = crate::apis::urlencode(section_gid)
);
let mut local_var_req_builder = local_var_client.get(local_var_uri_str.as_str());
if let Some(ref local_var_str) = opt_pretty {
local_var_req_builder =
local_var_req_builder.query(&[("opt_pretty", &local_var_str.to_string())]);
}
if let Some(ref local_var_str) = opt_fields {
local_var_req_builder = local_var_req_builder.query(&[(
"opt_fields",
&local_var_str
.into_iter()
.map(|p| p.to_string())
.collect::<Vec<String>>()
.join(",")
.to_string(),
)]);
}
if let Some(ref local_var_str) = limit {
local_var_req_builder =
local_var_req_builder.query(&[("limit", &local_var_str.to_string())]);
}
if let Some(ref local_var_str) = offset {
local_var_req_builder =
local_var_req_builder.query(&[("offset", &local_var_str.to_string())]);
}
if let Some(ref local_var_user_agent) = configuration.user_agent {
local_var_req_builder =
local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
}
if let Some(ref local_var_token) = configuration.oauth_access_token {
local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
};
if let Some(ref local_var_token) = configuration.bearer_access_token {
local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
};
let local_var_req = local_var_req_builder.build()?;
let local_var_resp = local_var_client.execute(local_var_req).await?;
let local_var_status = local_var_resp.status();
let local_var_content = local_var_resp.text().await?;
if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
serde_json::from_str(&local_var_content).map_err(Error::from)
} else {
let local_var_entity: Option<GetTasksForSectionError> =
serde_json::from_str(&local_var_content).ok();
let local_var_error = ResponseContent {
status: local_var_status,
content: local_var_content,
entity: local_var_entity,
};
Err(Error::ResponseError(local_var_error))
}
}
pub async fn get_tasks_for_tag(
configuration: &configuration::Configuration,
tag_gid: &str,
opt_pretty: Option<bool>,
opt_fields: Option<Vec<String>>,
limit: Option<i32>,
offset: Option<&str>,
) -> Result<crate::models::InlineResponse20023, Error<GetTasksForTagError>> {
let local_var_client = &configuration.client;
let local_var_uri_str = format!(
"{}/tags/{tag_gid}/tasks",
configuration.base_path,
tag_gid = crate::apis::urlencode(tag_gid)
);
let mut local_var_req_builder = local_var_client.get(local_var_uri_str.as_str());
if let Some(ref local_var_str) = opt_pretty {
local_var_req_builder =
local_var_req_builder.query(&[("opt_pretty", &local_var_str.to_string())]);
}
if let Some(ref local_var_str) = opt_fields {
local_var_req_builder = local_var_req_builder.query(&[(
"opt_fields",
&local_var_str
.into_iter()
.map(|p| p.to_string())
.collect::<Vec<String>>()
.join(",")
.to_string(),
)]);
}
if let Some(ref local_var_str) = limit {
local_var_req_builder =
local_var_req_builder.query(&[("limit", &local_var_str.to_string())]);
}
if let Some(ref local_var_str) = offset {
local_var_req_builder =
local_var_req_builder.query(&[("offset", &local_var_str.to_string())]);
}
if let Some(ref local_var_user_agent) = configuration.user_agent {
local_var_req_builder =
local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
}
if let Some(ref local_var_token) = configuration.oauth_access_token {
local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
};
if let Some(ref local_var_token) = configuration.bearer_access_token {
local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
};
let local_var_req = local_var_req_builder.build()?;
let local_var_resp = local_var_client.execute(local_var_req).await?;
let local_var_status = local_var_resp.status();
let local_var_content = local_var_resp.text().await?;
if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
serde_json::from_str(&local_var_content).map_err(Error::from)
} else {
let local_var_entity: Option<GetTasksForTagError> =
serde_json::from_str(&local_var_content).ok();
let local_var_error = ResponseContent {
status: local_var_status,
content: local_var_content,
entity: local_var_entity,
};
Err(Error::ResponseError(local_var_error))
}
}
pub async fn get_tasks_for_user_task_list(
configuration: &configuration::Configuration,
user_task_list_gid: &str,
completed_since: Option<&str>,
opt_pretty: Option<bool>,
opt_fields: Option<Vec<String>>,
limit: Option<i32>,
offset: Option<&str>,
) -> Result<crate::models::InlineResponse20023, Error<GetTasksForUserTaskListError>> {
let local_var_client = &configuration.client;
let local_var_uri_str = format!(
"{}/user_task_lists/{user_task_list_gid}/tasks",
configuration.base_path,
user_task_list_gid = crate::apis::urlencode(user_task_list_gid)
);
let mut local_var_req_builder = local_var_client.get(local_var_uri_str.as_str());
if let Some(ref local_var_str) = completed_since {
local_var_req_builder =
local_var_req_builder.query(&[("completed_since", &local_var_str.to_string())]);
}
if let Some(ref local_var_str) = opt_pretty {
local_var_req_builder =
local_var_req_builder.query(&[("opt_pretty", &local_var_str.to_string())]);
}
if let Some(ref local_var_str) = opt_fields {
local_var_req_builder = local_var_req_builder.query(&[(
"opt_fields",
&local_var_str
.into_iter()
.map(|p| p.to_string())
.collect::<Vec<String>>()
.join(",")
.to_string(),
)]);
}
if let Some(ref local_var_str) = limit {
local_var_req_builder =
local_var_req_builder.query(&[("limit", &local_var_str.to_string())]);
}
if let Some(ref local_var_str) = offset {
local_var_req_builder =
local_var_req_builder.query(&[("offset", &local_var_str.to_string())]);
}
if let Some(ref local_var_user_agent) = configuration.user_agent {
local_var_req_builder =
local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
}
if let Some(ref local_var_token) = configuration.oauth_access_token {
local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
};
if let Some(ref local_var_token) = configuration.bearer_access_token {
local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
};
let local_var_req = local_var_req_builder.build()?;
let local_var_resp = local_var_client.execute(local_var_req).await?;
let local_var_status = local_var_resp.status();
let local_var_content = local_var_resp.text().await?;
if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
serde_json::from_str(&local_var_content).map_err(Error::from)
} else {
let local_var_entity: Option<GetTasksForUserTaskListError> =
serde_json::from_str(&local_var_content).ok();
let local_var_error = ResponseContent {
status: local_var_status,
content: local_var_content,
entity: local_var_entity,
};
Err(Error::ResponseError(local_var_error))
}
}
pub async fn remove_dependencies_for_task(
configuration: &configuration::Configuration,
task_gid: &str,
inline_object41: crate::models::InlineObject41,
opt_pretty: Option<bool>,
opt_fields: Option<Vec<String>>,
) -> Result<crate::models::InlineResponse20024, Error<RemoveDependenciesForTaskError>> {
let local_var_client = &configuration.client;
let local_var_uri_str = format!(
"{}/tasks/{task_gid}/removeDependencies",
configuration.base_path,
task_gid = crate::apis::urlencode(task_gid)
);
let mut local_var_req_builder = local_var_client.post(local_var_uri_str.as_str());
if let Some(ref local_var_str) = opt_pretty {
local_var_req_builder =
local_var_req_builder.query(&[("opt_pretty", &local_var_str.to_string())]);
}
if let Some(ref local_var_str) = opt_fields {
local_var_req_builder = local_var_req_builder.query(&[(
"opt_fields",
&local_var_str
.into_iter()
.map(|p| p.to_string())
.collect::<Vec<String>>()
.join(",")
.to_string(),
)]);
}
if let Some(ref local_var_user_agent) = configuration.user_agent {
local_var_req_builder =
local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
}
if let Some(ref local_var_token) = configuration.oauth_access_token {
local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
};
if let Some(ref local_var_token) = configuration.bearer_access_token {
local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
};
local_var_req_builder = local_var_req_builder.json(&inline_object41);
let local_var_req = local_var_req_builder.build()?;
let local_var_resp = local_var_client.execute(local_var_req).await?;
let local_var_status = local_var_resp.status();
let local_var_content = local_var_resp.text().await?;
if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
serde_json::from_str(&local_var_content).map_err(Error::from)
} else {
let local_var_entity: Option<RemoveDependenciesForTaskError> =
serde_json::from_str(&local_var_content).ok();
let local_var_error = ResponseContent {
status: local_var_status,
content: local_var_content,
entity: local_var_entity,
};
Err(Error::ResponseError(local_var_error))
}
}
pub async fn remove_dependents_for_task(
configuration: &configuration::Configuration,
task_gid: &str,
inline_object43: crate::models::InlineObject43,
opt_pretty: Option<bool>,
opt_fields: Option<Vec<String>>,
) -> Result<crate::models::InlineResponse20024, Error<RemoveDependentsForTaskError>> {
let local_var_client = &configuration.client;
let local_var_uri_str = format!(
"{}/tasks/{task_gid}/removeDependents",
configuration.base_path,
task_gid = crate::apis::urlencode(task_gid)
);
let mut local_var_req_builder = local_var_client.post(local_var_uri_str.as_str());
if let Some(ref local_var_str) = opt_pretty {
local_var_req_builder =
local_var_req_builder.query(&[("opt_pretty", &local_var_str.to_string())]);
}
if let Some(ref local_var_str) = opt_fields {
local_var_req_builder = local_var_req_builder.query(&[(
"opt_fields",
&local_var_str
.into_iter()
.map(|p| p.to_string())
.collect::<Vec<String>>()
.join(",")
.to_string(),
)]);
}
if let Some(ref local_var_user_agent) = configuration.user_agent {
local_var_req_builder =
local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
}
if let Some(ref local_var_token) = configuration.oauth_access_token {
local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
};
if let Some(ref local_var_token) = configuration.bearer_access_token {
local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
};
local_var_req_builder = local_var_req_builder.json(&inline_object43);
let local_var_req = local_var_req_builder.build()?;
let local_var_resp = local_var_client.execute(local_var_req).await?;
let local_var_status = local_var_resp.status();
let local_var_content = local_var_resp.text().await?;
if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
serde_json::from_str(&local_var_content).map_err(Error::from)
} else {
let local_var_entity: Option<RemoveDependentsForTaskError> =
serde_json::from_str(&local_var_content).ok();
let local_var_error = ResponseContent {
status: local_var_status,
content: local_var_content,
entity: local_var_entity,
};
Err(Error::ResponseError(local_var_error))
}
}
pub async fn remove_follower_for_task(
configuration: &configuration::Configuration,
task_gid: &str,
inline_object49: crate::models::InlineObject49,
opt_pretty: Option<bool>,
opt_fields: Option<Vec<String>>,
) -> Result<crate::models::InlineResponse2001, Error<RemoveFollowerForTaskError>> {
let local_var_client = &configuration.client;
let local_var_uri_str = format!(
"{}/tasks/{task_gid}/removeFollowers",
configuration.base_path,
task_gid = crate::apis::urlencode(task_gid)
);
let mut local_var_req_builder = local_var_client.post(local_var_uri_str.as_str());
if let Some(ref local_var_str) = opt_pretty {
local_var_req_builder =
local_var_req_builder.query(&[("opt_pretty", &local_var_str.to_string())]);
}
if let Some(ref local_var_str) = opt_fields {
local_var_req_builder = local_var_req_builder.query(&[(
"opt_fields",
&local_var_str
.into_iter()
.map(|p| p.to_string())
.collect::<Vec<String>>()
.join(",")
.to_string(),
)]);
}
if let Some(ref local_var_user_agent) = configuration.user_agent {
local_var_req_builder =
local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
}
if let Some(ref local_var_token) = configuration.oauth_access_token {
local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
};
if let Some(ref local_var_token) = configuration.bearer_access_token {
local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
};
local_var_req_builder = local_var_req_builder.json(&inline_object49);
let local_var_req = local_var_req_builder.build()?;
let local_var_resp = local_var_client.execute(local_var_req).await?;
let local_var_status = local_var_resp.status();
let local_var_content = local_var_resp.text().await?;
if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
serde_json::from_str(&local_var_content).map_err(Error::from)
} else {
let local_var_entity: Option<RemoveFollowerForTaskError> =
serde_json::from_str(&local_var_content).ok();
let local_var_error = ResponseContent {
status: local_var_status,
content: local_var_content,
entity: local_var_entity,
};
Err(Error::ResponseError(local_var_error))
}
}
pub async fn remove_project_for_task(
configuration: &configuration::Configuration,
task_gid: &str,
inline_object45: crate::models::InlineObject45,
opt_pretty: Option<bool>,
opt_fields: Option<Vec<String>>,
) -> Result<crate::models::InlineResponse2001, Error<RemoveProjectForTaskError>> {
let local_var_client = &configuration.client;
let local_var_uri_str = format!(
"{}/tasks/{task_gid}/removeProject",
configuration.base_path,
task_gid = crate::apis::urlencode(task_gid)
);
let mut local_var_req_builder = local_var_client.post(local_var_uri_str.as_str());
if let Some(ref local_var_str) = opt_pretty {
local_var_req_builder =
local_var_req_builder.query(&[("opt_pretty", &local_var_str.to_string())]);
}
if let Some(ref local_var_str) = opt_fields {
local_var_req_builder = local_var_req_builder.query(&[(
"opt_fields",
&local_var_str
.into_iter()
.map(|p| p.to_string())
.collect::<Vec<String>>()
.join(",")
.to_string(),
)]);
}
if let Some(ref local_var_user_agent) = configuration.user_agent {
local_var_req_builder =
local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
}
if let Some(ref local_var_token) = configuration.oauth_access_token {
local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
};
if let Some(ref local_var_token) = configuration.bearer_access_token {
local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
};
local_var_req_builder = local_var_req_builder.json(&inline_object45);
let local_var_req = local_var_req_builder.build()?;
let local_var_resp = local_var_client.execute(local_var_req).await?;
let local_var_status = local_var_resp.status();
let local_var_content = local_var_resp.text().await?;
if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
serde_json::from_str(&local_var_content).map_err(Error::from)
} else {
let local_var_entity: Option<RemoveProjectForTaskError> =
serde_json::from_str(&local_var_content).ok();
let local_var_error = ResponseContent {
status: local_var_status,
content: local_var_content,
entity: local_var_entity,
};
Err(Error::ResponseError(local_var_error))
}
}
pub async fn remove_tag_for_task(
configuration: &configuration::Configuration,
task_gid: &str,
inline_object47: crate::models::InlineObject47,
opt_pretty: Option<bool>,
opt_fields: Option<Vec<String>>,
) -> Result<crate::models::InlineResponse2001, Error<RemoveTagForTaskError>> {
let local_var_client = &configuration.client;
let local_var_uri_str = format!(
"{}/tasks/{task_gid}/removeTag",
configuration.base_path,
task_gid = crate::apis::urlencode(task_gid)
);
let mut local_var_req_builder = local_var_client.post(local_var_uri_str.as_str());
if let Some(ref local_var_str) = opt_pretty {
local_var_req_builder =
local_var_req_builder.query(&[("opt_pretty", &local_var_str.to_string())]);
}
if let Some(ref local_var_str) = opt_fields {
local_var_req_builder = local_var_req_builder.query(&[(
"opt_fields",
&local_var_str
.into_iter()
.map(|p| p.to_string())
.collect::<Vec<String>>()
.join(",")
.to_string(),
)]);
}
if let Some(ref local_var_user_agent) = configuration.user_agent {
local_var_req_builder =
local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
}
if let Some(ref local_var_token) = configuration.oauth_access_token {
local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
};
if let Some(ref local_var_token) = configuration.bearer_access_token {
local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
};
local_var_req_builder = local_var_req_builder.json(&inline_object47);
let local_var_req = local_var_req_builder.build()?;
let local_var_resp = local_var_client.execute(local_var_req).await?;
let local_var_status = local_var_resp.status();
let local_var_content = local_var_resp.text().await?;
if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
serde_json::from_str(&local_var_content).map_err(Error::from)
} else {
let local_var_entity: Option<RemoveTagForTaskError> =
serde_json::from_str(&local_var_content).ok();
let local_var_error = ResponseContent {
status: local_var_status,
content: local_var_content,
entity: local_var_entity,
};
Err(Error::ResponseError(local_var_error))
}
}
pub async fn search_tasks_for_workspace(
configuration: &configuration::Configuration,
workspace_gid: &str,
opt_pretty: Option<bool>,
opt_fields: Option<Vec<String>>,
text: Option<&str>,
resource_subtype: Option<&str>,
assignee_any: Option<&str>,
assignee_not: Option<&str>,
portfolios_any: Option<&str>,
projects_any: Option<&str>,
projects_not: Option<&str>,
projects_all: Option<&str>,
sections_any: Option<&str>,
sections_not: Option<&str>,
sections_all: Option<&str>,
tags_any: Option<&str>,
tags_not: Option<&str>,
tags_all: Option<&str>,
teams_any: Option<&str>,
followers_any: Option<&str>,
followers_not: Option<&str>,
created_by_any: Option<&str>,
created_by_not: Option<&str>,
assigned_by_any: Option<&str>,
assigned_by_not: Option<&str>,
liked_by_any: Option<&str>,
liked_by_not: Option<&str>,
commented_on_by_any: Option<&str>,
commented_on_by_not: Option<&str>,
due_on_before: Option<String>,
due_on_after: Option<String>,
due_on: Option<String>,
due_at_before: Option<String>,
due_at_after: Option<String>,
start_on_before: Option<String>,
start_on_after: Option<String>,
start_on: Option<String>,
created_on_before: Option<String>,
created_on_after: Option<String>,
created_on: Option<String>,
created_at_before: Option<String>,
created_at_after: Option<String>,
completed_on_before: Option<String>,
completed_on_after: Option<String>,
completed_on: Option<String>,
completed_at_before: Option<String>,
completed_at_after: Option<String>,
modified_on_before: Option<String>,
modified_on_after: Option<String>,
modified_on: Option<String>,
modified_at_before: Option<String>,
modified_at_after: Option<String>,
is_blocking: Option<bool>,
is_blocked: Option<bool>,
has_attachment: Option<bool>,
completed: Option<bool>,
is_subtask: Option<bool>,
sort_by: Option<&str>,
sort_ascending: Option<bool>,
) -> Result<crate::models::InlineResponse20023, Error<SearchTasksForWorkspaceError>> {
let local_var_client = &configuration.client;
let local_var_uri_str = format!(
"{}/workspaces/{workspace_gid}/tasks/search",
configuration.base_path,
workspace_gid = crate::apis::urlencode(workspace_gid)
);
let mut local_var_req_builder = local_var_client.get(local_var_uri_str.as_str());
if let Some(ref local_var_str) = opt_pretty {
local_var_req_builder =
local_var_req_builder.query(&[("opt_pretty", &local_var_str.to_string())]);
}
if let Some(ref local_var_str) = opt_fields {
local_var_req_builder = local_var_req_builder.query(&[(
"opt_fields",
&local_var_str
.into_iter()
.map(|p| p.to_string())
.collect::<Vec<String>>()
.join(",")
.to_string(),
)]);
}
if let Some(ref local_var_str) = text {
local_var_req_builder =
local_var_req_builder.query(&[("text", &local_var_str.to_string())]);
}
if let Some(ref local_var_str) = resource_subtype {
local_var_req_builder =
local_var_req_builder.query(&[("resource_subtype", &local_var_str.to_string())]);
}
if let Some(ref local_var_str) = assignee_any {
local_var_req_builder =
local_var_req_builder.query(&[("assignee.any", &local_var_str.to_string())]);
}
if let Some(ref local_var_str) = assignee_not {
local_var_req_builder =
local_var_req_builder.query(&[("assignee.not", &local_var_str.to_string())]);
}
if let Some(ref local_var_str) = portfolios_any {
local_var_req_builder =
local_var_req_builder.query(&[("portfolios.any", &local_var_str.to_string())]);
}
if let Some(ref local_var_str) = projects_any {
local_var_req_builder =
local_var_req_builder.query(&[("projects.any", &local_var_str.to_string())]);
}
if let Some(ref local_var_str) = projects_not {
local_var_req_builder =
local_var_req_builder.query(&[("projects.not", &local_var_str.to_string())]);
}
if let Some(ref local_var_str) = projects_all {
local_var_req_builder =
local_var_req_builder.query(&[("projects.all", &local_var_str.to_string())]);
}
if let Some(ref local_var_str) = sections_any {
local_var_req_builder =
local_var_req_builder.query(&[("sections.any", &local_var_str.to_string())]);
}
if let Some(ref local_var_str) = sections_not {
local_var_req_builder =
local_var_req_builder.query(&[("sections.not", &local_var_str.to_string())]);
}
if let Some(ref local_var_str) = sections_all {
local_var_req_builder =
local_var_req_builder.query(&[("sections.all", &local_var_str.to_string())]);
}
if let Some(ref local_var_str) = tags_any {
local_var_req_builder =
local_var_req_builder.query(&[("tags.any", &local_var_str.to_string())]);
}
if let Some(ref local_var_str) = tags_not {
local_var_req_builder =
local_var_req_builder.query(&[("tags.not", &local_var_str.to_string())]);
}
if let Some(ref local_var_str) = tags_all {
local_var_req_builder =
local_var_req_builder.query(&[("tags.all", &local_var_str.to_string())]);
}
if let Some(ref local_var_str) = teams_any {
local_var_req_builder =
local_var_req_builder.query(&[("teams.any", &local_var_str.to_string())]);
}
if let Some(ref local_var_str) = followers_any {
local_var_req_builder =
local_var_req_builder.query(&[("followers.any", &local_var_str.to_string())]);
}
if let Some(ref local_var_str) = followers_not {
local_var_req_builder =
local_var_req_builder.query(&[("followers.not", &local_var_str.to_string())]);
}
if let Some(ref local_var_str) = created_by_any {
local_var_req_builder =
local_var_req_builder.query(&[("created_by.any", &local_var_str.to_string())]);
}
if let Some(ref local_var_str) = created_by_not {
local_var_req_builder =
local_var_req_builder.query(&[("created_by.not", &local_var_str.to_string())]);
}
if let Some(ref local_var_str) = assigned_by_any {
local_var_req_builder =
local_var_req_builder.query(&[("assigned_by.any", &local_var_str.to_string())]);
}
if let Some(ref local_var_str) = assigned_by_not {
local_var_req_builder =
local_var_req_builder.query(&[("assigned_by.not", &local_var_str.to_string())]);
}
if let Some(ref local_var_str) = liked_by_any {
local_var_req_builder =
local_var_req_builder.query(&[("liked_by.any", &local_var_str.to_string())]);
}
if let Some(ref local_var_str) = liked_by_not {
local_var_req_builder =
local_var_req_builder.query(&[("liked_by.not", &local_var_str.to_string())]);
}
if let Some(ref local_var_str) = commented_on_by_any {
local_var_req_builder =
local_var_req_builder.query(&[("commented_on_by.any", &local_var_str.to_string())]);
}
if let Some(ref local_var_str) = commented_on_by_not {
local_var_req_builder =
local_var_req_builder.query(&[("commented_on_by.not", &local_var_str.to_string())]);
}
if let Some(ref local_var_str) = due_on_before {
local_var_req_builder =
local_var_req_builder.query(&[("due_on.before", &local_var_str.to_string())]);
}
if let Some(ref local_var_str) = due_on_after {
local_var_req_builder =
local_var_req_builder.query(&[("due_on.after", &local_var_str.to_string())]);
}
if let Some(ref local_var_str) = due_on {
local_var_req_builder =
local_var_req_builder.query(&[("due_on", &local_var_str.to_string())]);
}
if let Some(ref local_var_str) = due_at_before {
local_var_req_builder =
local_var_req_builder.query(&[("due_at.before", &local_var_str.to_string())]);
}
if let Some(ref local_var_str) = due_at_after {
local_var_req_builder =
local_var_req_builder.query(&[("due_at.after", &local_var_str.to_string())]);
}
if let Some(ref local_var_str) = start_on_before {
local_var_req_builder =
local_var_req_builder.query(&[("start_on.before", &local_var_str.to_string())]);
}
if let Some(ref local_var_str) = start_on_after {
local_var_req_builder =
local_var_req_builder.query(&[("start_on.after", &local_var_str.to_string())]);
}
if let Some(ref local_var_str) = start_on {
local_var_req_builder =
local_var_req_builder.query(&[("start_on", &local_var_str.to_string())]);
}
if let Some(ref local_var_str) = created_on_before {
local_var_req_builder =
local_var_req_builder.query(&[("created_on.before", &local_var_str.to_string())]);
}
if let Some(ref local_var_str) = created_on_after {
local_var_req_builder =
local_var_req_builder.query(&[("created_on.after", &local_var_str.to_string())]);
}
if let Some(ref local_var_str) = created_on {
local_var_req_builder =
local_var_req_builder.query(&[("created_on", &local_var_str.to_string())]);
}
if let Some(ref local_var_str) = created_at_before {
local_var_req_builder =
local_var_req_builder.query(&[("created_at.before", &local_var_str.to_string())]);
}
if let Some(ref local_var_str) = created_at_after {
local_var_req_builder =
local_var_req_builder.query(&[("created_at.after", &local_var_str.to_string())]);
}
if let Some(ref local_var_str) = completed_on_before {
local_var_req_builder =
local_var_req_builder.query(&[("completed_on.before", &local_var_str.to_string())]);
}
if let Some(ref local_var_str) = completed_on_after {
local_var_req_builder =
local_var_req_builder.query(&[("completed_on.after", &local_var_str.to_string())]);
}
if let Some(ref local_var_str) = completed_on {
local_var_req_builder =
local_var_req_builder.query(&[("completed_on", &local_var_str.to_string())]);
}
if let Some(ref local_var_str) = completed_at_before {
local_var_req_builder =
local_var_req_builder.query(&[("completed_at.before", &local_var_str.to_string())]);
}
if let Some(ref local_var_str) = completed_at_after {
local_var_req_builder =
local_var_req_builder.query(&[("completed_at.after", &local_var_str.to_string())]);
}
if let Some(ref local_var_str) = modified_on_before {
local_var_req_builder =
local_var_req_builder.query(&[("modified_on.before", &local_var_str.to_string())]);
}
if let Some(ref local_var_str) = modified_on_after {
local_var_req_builder =
local_var_req_builder.query(&[("modified_on.after", &local_var_str.to_string())]);
}
if let Some(ref local_var_str) = modified_on {
local_var_req_builder =
local_var_req_builder.query(&[("modified_on", &local_var_str.to_string())]);
}
if let Some(ref local_var_str) = modified_at_before {
local_var_req_builder =
local_var_req_builder.query(&[("modified_at.before", &local_var_str.to_string())]);
}
if let Some(ref local_var_str) = modified_at_after {
local_var_req_builder =
local_var_req_builder.query(&[("modified_at.after", &local_var_str.to_string())]);
}
if let Some(ref local_var_str) = is_blocking {
local_var_req_builder =
local_var_req_builder.query(&[("is_blocking", &local_var_str.to_string())]);
}
if let Some(ref local_var_str) = is_blocked {
local_var_req_builder =
local_var_req_builder.query(&[("is_blocked", &local_var_str.to_string())]);
}
if let Some(ref local_var_str) = has_attachment {
local_var_req_builder =
local_var_req_builder.query(&[("has_attachment", &local_var_str.to_string())]);
}
if let Some(ref local_var_str) = completed {
local_var_req_builder =
local_var_req_builder.query(&[("completed", &local_var_str.to_string())]);
}
if let Some(ref local_var_str) = is_subtask {
local_var_req_builder =
local_var_req_builder.query(&[("is_subtask", &local_var_str.to_string())]);
}
if let Some(ref local_var_str) = sort_by {
local_var_req_builder =
local_var_req_builder.query(&[("sort_by", &local_var_str.to_string())]);
}
if let Some(ref local_var_str) = sort_ascending {
local_var_req_builder =
local_var_req_builder.query(&[("sort_ascending", &local_var_str.to_string())]);
}
if let Some(ref local_var_user_agent) = configuration.user_agent {
local_var_req_builder =
local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
}
if let Some(ref local_var_token) = configuration.oauth_access_token {
local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
};
if let Some(ref local_var_token) = configuration.bearer_access_token {
local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
};
let local_var_req = local_var_req_builder.build()?;
let local_var_resp = local_var_client.execute(local_var_req).await?;
let local_var_status = local_var_resp.status();
let local_var_content = local_var_resp.text().await?;
if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
serde_json::from_str(&local_var_content).map_err(Error::from)
} else {
let local_var_entity: Option<SearchTasksForWorkspaceError> =
serde_json::from_str(&local_var_content).ok();
let local_var_error = ResponseContent {
status: local_var_status,
content: local_var_content,
entity: local_var_entity,
};
Err(Error::ResponseError(local_var_error))
}
}
pub async fn set_parent_for_task(
configuration: &configuration::Configuration,
task_gid: &str,
inline_object39: crate::models::InlineObject39,
opt_pretty: Option<bool>,
opt_fields: Option<Vec<String>>,
) -> Result<crate::models::InlineResponse2016, Error<SetParentForTaskError>> {
let local_var_client = &configuration.client;
let local_var_uri_str = format!(
"{}/tasks/{task_gid}/setParent",
configuration.base_path,
task_gid = crate::apis::urlencode(task_gid)
);
let mut local_var_req_builder = local_var_client.post(local_var_uri_str.as_str());
if let Some(ref local_var_str) = opt_pretty {
local_var_req_builder =
local_var_req_builder.query(&[("opt_pretty", &local_var_str.to_string())]);
}
if let Some(ref local_var_str) = opt_fields {
local_var_req_builder = local_var_req_builder.query(&[(
"opt_fields",
&local_var_str
.into_iter()
.map(|p| p.to_string())
.collect::<Vec<String>>()
.join(",")
.to_string(),
)]);
}
if let Some(ref local_var_user_agent) = configuration.user_agent {
local_var_req_builder =
local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
}
if let Some(ref local_var_token) = configuration.oauth_access_token {
local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
};
if let Some(ref local_var_token) = configuration.bearer_access_token {
local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
};
local_var_req_builder = local_var_req_builder.json(&inline_object39);
let local_var_req = local_var_req_builder.build()?;
let local_var_resp = local_var_client.execute(local_var_req).await?;
let local_var_status = local_var_resp.status();
let local_var_content = local_var_resp.text().await?;
if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
serde_json::from_str(&local_var_content).map_err(Error::from)
} else {
let local_var_entity: Option<SetParentForTaskError> =
serde_json::from_str(&local_var_content).ok();
let local_var_error = ResponseContent {
status: local_var_status,
content: local_var_content,
entity: local_var_entity,
};
Err(Error::ResponseError(local_var_error))
}
}
pub async fn update_task(
configuration: &configuration::Configuration,
task_gid: &str,
inline_object36: crate::models::InlineObject36,
opt_pretty: Option<bool>,
opt_fields: Option<Vec<String>>,
) -> Result<crate::models::InlineResponse2016, Error<UpdateTaskError>> {
let local_var_client = &configuration.client;
let local_var_uri_str = format!(
"{}/tasks/{task_gid}",
configuration.base_path,
task_gid = crate::apis::urlencode(task_gid)
);
let mut local_var_req_builder = local_var_client.put(local_var_uri_str.as_str());
if let Some(ref local_var_str) = opt_pretty {
local_var_req_builder =
local_var_req_builder.query(&[("opt_pretty", &local_var_str.to_string())]);
}
if let Some(ref local_var_str) = opt_fields {
local_var_req_builder = local_var_req_builder.query(&[(
"opt_fields",
&local_var_str
.into_iter()
.map(|p| p.to_string())
.collect::<Vec<String>>()
.join(",")
.to_string(),
)]);
}
if let Some(ref local_var_user_agent) = configuration.user_agent {
local_var_req_builder =
local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
}
if let Some(ref local_var_token) = configuration.oauth_access_token {
local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
};
if let Some(ref local_var_token) = configuration.bearer_access_token {
local_var_req_builder = local_var_req_builder.bearer_auth(local_var_token.to_owned());
};
local_var_req_builder = local_var_req_builder.json(&inline_object36);
let local_var_req = local_var_req_builder.build()?;
let local_var_resp = local_var_client.execute(local_var_req).await?;
let local_var_status = local_var_resp.status();
let local_var_content = local_var_resp.text().await?;
if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
serde_json::from_str(&local_var_content).map_err(Error::from)
} else {
let local_var_entity: Option<UpdateTaskError> =
serde_json::from_str(&local_var_content).ok();
let local_var_error = ResponseContent {
status: local_var_status,
content: local_var_content,
entity: local_var_entity,
};
Err(Error::ResponseError(local_var_error))
}
}