public async Task <IPagedQueryResult <Comment> > GetPagedCommentsAsync(string issueKey, int?maxComments = default(int?), int startAt = 0, CancellationToken token = default(CancellationToken))
{
var resource = $"rest/api/latest/issue/{issueKey}/comment";
var queryParameters = new Dictionary <string, string>();
queryParameters.Add("startAt", $"{startAt}");
if (maxComments.HasValue)
{
queryParameters.Add("maxResults", $"{maxComments.Value}");
}
var result = await _jira.RestClient.ExecuteRequestAsync(Method.GET, resource, queryParameters, token).ConfigureAwait(false);
var serializerSettings = _jira.RestClient.Settings.JsonSerializerSettings;
var comments = result["comments"]
.Cast <JObject>()
.Select(commentJson =>
{
var remoteComment = JsonConvert.DeserializeObject <RemoteComment>(commentJson.ToString(), serializerSettings);
return(new Comment(remoteComment));
});
return(PagedQueryResult <Comment> .FromJson((JObject)result, comments));
}
private async Task <IPagedQueryResult <Issue> > GetIssuesFromJqlAsync(JqlOptions options)
{
if (_jira.Debug)
{
Trace.WriteLine("[GetFromJqlAsync] JQL: " + options.Jql);
}
var parameters = new
{
jql = options.Jql,
startAt = options.StartAt,
maxResults = options.MaxIssuesPerRequest,
validateQuery = options.ValidateQuery,
};
var result = await _jira.RestClient.ExecuteRequestAsync(Method.POST, "rest/api/2/search", parameters, options.Token).ConfigureAwait(false);
var serializerSettings = await this.GetIssueSerializerSettingsAsync(options.Token).ConfigureAwait(false);
var issues = result["issues"]
.Cast <JObject>()
.Select(issueJson =>
{
var remoteIssue = JsonConvert.DeserializeObject <RemoteIssueWrapper>(issueJson.ToString(), serializerSettings).RemoteIssue;
return(new Issue(_jira, remoteIssue));
});
return(PagedQueryResult <Issue> .FromJson((JObject)result, issues));
}
public async Task <IPagedQueryResult <Issue> > GetIssuesFromJqlAsync(IssueSearchOptions options, CancellationToken token = default(CancellationToken))
{
if (_jira.Debug)
{
Trace.WriteLine("[GetFromJqlAsync] JQL: " + options.Jql);
}
var fields = new List <string>();
if (options.AdditionalFields == null || !options.AdditionalFields.Any())
{
fields.Add(ALL_FIELDS_QUERY_STRING);
fields.AddRange(_excludedFields.Select(field => $"-{field}"));
}
else if (options.FetchBasicFields)
{
var excludedFields = _excludedFields.Where(excludedField => !options.AdditionalFields.Contains(excludedField, StringComparer.OrdinalIgnoreCase)).ToArray();
fields.Add(ALL_FIELDS_QUERY_STRING);
fields.AddRange(excludedFields.Select(field => $"-{field}"));
}
else
{
fields.AddRange(options.AdditionalFields.Select(field => field.Trim().ToLowerInvariant()));
}
var parameters = new
{
jql = options.Jql,
startAt = options.StartAt,
maxResults = options.MaxIssuesPerRequest ?? this.MaxIssuesPerRequest,
validateQuery = options.ValidateQuery,
fields = fields
};
var result = await _jira.RestClient.ExecuteRequestAsync(Method.POST, "rest/api/2/search", parameters, token).ConfigureAwait(false);
var serializerSettings = await this.GetIssueSerializerSettingsAsync(token).ConfigureAwait(false);
var issues = result["issues"]
.Cast <JObject>()
.Select(issueJson =>
{
var remoteIssue = JsonConvert.DeserializeObject <RemoteIssueWrapper>(issueJson.ToString(), serializerSettings).RemoteIssue;
return(new Issue(_jira, remoteIssue));
});
return(PagedQueryResult <Issue> .FromJson((JObject)result, issues));
}
public async Task <IPagedQueryResult <JiraUser> > GetUsersAsync(string groupname, bool includeInactiveUsers = false, int maxResults = 50, int startAt = 0, CancellationToken token = default(CancellationToken))
{
var resource = String.Format(
"rest/api/2/group/member?groupname={0}&includeInactiveUsers={1}&startAt={2}&maxResults={3}",
Uri.EscapeDataString(groupname),
includeInactiveUsers,
startAt,
maxResults);
var response = await _jira.RestClient.ExecuteRequestAsync(Method.GET, resource, null, token).ConfigureAwait(false);
var serializerSetting = _jira.RestClient.Settings.JsonSerializerSettings;
var users = response["values"]
.Cast <JObject>()
.Select(valuesJson => JsonConvert.DeserializeObject <JiraUser>(valuesJson.ToString(), serializerSetting));
return(PagedQueryResult <JiraUser> .FromJson((JObject)response, users));
}
public async Task <IPagedQueryResult <JiraUser> > GetUsersAsync(string groupname, bool includeInactiveUsers = false, int maxResults = 50, int startAt = 0, CancellationToken token = default(CancellationToken))
{
var resource = "rest/api/latest/group/member";
var queryParameters = new Dictionary <string, string>();
queryParameters.Add("groupname", Uri.EscapeDataString(groupname));
queryParameters.Add("includeInactiveUsers", $"{includeInactiveUsers}");
queryParameters.Add("startAt", $"{startAt}");
queryParameters.Add("maxResults", $"{maxResults}");
var response = await _jira.RestClient.ExecuteRequestAsync(Method.GET, resource, queryParameters, token).ConfigureAwait(false);
var serializerSetting = _jira.RestClient.Settings.JsonSerializerSettings;
var users = response["values"]
.Cast <JObject>()
.Select(valuesJson => JsonConvert.DeserializeObject <JiraUser>(valuesJson.ToString(), serializerSetting));
return(PagedQueryResult <JiraUser> .FromJson((JObject)response, users));
}
public async Task <IPagedQueryResult <ProjectVersion> > GetPagedVersionsAsync(string projectKey, int startAt = 0, int maxResults = 50, CancellationToken token = default(CancellationToken))
{
var settings = _jira.RestClient.Settings.JsonSerializerSettings;
var resource = String.Format("rest/api/2/project/{0}/version?startAt={1}&maxResults={2}",
projectKey,
startAt,
maxResults);
var result = await _jira.RestClient.ExecuteRequestAsync(Method.GET, resource, null, token).ConfigureAwait(false);
var versions = result["values"]
.Cast <JObject>()
.Select(versionJson =>
{
var remoteVersion = JsonConvert.DeserializeObject <RemoteVersion>(versionJson.ToString(), settings);
remoteVersion.ProjectKey = projectKey;
return(new ProjectVersion(_jira, remoteVersion));
});
return(PagedQueryResult <ProjectVersion> .FromJson((JObject)result, versions));
}
public Task <IPagedQueryResult <Comment> > GetCommentsFromIssueAsync(string issueKey, int maxComments, int startAt, CancellationToken token)
{
var resource = String.Format("rest/api/2/issue/{0}/comment", issueKey);
var parameters = new
{
startAt = startAt,
maxResults = maxComments,
};
return(this.ExecuteRequestAsync(Method.GET, resource, parameters).ContinueWith <IPagedQueryResult <Comment> >(task =>
{
var comments = task.Result["comments"]
.Cast <JObject>()
.Select(commentJson =>
{
var remoteComment = JsonConvert.DeserializeObject <RemoteComment>(commentJson.ToString(), this.GetSerializerSettings());
return new Comment(remoteComment);
});
return PagedQueryResult <Comment> .FromJson((JObject)task.Result, comments);
}));
}
public Task <IEnumerable <Issue> > GetIssuesFromJqlAsync(string jql, int?maxIssues, int startAt, CancellationToken token)
{
var jira = this._getCurrentJiraFunc();
var parameters = new
{
jql = jql,
startAt = startAt,
maxResults = maxIssues ?? jira.MaxIssuesPerRequest,
};
return(this.ExecuteRequestAsync(Method.POST, "rest/api/2/search", parameters, token).ContinueWith <IEnumerable <Issue> >(task =>
{
var issues = task.Result["issues"]
.Cast <JObject>()
.Select(issueJson =>
{
var remoteIssue = JsonConvert.DeserializeObject <RemoteIssueWrapper>(issueJson.ToString(), this.GetSerializerSettings()).RemoteIssue;
return new Issue(jira, remoteIssue);
});
return PagedQueryResult <Issue> .FromJson((JObject)task.Result, issues);
}));
}
