JIRA 작업을 MS Project MPP 파일로 내 보냅니다

이 기사에서는 REST API를 사용하여 JIRA에서 [MPP]로 작업을 내보내는 방법을 보여 드리겠습니다.

Jira 작업을 MPP로 내보내십시오

다음은 JIRA 작업을 MPP 또는 Aspose.Tasks에서 지원하는 모든 내보내기 형식으로 내보내기위한 고유 한 솔루션을 구축 할 수있는 주요 아이디어를 보여주는 단순화 된 코드입니다.

JIRA에서 MPP 형식으로 작업을 내보내려면 다음 단계를 수행해야합니다.

1. Jira API에 요청하여 내보내기 작업을 선택하십시오.
2. 프로젝트 클래스 인스턴스를 만듭니다.
3. 결과 JSON을 통과하고 결과 JSON의 각 “문제"엔티티에 대한 작업 객체를 만듭니다.
4. 작업 설정을위한 논리를 구현하십시오.
5. 프로젝트 클래스 인스턴스를 필요한 형식의 파일에 저장하십시오 (이 예제의 MPP).

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");
        }
    }
}

This example demonstrates how to retrieve tasks from Jira using the REST API, convert them into Task objects with Aspose.Tasks, and export them to the MPP format. The process begins with an HTTP request to the Jira API using basic authentication. The received JSON data is parsed and stored in a dictionary for further processing. The TasksBuilder class is responsible for constructing the task hierarchy by iterating through issues and creating corresponding tasks and subtasks. Each task is assigned extended attributes that include the issue key and a link to the original Jira issue. The implementation includes a placeholder for setting task start and finish dates, as well as duration, which should be defined according to the project’s requirements. Finally, the constructed project is saved to a file in the MPP format.