Export Jira tasks to MS Project MPP file

In this article we are going to show how to export tasks from Jira using REST API to MPP file format using Aspose.Tasks for .NET.

Export Jira tasks to MPP

Here is the simplified code which demonstrates the key ideas which allows your to build your own solution to export Jira tasks to MPP or any export format supported by Aspose.Tasks for .NET.

In order to export tasks from Jira to MPP format the following steps should be performed:

1. Make a request to Jira API to select the tasks to export.
2. Create an instance of Project class.
3. Traverse the resulting JSON and create a Task object for each “issue” entity in the resulting JSON.
4. Implement logic for setting Task.Start, Finish and Duration fields.
5. Save the instance of Project class to a file in the required format (MPP in this example).

using System;
using System.Collections.Generic;
using System.Net.Http;
using Aspose.Tasks;
using Newtonsoft.Json.Linq;
using Task = Aspose.Tasks.Task;

namespace JiraToMpp
{
    class Program
    {
        private static readonly string OutputFileName = @"c:\output.mpp";
        private static readonly string LicenseFileName = @"c:\Aspose.Tasks.NET.SHA256.lic";
        private static readonly string JiraHost = @"https://issue.test.local";
        private static readonly string UserName = "user_name";
        private static readonly string UserApiKey = "user_api_key";

        static async System.Threading.Tasks.Task Main()
        {
            System.Text.Encoding.RegisterProvider(System.Text.CodePagesEncodingProvider.Instance);
            SetLicense();

            HttpClient client = new HttpClient();

            AddBasicAuthorizationHeader(client);

            string endPointAddress = JiraHost + "/rest/api/2/search?jql=ORDER%20BY%20Created&maxResults=100&startAt=0";
            var result = await client.GetStringAsync(endPointAddress);
            dynamic deserialized = JObject.Parse(result);
            var issues = deserialized.issues;

            Project project = new Project();
            Dictionary<string, dynamic> rawTasks = new Dictionary<string, dynamic>();
            HashSet<string> subTasksSet = new HashSet<string>();

            foreach (var issue in issues)
            {
                rawTasks.Add((string)issue.key, issue);

                if (issue.fields.subtasks != null && issue.fields.subtasks.Count > 0)
                {
                    foreach (var subTask in issue.fields.subtasks)
                    {
                        subTasksSet.Add((string)subTask.key);
                    }
                }

            }

            var builder = new TasksBuilder(project, rawTasks, subTasksSet);
            builder.Build();

            project.Save(OutputFileName, SaveFileFormat.Mpp);
        }

        private static void SetLicense()
        {
            License l = new License();
            using (var fs2 = System.IO.File.OpenRead(LicenseFileName))
            {
                l.SetLicense(fs2);
            }
        }

        private static void AddBasicAuthorizationHeader(HttpClient client)
        {
            string headerValue = string.Format("{0}:{1}", UserName, UserApiKey);
            var bytes = System.Text.Encoding.UTF8.GetBytes(headerValue);
            var encodedText = Convert.ToBase64String(bytes);
            client.DefaultRequestHeaders.Add("Authorization", "Basic " + encodedText);
        }
    }

    internal sealed class TasksBuilder
    {
        private readonly Project project;
        private readonly Dictionary<string, dynamic> jsonTasks;
        private readonly HashSet<string> subTasks;
        private readonly HashSet<string> processedIssues = new HashSet<string>();

        private ExtendedAttributeDefinition linkExtendedAttribute;
        private ExtendedAttributeDefinition jiraKeyExtendedAttribute;

        public TasksBuilder(Project project, Dictionary<string, dynamic> jsonTasks, HashSet<string> subTasks)
        {
            this.project = project;
            this.jsonTasks = jsonTasks;
            this.subTasks = subTasks;
            this.SetUpExtendedAttributes();
        }

        public void Build()
        {
            foreach (var kv in this.jsonTasks)
            {
                if (this.processedIssues.Contains(kv.Key))
                {
                    continue;
                }

                if (this.subTasks.Contains(kv.Key))
                {
                    continue;
                }

                this.ProcessIssue(kv.Value, this.project.RootTask.Children);
                this.processedIssues.Add(kv.Key);
            }
        }

        private void ProcessIssue(dynamic issue, TaskCollection parentCollection)
        {
            var taskName = (string)issue.fields["summary"];

            Task task = parentCollection.Add(taskName);

            Console.WriteLine("Added task " + taskName);
            
            // TODO : implement logic for setting task's start, finish and duration.

            this.MapExtendedAttributes(issue, task);

            if (issue.fields.subtasks == null)
            {
                return;
            }

            foreach (var subTask in issue.fields.subtasks)
            {
                var subTaskKey = (string)subTask.key;
                var rawSubTask = this.jsonTasks[subTaskKey];
                this.ProcessIssue(rawSubTask, task.Children);
            }
        }

        private void MapExtendedAttributes(dynamic rawIssue, Task task)
        {
            var key = (string)rawIssue.key;
            var link = (string)rawIssue.self;

            task.ExtendedAttributes.Add(this.jiraKeyExtendedAttribute.CreateExtendedAttribute(key));
            task.ExtendedAttributes.Add(this.linkExtendedAttribute.CreateExtendedAttribute(link));
        }

        private void SetUpExtendedAttributes()
        {
            this.linkExtendedAttribute = ExtendedAttributeDefinition.CreateTaskDefinition(ExtendedAttributeTask.Text1, "Link to the issue");
            this.jiraKeyExtendedAttribute = ExtendedAttributeDefinition.CreateTaskDefinition(ExtendedAttributeTask.Text2, "Issue Key");
        }
    }
}