public Task <IPagedQueryResult <Issue> > GetIssuesFromJqlAsync(string jql, int?maxIssues = default(int?), int startAt = 0, CancellationToken token = default(CancellationToken))
{
var options = new IssueSearchOptions(jql)
{
MaxIssuesPerRequest = maxIssues,
StartAt = startAt,
ValidateQuery = this.ValidateQuery
};
return(GetIssuesFromJqlAsync(options, token));
}
protected virtual async Task <IPagedQueryResult <Issue> > GetPagedResultsAsync(Jira jira, string jql, int pageNumber, int resultsPerPage)
{
IList <Issue> issues = new List <Issue>();
IssueSearchOptions options = new IssueSearchOptions(jql)
{
MaxIssuesPerRequest = resultsPerPage,
StartAt = resultsPerPage * pageNumber,
FetchBasicFields = true
};
return(await jira.Issues.GetIssuesFromJqlAsync(options));
}
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 GetIssueThatIncludesOnlyAllNonBasicFields(Jira jira)
{
// Arrange
var issue = new Issue(jira, "TST")
{
Type = "1",
Summary = "Test issue",
Assignee = "admin"
};
issue.SaveChanges();
await issue.AddCommentAsync("My comment");
await issue.AddWorklogAsync("1d");
// Act
var options = new IssueSearchOptions($"key = {issue.Key.Value}")
{
FetchBasicFields = false,
AdditionalFields = new List <string>()
{
"comment", "watches", "worklog"
}
};
var issues = await jira.Issues.GetIssuesFromJqlAsync(options);
var serverIssue = issues.First();
// Assert
Assert.Null(serverIssue.Summary);
Assert.True(serverIssue.AdditionalFields.ContainsKey("watches"));
var worklogs = serverIssue.AdditionalFields.Worklogs;
Assert.Equal(20, worklogs.ItemsPerPage);
Assert.Equal(0, worklogs.StartAt);
Assert.Equal(1, worklogs.TotalItems);
Assert.Equal("1d", worklogs.First().TimeSpent);
var comments = serverIssue.AdditionalFields.Comments;
Assert.Equal(1, comments.ItemsPerPage);
Assert.Equal(0, comments.StartAt);
Assert.Equal(1, comments.TotalItems);
Assert.Equal("My comment", comments.First().Body);
}
public async Task GetIssueThatIncludesOnlyOneBasicField(Jira jira)
{
var options = new IssueSearchOptions("key = TST-1")
{
FetchBasicFields = false,
AdditionalFields = new List <string>()
{
"summary"
}
};
var issues = await jira.Issues.GetIssuesFromJqlAsync(options);
Assert.NotNull(issues.First().Summary);
Assert.Null(issues.First().Assignee);
}
public async Task GetIssueThatIncludesOnlyOneNonBasicField(Jira jira)
{
var options = new IssueSearchOptions("key = TST-1")
{
FetchBasicFields = false,
AdditionalFields = new List <string>()
{
"attachment"
}
};
var issues = await jira.Issues.GetIssuesFromJqlAsync(options);
var issue = issues.First();
Assert.Null(issue.Summary);
Assert.NotEmpty(issue.AdditionalFields.Attachments);
}
public async Task <IDictionary <string, Issue> > GetIssuesAsync(IEnumerable <string> issueKeys, CancellationToken token = default(CancellationToken))
{
if (issueKeys.Any())
{
var distinctKeys = issueKeys.Distinct();
var jql = String.Format("key in ({0})", String.Join(",", distinctKeys));
var options = new IssueSearchOptions(jql)
{
MaxIssuesPerRequest = distinctKeys.Count(),
ValidateQuery = false
};
var result = await this.GetIssuesFromJqlAsync(options, token).ConfigureAwait(false);
return(result.ToDictionary <Issue, string>(i => i.Key.Value));
}
else
{
return(new Dictionary <string, Issue>());
}
}
public List <Issue> GetIssues(string jql, bool basicFields, params string[] additionalFields)
{
List <Issue> issues = new List <Issue>();
int incr = 0;
int total = 0;
IssueSearchOptions searchOptions = new IssueSearchOptions(jql);
searchOptions.FetchBasicFields = basicFields;
searchOptions.MaxIssuesPerRequest = _jira.Issues.MaxIssuesPerRequest;
if (additionalFields == null)
{
if (!string.IsNullOrWhiteSpace(_epicLinkFieldKey))
{
additionalFields = new string[] { _epicLinkFieldKey };
}
}
if (additionalFields == null)
{
if (!string.IsNullOrWhiteSpace(_featureTeamChoicesFieldKey))
{
additionalFields = new string[] { _featureTeamChoicesFieldKey };
}
}
if (additionalFields != null)
{
var fldList = additionalFields.ToList();
if (!fldList.Contains(_epicLinkFieldKey) && !string.IsNullOrWhiteSpace(_epicLinkFieldKey))
{
fldList.Add(_epicLinkFieldKey);
}
if (!fldList.Contains(_featureTeamChoicesFieldKey) && !string.IsNullOrWhiteSpace(_featureTeamChoicesFieldKey))
{
fldList.Add(_featureTeamChoicesFieldKey);
}
searchOptions.AdditionalFields = fldList;
}
do
{
searchOptions.StartAt = incr;
Task <IPagedQueryResult <Issue> > results = _jira.Issues.GetIssuesFromJqlAsync(searchOptions);
results.Wait();
total = results.Result.TotalItems;
foreach (Issue i in results.Result)
{
issues.Add((Issue)i);
}
incr += results.Result.Count();
}while (incr < total);
return(issues);
}
public async Task <IList <IssueLight> > GetAllIssuesInProject(IReadOnlyCollection <JiraNamedObjectLight> customFields)
{
if (customFields == null)
{
throw new ArgumentNullException(nameof(customFields));
}
var epicField = customFields.First(cf => cf.Name == _jiraContext.EpicLinkName);
var storyPointsField = customFields.First(cf => cf.Name == _jiraContext.StoryPointsName);
bool useStatus = _jiraContext.ExcludedStatuses?.LongLength > 0;
bool useCreated = false;
bool useEpics = _jiraContext.Epics?.Any() ?? false;
string epics = string.Join(',', _jiraContext.Epics?.Select(i => $"\"{i}\"") ?? Enumerable.Empty <string>());
string excludedStatuses = string.Join(',',
_jiraContext.ExcludedStatuses ?? Enumerable.Empty <string>());
var createdFilterPart =
$@" AND Created > ""{DateTime.Today.AddDays(-_jiraContext.DaysBackToFetchIssues).Date:yyyy-MM-dd}"" ";
var statusFilterPart = $" AND Status NOT IN ( {excludedStatuses} ) ";
var epicFilterPart = $@" AND (""{epicField.Name}"" in ({epics}) OR parent in ({epics}) OR id in ({epics}) ) ";
var searchOptions =
new IssueSearchOptions(
$@" Project = ""{_jiraContext.Project}""{(useStatus ? statusFilterPart:"")}{(useEpics ? epicFilterPart:"")}{(useCreated ? createdFilterPart: "")} ")
{
StartAt = 0,
FetchBasicFields = false,
AdditionalFields = new[]
{
"key",
"assignee",
"reporter",
"created",
"summary",
"status",
"issuetype",
epicField.Id,
storyPointsField.Id,
"parent",
"labels"
}
};
Console.WriteLine($"JQL: {searchOptions.Jql}");
var result = new List <IssueLight>();
IPagedQueryResult <Issue> pages = null;
do
{
pages = await _jira.Issues.GetIssuesFromJqlAsync(searchOptions).ConfigureAwait(false);
Debug.Assert(pages != null);
result.AddRange(pages.Select(i => i.ToIssueLight(epicField.Id, storyPointsField.Id)));
searchOptions.StartAt = Math.Min(searchOptions.StartAt + pages.ItemsPerPage, pages.TotalItems);
} while (searchOptions.StartAt < pages.TotalItems);
return(result);
}
