Merge pull request #18 from JakeGinnivan/JiraSupport

Added support for Jira fixing #14

Author: JakeGinnivan

src/GitReleaseNotes.Tests/GitReleaseNotes.Tests.csproj

@@ -68,6 +68,7 @@
     <Compile Include="CommitGrouperTests.cs" />
     <Compile Include="IssueTrackers\GitHub\GitHubIssueTrackerTests.cs" />
     <Compile Include="IssueTrackers\IssueNumberExtractor.cs" />
+    <Compile Include="IssueTrackers\Jira\JiraIssueTrackerTests.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
     <Compile Include="ReleaseFileWriterTests.cs" />
     <Compile Include="ReleaseNotesGeneratorTests.cs" />

src/GitReleaseNotes.Tests/IssueTrackers/Jira/JiraIssueTrackerTests.cs

@@ -0,0 +1,60 @@
+using System;
+using System.Collections.Generic;
+using GitReleaseNotes.IssueTrackers;
+using GitReleaseNotes.IssueTrackers.Jira;
+using LibGit2Sharp;
+using NSubstitute;
+using Xunit;
+
+namespace GitReleaseNotes.Tests.IssueTrackers.Jira
+{
+    public class JiraIssueTrackerTests
+    {
+        private readonly IJiraApi _jiraApi;
+        private readonly JiraIssueTracker _sut;
+
+        public JiraIssueTrackerTests()
+        {
+            _jiraApi = Substitute.For<IJiraApi>();
+            _sut = new JiraIssueTracker(new IssueNumberExtractor(), _jiraApi);
+        }
+
+        [Fact]
+        public void CreatesReleaseNotesForClosedGitHubIssues()
+        {
+            var commit = CreateCommit("Fixes JIRA-5", DateTimeOffset.Now.AddDays(-1));
+            var commitsToScan = new List<Commit> { commit };
+            var toScan = new Dictionary<ReleaseInfo, List<Commit>>
+            {
+                {new ReleaseInfo(), commitsToScan}
+            };
+            _jiraApi
+                .GetPotentialIssues(Arg.Any<Dictionary<ReleaseInfo, List<Commit>>>(), Arg.Any<GitReleaseNotesArguments>())
+                .Returns(new List<JiraIssue>
+                {
+                    new JiraIssue
+                    {
+                        Id = "JIRA-5",
+                        Name = "Issue Title"
+                    }
+                });
+
+            var releaseNotes = _sut.ScanCommitMessagesForReleaseNotes(new GitReleaseNotesArguments
+            {
+                JiraServer = "http://my.jira.net",
+                JiraProjectId = "JIRA"
+            }, toScan);
+
+            Assert.Equal("Issue Title", releaseNotes.Releases[0].ReleaseNoteItems[0].Title);
+        }
+
+        private static Commit CreateCommit(string message, DateTimeOffset when)
+        {
+            var commit = Substitute.For<Commit>();
+            commit.Message.Returns(message);
+            var commitSignature = new Signature("Jake", "", when);
+            commit.Author.Returns(commitSignature);
+            return commit;
+        }
+    }
+}

src/GitReleaseNotes/GitReleaseNotes.csproj

@@ -47,6 +47,7 @@
     <Reference Include="System.ComponentModel.DataAnnotations" />
     <Reference Include="System.Core" />
     <Reference Include="System.Net.Http" />
+    <Reference Include="System.Web.Helpers, Version=2.0.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35, processorArchitecture=MSIL" />
     <Reference Include="System.Xml.Linq" />
     <Reference Include="System.Data.DataSetExtensions" />
     <Reference Include="Microsoft.CSharp" />
@@ -70,6 +71,9 @@
     <Compile Include="IssueTrackers\IssueNumberExtractor.cs" />
     <Compile Include="IssueTrackers\IIssueTracker.cs" />
     <Compile Include="IssueTrackers\IssueTracker.cs" />
+    <Compile Include="IssueTrackers\Jira\JiraApi.cs" />
+    <Compile Include="IssueTrackers\Jira\JiraIssue.cs" />
+    <Compile Include="IssueTrackers\Jira\JiraIssueTracker.cs" />
     <Compile Include="Log.cs" />
     <Compile Include="Program.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />

src/GitReleaseNotes/GitReleaseNotesArguments.cs

@@ -12,7 +12,7 @@ public class GitReleaseNotesArguments
         [Description("Enables verbose logging")]
         public bool Verbose { get; set; }
 
-        [Description("Specifies the issue tracker used, possible Options: GitHub")]
+        [Description("Specifies the issue tracker used, possible Options: GitHub, Jira")]
         public IssueTracker? IssueTracker { get; set; }
 
         [Description("Speficy the tag name to start from, default is the last tag on master")]
@@ -21,6 +21,21 @@ public class GitReleaseNotesArguments
         [Description("GitHub access token")]
         public string Token { get; set; }
 
+        [Description("Jira Username")]
+        public string Username { get; set; }
+
+        [Description("Jira Password")]
+        public string Password { get; set; }
+
+        [Description("Jira project Id")]
+        public string JiraProjectId { get; set; }
+
+        [Description("Jql query for closed issues you would like included if mentioned. Defaults to project = <YOURPROJECTID> AND (issuetype = Bug OR issuetype = Story OR issuetype = \"New Feature\") AND status in (Closed, Done, Resolved)")]
+        public string Jql { get; set; }
+
+        [Description("Url of Jira server")]
+        public string JiraServer { get; set; }
+
         [Description("GitHub Repository name, in Organisation/Repository format")]
         public string Repo { get; set; }
 

src/GitReleaseNotes/IssueTrackers/IssueTracker.cs

@@ -3,8 +3,8 @@ namespace GitReleaseNotes.IssueTrackers
     public enum IssueTracker
     {
         GitHub,
+        Jira
         //TODO Tfs
-        //TODO Jira
         //TODO Youtrack
     }
 }

src/GitReleaseNotes/IssueTrackers/Jira/JiraApi.cs

@@ -0,0 +1,70 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Net;
+using System.Text;
+using System.Web.Helpers;
+using LibGit2Sharp;
+
+namespace GitReleaseNotes.IssueTrackers.Jira
+{
+    public interface IJiraApi
+    {
+        IEnumerable<JiraIssue> GetPotentialIssues(Dictionary<ReleaseInfo, List<Commit>> releases, GitReleaseNotesArguments arguments);
+    }
+
+    public class JiraApi : IJiraApi
+    {
+        public IEnumerable<JiraIssue> GetPotentialIssues(Dictionary<ReleaseInfo, List<Commit>> releases, GitReleaseNotesArguments arguments)
+        {
+            var since = releases.SelectMany(c => c.Value).Select(c => c.Author.When).Min();
+            var sinceFormatted = since.ToString("yyyy-MM-d HH:mm");
+            var jql = string.Format("{0} AND updated > '{1}'", arguments.Jql, sinceFormatted).Replace("\"", "\\\"");
+
+            var searchUri = new Uri(new Uri(arguments.JiraServer, UriKind.Absolute), "/rest/api/latest/search");
+            var httpRequest = WebRequest.CreateHttp(searchUri);
+            var usernameAndPass = string.Format("{0}:{1}", arguments.Username, arguments.Password);
+            var token = Convert.ToBase64String(Encoding.UTF8.GetBytes(usernameAndPass));
+            httpRequest.Headers.Add("Authorization", string.Format("Basic {0}", token));
+            httpRequest.Method = "POST";
+            httpRequest.ContentType = "application/json";
+
+            using (var streamWriter = new StreamWriter(httpRequest.GetRequestStream()))
+            {
+                string json = "{\"jql\": \"" + jql + "\",\"startAt\": 0, \"maxResults\": 100, \"fields\": [\"summary\",\"issuetype\"]}";
+                streamWriter.Write(json);
+                streamWriter.Flush();
+                streamWriter.Close();
+            }
+
+            var response = (HttpWebResponse)httpRequest.GetResponse();
+            if ((int)response.StatusCode == 400)
+            {
+                throw new Exception("Jql query error, please review your Jql");
+            }
+
+            if (response.StatusCode != HttpStatusCode.OK)
+                throw new Exception("Failed to query Jira: " + response.StatusDescription);
+
+            using (var responseStream = response.GetResponseStream())
+            using (var responseReader = new StreamReader(responseStream))
+            {
+                var responseObject = Json.Decode(responseReader.ReadToEnd());
+                foreach (var issue in responseObject.issues)
+                {
+                    string summary = issue.fields.summary;
+                    string id = issue.key;
+                    string issueType = issue.fields.issuetype.name;
+
+                    yield return new JiraIssue
+                    {
+                        Id = id,
+                        Name = summary,
+                        IssueType = issueType
+                    };
+                }
+            }
+        }
+    }
+}

src/GitReleaseNotes/IssueTrackers/Jira/JiraIssue.cs

@@ -0,0 +1,9 @@
+namespace GitReleaseNotes.IssueTrackers.Jira
+{
+    public class JiraIssue
+    {
+        public string Id { get; set; }
+        public string Name { get; set; }
+        public string IssueType { get; set; }
+    }
+}

src/GitReleaseNotes/IssueTrackers/Jira/JiraIssueTracker.cs

@@ -0,0 +1,96 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using GitReleaseNotes.IssueTrackers.GitHub;
+using LibGit2Sharp;
+
+namespace GitReleaseNotes.IssueTrackers.Jira
+{
+    public class JiraIssueTracker : IIssueTracker
+    {
+        private readonly IIssueNumberExtractor _issueNumberExtractor;
+        private readonly IJiraApi _jiraApi;
+
+        public JiraIssueTracker(IIssueNumberExtractor issueNumberExtractor, IJiraApi jiraApi)
+        {
+            _issueNumberExtractor = issueNumberExtractor;
+            _jiraApi = jiraApi;
+        }
+
+        public SemanticReleaseNotes ScanCommitMessagesForReleaseNotes(
+            GitReleaseNotesArguments arguments,
+            Dictionary<ReleaseInfo, List<Commit>> releases)
+        {
+            var issueNumberRegexPattern = string.Format(@"(?<issueNumber>{0}-\d+)", arguments.JiraProjectId);
+            var issueNumbersToScan = _issueNumberExtractor.GetIssueNumbers(arguments, releases, issueNumberRegexPattern);
+
+            var potentialIssues = _jiraApi.GetPotentialIssues(releases, arguments).ToArray();
+
+            var closedMentionedIssuesByRelease = issueNumbersToScan.Select(issues =>
+            {
+                var issuesForRelease = potentialIssues
+                    .Where(i => issues.Value.Contains(i.Id))
+                    .ToArray();
+                return new
+                {
+                    ReleaseInfo = issues.Key,
+                    IssuesForRelease = issuesForRelease
+                };
+            })
+                .Where(g => g.IssuesForRelease.Any())
+                .OrderBy(g => g.ReleaseInfo.When);
+
+            var baseUrl = new Uri(arguments.JiraServer, UriKind.Absolute);
+            return new SemanticReleaseNotes(closedMentionedIssuesByRelease.Select(r =>
+            {
+                var releaseNoteItems = r.IssuesForRelease.Select(i =>
+                {
+                    var htmlUrl = new Uri(baseUrl, string.Format("browse/{0}", i.Id));
+                    return new ReleaseNoteItem(i.Name, i.Id, htmlUrl, new[] { i.IssueType });
+                }).ToArray();
+                return new SemanticRelease(r.ReleaseInfo.Name, r.ReleaseInfo.When, releaseNoteItems);
+            }));
+        }
+
+        public bool VerifyArgumentsAndWriteErrorsToConsole(GitReleaseNotesArguments arguments)
+        {
+            if (string.IsNullOrEmpty(arguments.JiraServer) ||
+                !Uri.IsWellFormedUriString(arguments.JiraServer, UriKind.Absolute))
+            {
+                Console.WriteLine("A valid Jira server must be specified [/JiraServer ]");
+                return false;
+            }
+
+            if (string.IsNullOrEmpty(arguments.JiraProjectId))
+            {
+                Console.WriteLine("/JiraProjectId is a required parameter for Jira");
+                return false;
+            }
+
+            if (string.IsNullOrEmpty(arguments.Username))
+            {
+                Console.WriteLine("/Username is a required to authenticate with Jira");
+                return false;
+            }
+            if (string.IsNullOrEmpty(arguments.Password))
+            {
+                Console.WriteLine("/Password is a required to authenticate with Jira");
+                return false;
+            }
+
+            if (string.IsNullOrEmpty(arguments.Jql))
+            {
+                arguments.Jql = string.Format("project = {0} AND " +
+                               "(issuetype = Bug OR issuetype = Story OR issuetype = \"New Feature\") AND " +
+                               "status in (Closed, Done, Resolved)", arguments.JiraProjectId);
+            }
+
+            return true;
+        }
+
+        public void PublishRelease(string releaseNotesOutput, GitReleaseNotesArguments arguments)
+        {
+            Console.WriteLine("Jira does not support publishing releases");
+        }
+    }
+}

src/GitReleaseNotes/Program.cs

@@ -9,6 +9,7 @@
 using GitReleaseNotes.Git;
 using GitReleaseNotes.IssueTrackers;
 using GitReleaseNotes.IssueTrackers.GitHub;
+using GitReleaseNotes.IssueTrackers.Jira;
 using Octokit;
 using Credentials = Octokit.Credentials;
 using Repository = LibGit2Sharp.Repository;
@@ -38,6 +39,9 @@ static int Main(string[] args)
                 return 1;
 
             CreateIssueTrackers(arguments);
+            if (!IssueTrackers.ContainsKey(arguments.IssueTracker.Value))
+                throw new Exception(string.Format("{0} is not a known issue tracker", arguments.IssueTracker.Value));
+
             var issueTracker = IssueTrackers[arguments.IssueTracker.Value];
             if (!issueTracker.VerifyArgumentsAndWriteErrorsToConsole(arguments))
                 return 1;
@@ -109,6 +113,10 @@ private static void CreateIssueTrackers(GitReleaseNotesArguments arguments)
                         {
                             Credentials = new Credentials(arguments.Token)
                         }, new Log())
+                },
+                {
+                    IssueTracker.Jira, 
+                    new JiraIssueTracker(new IssueNumberExtractor(), new JiraApi())
                 }
             };
         }