public void ReleaseVersion(IJiraRestClient jiraRestClient, string projectKey, string version)
{
Argument.IsNotNull(() => jiraRestClient);
Argument.IsNotNullOrWhitespace(() => projectKey);
Argument.IsNotNullOrWhitespace(() => version);
Log.Info("Releasing version '{0}'", version);
var projectVersion = GetProjectVersion(jiraRestClient, projectKey, version);
if (projectVersion == null)
{
var error = string.Format("Version {0} does not exist, make sure to create it first", version);
Log.Error(error);
throw new InvalidOperationException(error);
}
if (projectVersion.Released)
{
Log.Info("Version was already released on {0}", projectVersion.ReleaseDate);
return;
}
projectVersion.ReleaseDate = DateTime.Now;
projectVersion.Released = true;
jiraRestClient.UpdateProjectVersion(projectVersion);
Log.Info("Released version '{0}'", version);
}
public static List <JiraIssue> GetIssues(this IJiraRestClient jiraRestClient, string jql, int startAt = 0, int maxResults = 200,
string[] fields = null)
{
Argument.IsNotNull(() => jiraRestClient);
var issues = new List <JiraIssue>();
var searchRequest = new JiraSearchRequest
{
Jql = jql,
StartAt = startAt,
MaxResults = maxResults,
};
if (fields != null)
{
searchRequest.Fields.AddRange(fields);
}
var requestJson = JsonConvert.SerializeObject(searchRequest, GetJsonSettings());
var responseJson = jiraRestClient.ExecuteRequestRaw(Method.POST, "rest/api/2/search", requestJson);
foreach (var jsonElement in responseJson.Children())
{
var issue = JsonConvert.DeserializeObject <JiraIssue>(jsonElement.ToString());
issues.Add(issue);
}
return(issues);
}
private JiraProjectVersion GetProjectVersion(IJiraRestClient jiraRestClient, string project, string version)
{
var existingVersion = (from x in jiraRestClient.GetProjectVersions(project)
where string.Equals(x.Name, version, StringComparison.OrdinalIgnoreCase)
select x).FirstOrDefault();
return(existingVersion);
}
private JiraProject GetProject(IJiraRestClient jiraRestClient, string projectKey)
{
var existingProject = (from x in jiraRestClient.GetProjects()
where string.Equals(x.Key, projectKey, StringComparison.OrdinalIgnoreCase)
select x).FirstOrDefault();
return(existingProject);
}
/// <summary>
/// Creates a JIRA client with the given rest client implementation.
/// </summary>
/// <param name="jiraClient">Rest client to use.</param>
/// <param name="credentials">Credentials to use.</param>
/// <param name="cache">Cache to use.</param>
public static Jira CreateRestClient(IJiraRestClient jiraClient, JiraCredentials credentials = null, JiraCache cache = null)
{
var services = new ServiceLocator();
var jira = new Jira(services, credentials, cache);
ConfigureDefaultServices(services, jira, jiraClient);
return(jira);
}
/// <summary>
/// Creates a JIRA client with the given rest client implementation.
/// </summary>
/// <param name="restClient">Rest client to use.</param>
/// <param name="cache">Cache to use.</param>
public static Jira CreateRestClient(IJiraRestClient restClient)
{
var services = new ServiceLocator();
var jira = new Jira(services);
ConfigureDefaultServices(services, jira, restClient);
return(jira);
}
public RestJiraApi(IJiraApiSettings jiraApiSettings, LocalDirs localDirs, CancellationToken cancellationToken)
{
_jiraApiSettings = jiraApiSettings ?? throw new ArgumentNullException(nameof(jiraApiSettings));
_localDirs = localDirs ?? throw new ArgumentNullException(nameof(localDirs));
_cancellationToken = cancellationToken;
_apiUrl = "/rest/api/2/";
_jiraClient = Atlassian.Jira.Jira.CreateRestClient(jiraApiSettings.JiraUrl, jiraApiSettings.JiraUsername, jiraApiSettings.JiraToken.Value);
_restClient = _jiraClient.RestClient;
}
public static void UpdateProjectVersion(this IJiraRestClient jiraRestClient, JiraProjectVersion projectVersion)
{
Argument.IsNotNull(() => jiraRestClient);
Argument.IsNotNull(() => projectVersion);
var requestJson = JsonConvert.SerializeObject(projectVersion, GetJsonSettings());
var resource = string.Format("rest/api/2/version/{0}", projectVersion.Id);
var responseJson = jiraRestClient.ExecuteRequestRaw(Method.PUT, resource, requestJson);
}
public static List <JiraProject> GetProjects(this IJiraRestClient jiraRestClient)
{
Argument.IsNotNull(() => jiraRestClient);
var projects = new List <JiraProject>();
var responseJson = jiraRestClient.ExecuteRequest(Method.GET, "rest/api/2/project");
foreach (var jsonElement in responseJson.Children())
{
var project = JsonConvert.DeserializeObject <JiraProject>(jsonElement.ToString());
projects.Add(project);
}
return(projects);
}
public void CreateVersion(IJiraRestClient jiraRestClient, string projectKey, string version)
{
Argument.IsNotNull(() => jiraRestClient);
Argument.IsNotNullOrWhitespace(() => projectKey);
Argument.IsNotNullOrWhitespace(() => version);
Log.Info("Creating version '{0}'", version);
Log.Debug("Checking if version already exists");
var existingVersion = GetProjectVersion(jiraRestClient, projectKey, version);
if (existingVersion != null)
{
Log.Info("Version '{0}' already exists", version);
if (existingVersion.Released)
{
var error = string.Format("Version '{0}' is already released, are you re-releasing an existing version?", version);
Log.Error(error);
throw new InvalidOperationException(error);
}
return;
}
Log.Debug("Version does not yet exist, creating version");
var project = GetProject(jiraRestClient, projectKey);
if (project == null)
{
var error = string.Format("Project '{0}' cannot be found or current user does not have access to the project", projectKey);
Log.Error(error);
throw new InvalidOperationException(error);
}
jiraRestClient.CreateProjectVersion(new JiraProjectVersion
{
Project = project.Key,
Name = version,
});
Log.Info("Created version '{0}'", version);
}
public static JToken ExecuteRequestRaw(this IJiraRestClient jiraRestClient, Method method, string resource, string jsonRequestBody)
{
var restRequest = new RestRequest
{
Resource = resource,
Method = method,
RequestFormat = DataFormat.Json,
};
restRequest.AddParameter(new Parameter
{
Name = "application/json",
Type = ParameterType.RequestBody,
Value = jsonRequestBody
});
var response = jiraRestClient.ExecuteRequest(restRequest);
return(response.StatusCode != HttpStatusCode.NoContent ? JToken.Parse(response.Content) : new JObject());
}
public static List <JiraProjectVersion> GetProjectVersions(this IJiraRestClient jiraRestClient, string projectKey)
{
Argument.IsNotNull(() => jiraRestClient);
Argument.IsNotNullOrWhitespace(() => projectKey);
var projectVersions = new List <JiraProjectVersion>();
var resource = string.Format("rest/api/2/project/{0}/versions", projectKey);
var responseJson = jiraRestClient.ExecuteRequest(Method.GET, resource);
foreach (var jsonElement in responseJson.Children())
{
var projectVersion = JsonConvert.DeserializeObject <JiraProjectVersion>(jsonElement.ToString());
projectVersion.Project = projectKey;
projectVersions.Add(projectVersion);
}
return(projectVersions);
}
public void MergeVersions(IJiraRestClient jiraRestClient, string projectKey, string version)
{
Argument.IsNotNull(() => jiraRestClient);
Argument.IsNotNullOrWhitespace(() => projectKey);
Argument.IsNotNullOrWhitespace(() => version);
Log.Info("Merging all prerelease versions into '{0}'", version);
if (!_versionInfoService.IsStableVersion(version))
{
Log.Info("Version '{0}' is not a stable version, versions will not be merged", version);
return;
}
var allVersions = jiraRestClient.GetProjectVersions(projectKey);
var newVersion = allVersions.First(x => string.Equals(x.Name, version));
var versionsToMerge = new List <JiraProjectVersion>();
foreach (var remoteVersion in allVersions)
{
if (_mergeVersionService.ShouldBeMerged(version, remoteVersion.Name))
{
versionsToMerge.Add(remoteVersion);
}
}
foreach (var versionToMerge in versionsToMerge)
{
if (string.Equals(versionToMerge.Id, newVersion.Id))
{
continue;
}
Log.Debug("Deleting version '{0}' and moving issues to '{1}'", versionToMerge, newVersion);
jiraRestClient.DeleteProjectVersion(versionToMerge, newVersion, newVersion);
}
Log.Info("Merged all prerelease versions into '{0}'", version);
}
public static void DeleteProjectVersion(this IJiraRestClient jiraRestClient, JiraProjectVersion projectVersion, JiraProjectVersion projectToMoveFixIssuesTo = null,
JiraProjectVersion projectToMoveAffectedIssuesTo = null)
{
Argument.IsNotNull(() => jiraRestClient);
Argument.IsNotNull(() => projectVersion);
var resource = string.Format("rest/api/2/version/{0}", projectVersion.Id);
if (projectToMoveFixIssuesTo != null)
{
resource += resource.Contains("?") ? "&" : "?";
resource += string.Format("moveFixIssuesTo={0}", projectToMoveFixIssuesTo.Id);
}
if (projectToMoveAffectedIssuesTo != null)
{
resource += resource.Contains("?") ? "&" : "?";
resource += string.Format("moveAffectedIssuesTo={0}", projectToMoveAffectedIssuesTo.Id);
}
var responseJson = jiraRestClient.ExecuteRequest(Method.DELETE, resource);
}
/// <summary>
/// Create a client that connects with a JIRA server with specified dependencies.
/// </summary>
public Jira(IJqlExpressionVisitor translator,
IJiraSoapClient jiraService,
IFileSystem fileSystem,
JiraCredentials credentials = null,
string accessToken = null,
JiraCache cache = null)
{
_provider = new JiraQueryProvider(translator, this);
_jiraService = jiraService;
_fileSystem = fileSystem;
_token = accessToken;
_credentials = credentials;
_restClient = jiraService as IJiraRestClient;
_cache = cache ?? new JiraCache();
this.MaxIssuesPerRequest = DEFAULT_MAX_ISSUES_PER_REQUEST;
this.Debug = false;
if (_restClient == null && !String.IsNullOrEmpty(jiraService.Url))
{
var options = new JiraRestClient.Options()
{
Url = jiraService.Url,
RestClientSettings = new JiraRestClientSettings(),
GetCurrentJiraFunc = () => this
};
if (this._credentials != null)
{
options.Username = _credentials.UserName;
options.Password = _credentials.Password;
}
this._restClient = new JiraRestClient(options);
}
}
public JiraClient(IJiraRestClient client)
{
RestClient = client;
IssueClient = new JiraIssueClient(client);
UserClient = new JiraUserClient(client);
}
private static void ConfigureDefaultServices(ServiceLocator services, Jira jira, IJiraRestClient restClient)
{
services.Register <IProjectVersionService>(() => new ProjectVersionService(jira));
services.Register <IProjectComponentService>(() => new ProjectComponentService(jira));
services.Register <IIssuePriorityService>(() => new IssuePriorityService(jira));
services.Register <IIssueResolutionService>(() => new IssueResolutionService(jira));
services.Register <IIssueStatusService>(() => new IssueStatusService(jira));
services.Register <IIssueLinkService>(() => new IssueLinkService(jira));
services.Register <IIssueRemoteLinkService>(() => new IssueRemoteLinkService(jira));
services.Register <IIssueTypeService>(() => new IssueTypeService(jira));
services.Register <IIssueFilterService>(() => new IssueFilterService(jira));
services.Register <IIssueFieldService>(() => new IssueFieldService(jira));
services.Register <IIssueService>(() => new IssueService(jira, restClient.Settings));
services.Register <IJiraUserService>(() => new JiraUserService(jira));
services.Register <IJiraGroupService>(() => new JiraGroupService(jira));
services.Register <IProjectService>(() => new ProjectService(jira));
services.Register <IScreenService>(() => new ScreenService(jira));
services.Register <IServerInfoService>(() => new ServerInfoService(jira));
services.Register <IJqlExpressionVisitor>(() => new JqlExpressionVisitor());
services.Register <IFileSystem>(() => new FileSystem());
services.Register(() => restClient);
}
public JiraUserClient(IJiraRestClient restClient)
{
_restClient = restClient;
}
public JiraDataProvider(IJiraRestClient client)
{
this.client = client;
}
public JiraDataProvider(IJiraRestClient client)
{
this.client = client;
}
public static List <JiraIssue> GetIssues(this IJiraRestClient jiraRestClient, string jql, int startAt = 0, int maxResults = 200)
{
var issues = new List <JiraIssue>();
var searchRequest = new JiraSearchRequest
{
Jql = jql,
StartAt = startAt,
MaxResults = maxResults,
};
//if (fields != null)
//{
// searchRequest.Fields.AddRange(fields);
//}
var requestJson = JsonConvert.SerializeObject(searchRequest, GetJsonSettings());
var responseJson = jiraRestClient.ExecuteRequestRaw(Method.POST, "rest/api/2/search", requestJson);
var issuesJson = responseJson["issues"];
foreach (var jsonElement in issuesJson.Children())
{
var issue = JsonConvert.DeserializeObject <JiraIssue>(jsonElement.ToString());
var fieldsElement = jsonElement["fields"];
if (fieldsElement != null)
{
issue.summary = fieldsElement.Value <string>("summary");
issue.description = fieldsElement.Value <string>("description");
issue.created = fieldsElement.Value <DateTime?>("created");
issue.resolutionDate = fieldsElement.Value <DateTime?>("resolutiondate");
var statusElement = fieldsElement["status"];
if (statusElement != null)
{
issue.status = statusElement.Value <string>("id");
}
var labelsElement = fieldsElement["labels"];
if (labelsElement != null)
{
issue.labels = JsonConvert.DeserializeObject <List <string> >(labelsElement.ToString());
}
var fixVersionsElement = fieldsElement["fixVersions"];
if (fixVersionsElement != null)
{
foreach (var fixVersionElement in fixVersionsElement)
{
var fixVersion = JsonConvert.DeserializeObject <JiraFixVersion>(fixVersionElement.ToString());
issue.fixVersions.Add(fixVersion);
}
}
}
issues.Add(issue);
}
return(issues);
}
public JiraIssueClient(IJiraRestClient restClient)
{
_restClient = restClient;
}