/// <summary>
/// Create Object with <see cref="ParamsAccessToken"/>
/// </summary>
/// <param name="paramAccessToken">param access token object</param>
public static Task <ClickUpApi> CreateAsync(ParamsAccessToken paramAccessToken)
{
var client = new RestClient(_baseAddress);
var request = new RestRequest("oauth/token", Method.POST);
request.AddParameter("client_id", paramAccessToken.ClientId);
request.AddParameter("client_secret", paramAccessToken.ClientSecret);
request.AddParameter("code", paramAccessToken.Code);
// execute the request
var taskCompletionSource = new TaskCompletionSource <ClickUpApi>();
var task = RestSharperHelper.ExecuteRequestAsync <ResponseAccessToken, ResponseError>(client, request)
.ContinueWith(responseTask => {
ResponseGeneric <ResponseAccessToken, ResponseError> response = responseTask.Result;
// Manage Response
if (response.ResponseSuccess == null)
{
throw new Exception(response.ResponseError.Err);
}
string accessToken = response.ResponseSuccess.AccessToken;
taskCompletionSource.SetResult(new ClickUpApi(accessToken));
});
return(taskCompletionSource.Task);
}
public async Task <List <ResponseModelTaskFull> > GetFilteredTeamTasks(string teamId, ParamsGetFilteredTeamTasks param)
{
var tasks = new List <ResponseModelTaskFull>();
var page = 0;
while (true)
{
param.Page = page++;
var queryString = OptionalParamGenerator.GenerateOptionalParams(param);
var request = CreateRequest($"team/{teamId}/task?{queryString}", Method.GET);
var res = await RestSharperHelper.ExecuteRequestAsync <ResponseTasksFull, ResponseError>(_client, request);
if (res.ResponseError != null)
{
throw new Exception($"{res.ResponseError.ECode} {res.ResponseError.Status} {res.ResponseError.Err}");
}
if (!res.ResponseSuccess.Tasks.Any())
{
break;
}
tasks.AddRange(res.ResponseSuccess.Tasks);
}
return(tasks);
}
/// <summary>
/// Get a task by id
/// </summary>
/// <param name="paramsGetTaskById">param object of get task by id request</param>
/// <returns>ResponseGeneric with ResponseModelTask response object</returns>
public Task <ResponseGeneric <ResponseModelTask, ResponseError> > GetTaskByIdAsync(ParamsGetTaskById paramsGetTaskById)
{
var client = new RestClient(_baseAddress);
var request = new RestRequest($"task/{paramsGetTaskById.TaskId}", Method.GET);
request.AddHeader("authorization", AccessToken);
// execute the request
return(RestSharperHelper.ExecuteRequestAsync <ResponseModelTask, ResponseError>(client, request));
}
/// <summary>
/// Get a space's lists AKA folderless lists
/// </summary>
/// <param name="paramsGetFolderlessLists">param object of get folderless lists request</param>
/// <returns>ResponseGeneric with ResponseFolderlessLists response object</returns>
public Task <ResponseGeneric <ResponseFolderlessLists, ResponseError> > GetFolderlessListsAsync(ParamsGetFolderlessLists paramsGetFolderlessLists)
{
var client = new RestClient(_baseAddress);
var request = new RestRequest($"space/{paramsGetFolderlessLists.SpaceId}/list", Method.GET);
request.AddHeader("authorization", AccessToken);
// execute the request
return(RestSharperHelper.ExecuteRequestAsync <ResponseFolderlessLists, ResponseError>(client, request));
}
/// <summary>
/// Get the authorized teams for this token
/// </summary>
/// <returns>ResponseGeneric with ResponseAuthorizedTeams expected</returns>
public Task <ResponseGeneric <ResponseAuthorizedTeams, ResponseError> > GetAuthorizedTeamsAsync()
{
var client = new RestClient(_baseAddress);
var request = new RestRequest($"team", Method.GET);
request.AddHeader("authorization", AccessToken);
// execute the request
return(RestSharperHelper.ExecuteRequestAsync <ResponseAuthorizedTeams, ResponseError>(client, request));
}
/// <summary>
/// Get a team's webhooks. This team must be one of the authorized teams for this token.
/// </summary>
/// <param name="paramsGetTeamWebhook">param object of get team Webhook request</param>
/// <returns>ResponseGeneric with ResponseTeamWebhook response object</returns>
public Task <ResponseGeneric <ResponseWebhooks, ResponseError> > GetTeamWebhooksAsync(ParamsGetTeamWebhooks paramsGetTeamWebhook)
{
var client = new RestClient(_baseAddress);
var request = new RestRequest($"team/{paramsGetTeamWebhook.TeamId}/webhook", Method.GET);
request.AddHeader("authorization", AccessToken);
// execute the request
return(RestSharperHelper.ExecuteRequestAsync <ResponseWebhooks, ResponseError>(client, request));
}
public async Task <List <ResponseModelMember> > GetListMembers(string listId)
{
var request = CreateRequest($"list/{listId}/member", Method.GET);
var res = await RestSharperHelper.ExecuteRequestAsync <ResponseMembers, ResponseError>(_client, request);
if (res.ResponseError != null)
{
throw new Exception($"{res.ResponseError.ECode} {res.ResponseError.Status} {res.ResponseError.Err}");
}
return(res.ResponseSuccess.Members);
}
/// <summary>
/// Edit Task informations.
/// </summary>
/// <param name="paramsEditTask">param object of edit task request</param>
/// <param name="requestData">RequestEditTask object</param>
/// <returns>ResponseGeneric with ResponseSuccess object expected</returns>
public Task <ResponseGeneric <ResponseModelTask, ResponseError> > EditTaskAsync(ParamsEditTask paramsEditTask, RequestEditTask requestData)
{
var client = new RestClient(_baseAddress);
var request = new RestRequest($"task/{paramsEditTask.TaskId}", Method.PUT);
request.AddHeader("authorization", AccessToken);
request.AddJsonBody(requestData);
// execute the request
return(RestSharperHelper.ExecuteRequestAsync <ResponseModelTask, ResponseError>(client, request));
}
/// <summary>
/// Get Tasks of the Team and filter its by optionalParams
/// </summary>
/// <param name="paramsGetTasks">params obkect of get tasks request</param>
/// <param name="optionalParams">OptionalParamsGetTask object</param>
/// <returns>ResponseGeneric with ResponseTasks response object</returns>
public ResponseGeneric <ResponseTasks, ResponseError> GetTasks(ParamsGetTasks paramsGetTasks)
{
var client = new RestClient(_baseAddress);
var request = new RestRequest($"team/{paramsGetTasks.TeamId}/task", Method.GET);
request.AddHeader("authorization", AccessToken);
// execute the request
ResponseGeneric <ResponseTasks, ResponseError> result = RestSharperHelper.ExecuteRequest <ResponseTasks, ResponseError>(client, request);
return(result);
}
/// <summary>
/// Get a list by id
/// </summary>
/// <param name="paramsGetListById">param object of get list by id request</param>
/// <returns>ResponseGeneric with ResponseModelList response object</returns>
public ResponseGeneric <ResponseModelList, ResponseError> GetListById(ParamsGetListById paramsGetListById)
{
var client = new RestClient(_baseAddress);
var request = new RestRequest($"list/{paramsGetListById.ListId}", Method.GET);
request.AddHeader("authorization", AccessToken);
// execute the request
ResponseGeneric <ResponseModelList, ResponseError> result = RestSharperHelper.ExecuteRequest <ResponseModelList, ResponseError>(client, request);
return(result);
}
/// <summary>
/// Get a space's folders. The folders' lists will also be included.
/// </summary>
/// <param name="paramsGetSpaceFolders">param object of get space folder request</param>
/// <returns>ResponseGeneric with ResponseSpaceFolders response object</returns>
public ResponseGeneric <ResponseSpaceFolders, ResponseError> GetSpaceFolders(ParamsGetSpaceFolders paramsGetSpaceFolders)
{
var client = new RestClient(_baseAddress);
var request = new RestRequest($"space/{paramsGetSpaceFolders.SpaceId}/folder", Method.GET);
request.AddHeader("authorization", AccessToken);
// execute the request
ResponseGeneric <ResponseSpaceFolders, ResponseError> result = RestSharperHelper.ExecuteRequest <ResponseSpaceFolders, ResponseError>(client, request);
return(result);
}
/// <summary>
/// Get the user that belongs to this token
/// </summary>
/// <returns>ResponseGeneric with ResponseAuthorizedUser response object</returns>
public ResponseGeneric <ResponseAuthorizedUser, ResponseError> GetAuthorizedUser()
{
var client = new RestClient(_baseAddress);
var request = new RestRequest($"user", Method.GET);
request.AddHeader("authorization", AccessToken);
// execute the request
ResponseGeneric <ResponseAuthorizedUser, ResponseError> result = RestSharperHelper.ExecuteRequest <ResponseAuthorizedUser, ResponseError>(client, request);
return(result);
}
/// <summary>
/// Create Task in List.
/// </summary>
/// <param name="paramsCreateTaskInList">param object of Create Task in List request</param>
/// <param name="requestData">RequestCreateTaskInList object</param>
/// <returns>ResponseGeneric with ModelTask object Expected</returns>
public Task <ResponseGeneric <ResponseModelTask, ResponseError> > CreateTaskInListAsync(ParamsCreateTaskInList paramsCreateTaskInList, RequestCreateTaskInList requestData)
{
requestData.ValidateData();
var client = new RestClient(_baseAddress);
var createListRequest = new RestRequest($"list/{paramsCreateTaskInList.ListId}/task", Method.POST);
createListRequest.AddHeader("authorization", AccessToken);
createListRequest.AddJsonBody(requestData);
// execute the request
return(RestSharperHelper.ExecuteRequestAsync <ResponseModelTask, ResponseError>(client, createListRequest));
}
/// <summary>
/// Create a folderless List
/// </summary>
/// <param name="paramsCreateList">param object of create list request</param>
/// <param name="requestData">RequestCreateList object</param>
/// <returns>ResponseGeneric with ModelList object expected</returns>
public Task <ResponseGeneric <ResponseModelList, ResponseError> > CreateFolderlessListAsync(ParamsCreateFolderlessList paramsCreateList, RequestCreateList requestData)
{
requestData.ValidateData();
var client = new RestClient(_baseAddress);
var request = new RestRequest($"space/{paramsCreateList.SpaceId}/list", Method.POST);
request.AddHeader("authorization", AccessToken);
request.AddJsonBody(requestData);
// execute the request
return(RestSharperHelper.ExecuteRequestAsync <ResponseModelList, ResponseError>(client, request));
}
/// <summary>
/// Edit List informations
/// </summary>
/// <param name="paramsEditList">params object of edit list request</param>
/// <param name="requestData">RequestEditList object</param>
/// <returns>ResponseGeneric with ModelList response object</returns>
public ResponseGeneric <ResponseModelList, ResponseError> EditList(ParamsEditList paramsEditList, RequestEditList requestData)
{
var client = new RestClient(_baseAddress);
var request = new RestRequest($"list/{paramsEditList.ListId}", Method.PUT);
request.AddHeader("authorization", AccessToken);
request.AddJsonBody(requestData);
// execute the request
ResponseGeneric <ResponseModelList, ResponseError> result = RestSharperHelper.ExecuteRequest <ResponseModelList, ResponseError>(client, request);
return(result);
}
/// <summary>
/// Create a webhook in a Team
/// </summary>
/// <param name="paramsCreateTeamWebhook">param object of create webhook request</param>
/// <param name="requestData">RequestCreateTeamWebhook object</param>
/// <returns>ResponseGeneric with ResponseWebhook response object</returns>
public Task <ResponseGeneric <ResponseWebhook, ResponseError> > CreateTeamWebhookAsync(ParamsCreateTeamWebhook paramsCreateTeamWebhook, RequestCreateTeamWebhook requestData)
{
requestData.ValidateData();
var client = new RestClient(_baseAddress);
var request = new RestRequest($"team/{paramsCreateTeamWebhook.TeamId}/webhook", Method.POST);
request.AddHeader("authorization", AccessToken);
request.AddJsonBody(requestData);
// execute the request
return(RestSharperHelper.ExecuteRequestAsync <ResponseWebhook, ResponseError>(client, request));
}
/// <summary>
/// Create space in a Team
/// </summary>
/// <param name="paramsCreateTeamSpace">param object of create space request</param>
/// <param name="requestData">RequestCreateTeamSpace object</param>
/// <returns>ResponseGeneric with ModelList response object</returns>
public ResponseGeneric <ResponseModelSpace, ResponseError> CreateTeamSpace(ParamsCreateTeamSpace paramsCreateTeamSpace, RequestCreateTeamSpace requestData)
{
requestData.ValidateData();
var client = new RestClient(_baseAddress);
var request = new RestRequest($"team/{paramsCreateTeamSpace.TeamId}/space", Method.POST);
request.AddHeader("authorization", AccessToken);
request.AddJsonBody(requestData);
// execute the request
ResponseGeneric <ResponseModelSpace, ResponseError> result = RestSharperHelper.ExecuteRequest <ResponseModelSpace, ResponseError>(client, request);
return(result);
}
/// <summary>
/// Create List in Folder
/// </summary>
/// <param name="paramsCreateList">param object of create list request</param>
/// <param name="requestData">RequestCreateList object</param>
/// <returns>ResponseGeneric with ModelList response object</returns>
public ResponseGeneric <ResponseModelList, ResponseError> CreateList(ParamsCreateFolderList paramsCreateList, RequestCreateList requestData)
{
requestData.ValidateData();
var client = new RestClient(_baseAddress);
var request = new RestRequest($"folder/{paramsCreateList.FolderId}/list", Method.POST);
request.AddHeader("authorization", AccessToken);
request.AddJsonBody(requestData);
// execute the request
ResponseGeneric <ResponseModelList, ResponseError> result = RestSharperHelper.ExecuteRequest <ResponseModelList, ResponseError>(client, request);
return(result);
}
/// <summary>
/// Create Object with <see cref="ParamsAccessToken"/>
/// </summary>
/// <param name="paramAccessToken">param access token object</param>
public static ClickUpApi Create(ParamsAccessToken paramAccessToken)
{
var client = new RestClient(_baseAddress);
var request = new RestRequest("oauth/token", Method.POST);
request.AddParameter("client_id", paramAccessToken.ClientId);
request.AddParameter("client_secret", paramAccessToken.ClientSecret);
request.AddParameter("code", paramAccessToken.Code);
// execute the request
ResponseGeneric <ResponseAccessToken, ResponseError> response = RestSharperHelper.ExecuteRequest <ResponseAccessToken, ResponseError>(client, request);
string accessToken;
// Manage Response
if (response.ResponseSuccess == null)
{
throw new Exception(response.ResponseError.Err);
}
accessToken = response.ResponseSuccess.AccessToken;
return(new ClickUpApi(accessToken));
}
