import * as settings from './settings';

import utils from './utils';

export default class GithubHelper {

constructor(githubApi, githubSettings, gitlabHelper) {

this.githubApi = githubApi;

this.githubOwner = githubSettings.owner;

this.githubToken = githubSettings.token;

this.githubRepo = githubSettings.repo;

this.githubTimeout = githubSettings.timeout;

this.gitlabHelper = gitlabHelper;

// regex for converting user from GitLab to GitHub

this.userProjectRegex = utils.generateUserProjectRegex();

}

/*

******************************************************************************

******************************** GET METHODS *********************************

******************************************************************************

*/

/**

* Get a list of all GitHub milestones currently in new repo

*/

async getAllGithubMilestones() {

try {

await utils.sleep(2000);

// get an array of GitHub milestones for the new repo

let result = await this.githubApi.issues.listMilestonesForRepo({

owner: this.githubOwner,

repo: this.githubRepo,

state: 'all',

});

// extract the milestone number and title and put into a new array

const milestones = result.data.map(x => ({

number: x.number,

title: x.title,

}));

return milestones;

} catch (err) {

console.error('Could not access all GitHub milestones');

console.error(err);

process.exit(1);

}

}

// ----------------------------------------------------------------------------

/**

* Get a list of all the current GitHub issues.

* This uses a while loop to make sure that each page of issues is received.

*/

async getAllGithubIssues() {

let allIssues = [];

let page = 1;

const perPage = 100;

while (true) {

await utils.sleep(2000);

// get a paginated list of issues

const issues = await this.githubApi.issues.listForRepo({

owner: this.githubOwner,

repo: this.githubRepo,

state: 'all',

per_page: perPage,

page: page,

});

// if this page has zero issues then we are done!

if (issues.data.length === 0) break;

// join this list of issues with the master list

allIssues = allIssues.concat(issues.data);

// if there are strictly less issues on this page than the maximum number per page

// then we can be sure that this is all the issues. No use querying again.

if (issues.data.length < perPage) break;

// query for the next page of issues next iteration

page++;

}

return allIssues;

}

// ----------------------------------------------------------------------------

/**

* Get a list of all GitHub label names currently in new repo

*/

async getAllGithubLabelNames() {

try {

await utils.sleep(2000);

// get an array of GitHub labels for the new repo

let result = await this.githubApi.issues.listLabelsForRepo({

owner: this.githubOwner,

repo: this.githubRepo,

});

// extract the label name and put into a new array

let labels = result.data.map(x => x.name);

return labels;

} catch (err) {

console.error('Could not access all GitHub label names');

console.error(err);

process.exit(1);

}

}

// ----------------------------------------------------------------------------

/**

* Get a list of all the current GitHub pull requests.

* This uses a while loop to make sure that each page of issues is received.

*/

async getAllGithubPullRequests() {

let allPullRequests = [];

let page = 1;

const perPage = 100;

while (true) {

await utils.sleep(2000);

// get a paginated list of pull requests

const pullRequests = await this.githubApi.pulls.list({

owner: this.githubOwner,

repo: this.githubRepo,

state: 'all',

per_page: perPage,

page: page,

});

// if this page has zero PRs then we are done!

if (pullRequests.data.length === 0) break;

// join this list of PRs with the master list

allPullRequests = allPullRequests.concat(pullRequests.data);

// if there are strictly less PRs on this page than the maximum number per page

// then we can be sure that this is all the PRs. No use querying again.

if (pullRequests.data.length < perPage) break;

// query for the next page of PRs next iteration

page++;

}

return allPullRequests;

}

// ----------------------------------------------------------------------------

/*

******************************************************************************

******************************** POST METHODS ********************************

******************************************************************************

*/

/**

* TODO description

*/

async createIssue(milestones, issue) {

let bodyConverted = this.convertIssuesAndComments(issue.description, issue);

let props = {

owner: this.githubOwner,

repo: this.githubRepo,

title: issue.title.trim(),

body: bodyConverted,

};

//

// Issue Assignee

//

// If the GitLab issue has an assignee, make sure to carry it over -- but only

// if the username is a valid GitHub username.

if (issue.assignee) {

props.assignees = [];

if (issue.assignee.username === settings.github.username) {

props.assignees.push(settings.github.username);

} else if (

settings.usermap &&

settings.usermap[issue.assignee.username]

) {

// get GitHub username name from settings

props.assignees.push(settings.usermap[issue.assignee.username]);

}

}

//

// Issue Milestone

//

// if the GitLab issue has an associated milestone, make sure to attach it.

if (issue.milestone) {

let milestone = milestones.find(m => m.title === issue.milestone.title);

if (milestone) {

props.milestone = milestone.number;

}

}

//

// Issue Labels

//

// make sure to add any labels that existed in GitLab

if (issue.labels) {

props.labels = issue.labels.filter(l => {

if (issue.state !== 'closed') return true;

let lower = l.toLowerCase();

// ignore any labels that should have been removed when the issue was closed

return lower !== 'doing' && lower !== 'to do';

});

}

//

// Issue Attachments

//

// if the issue contains a url that contains "/uploads/", it is likely to

// have an attachment. Therefore, add the "has attachment" label.

if (props.body && props.body.indexOf('/uploads/') > -1) {

props.labels.push('has attachment');

}

await utils.sleep(2000);

if (settings.debug) return Promise.resolve({ data: issue });

// create the GitHub issue from the GitLab issue

return this.githubApi.issues.create(props);

}

// ----------------------------------------------------------------------------

/**

* TODO description

*/

async createIssueComments(githubIssue, issue) {

console.log('\tMigrating issue comments...');

// retrieve any notes/comments associated with this issue

if (issue.isPlaceholder) {

console.log(

'\t...this is a placeholder issue, no comments are migrated.'

);

return;

}

let notes = await this.gitlabHelper.getIssueNotes(issue.iid);

// if there are no notes, then there is nothing to do!

if (notes.length === 0) {

console.log(`\t...no issue comments available, nothing to migrate.`);

return;

}

// sort notes in ascending order of when they were created (by id)

notes = notes.sort((a, b) => a.id - b.id);

let nrOfMigratedNotes = 0;

for (let note of notes) {

const gotMigrated = await this.processNote(note, githubIssue);

if (gotMigrated) {

nrOfMigratedNotes++;

}

}

console.log(

`\t...Done creating issue comments (migrated ${nrOfMigratedNotes} comments, skipped ${notes.length -

nrOfMigratedNotes} comments)`

);

}

// ----------------------------------------------------------------------------

/**

* This function checks if a note needs to be processed or if it can be skipped.

* A note can be skipped if it contains predefined terms (like 'Status changed to...')

* or if it contains any value from settings.skipMatchingComments ->

* Note that this is case insensitive!

*

*/

checkIfNoteCanBeSkipped(noteBody) {

const stateChange =

(/Status changed to .*/i.test(noteBody) &&

!/Status changed to closed by commit.*/i.test(noteBody)) ||

/changed milestone to .*/i.test(noteBody) ||

/Milestone changed to .*/i.test(noteBody) ||

/Reassigned to /i.test(noteBody) ||

/added .* labels/i.test(noteBody) ||

/Added ~.* label/i.test(noteBody) ||

/removed ~.* label/i.test(noteBody) ||

/mentioned in issue.*/i.test(noteBody);

const matchingComment = settings.skipMatchingComments.reduce(

(a, b) => a || new RegExp(b, 'i').test(noteBody),

false

);

return stateChange || matchingComment;

}

// ----------------------------------------------------------------------------

/*

* Processes the current note.

* This means, it either creates a comment in the github issue, or it gets skipped.

* Return false when it got skipped, otherwise true.

*/

async processNote(note, githubIssue) {

if (this.checkIfNoteCanBeSkipped(note.body)) {

// note will be skipped

return false;

} else {

let bodyConverted = this.convertIssuesAndComments(note.body, note);

await utils.sleep(2000);

if (settings.debug) {

return true;

}

await this.githubApi.issues

.createComment({

owner: this.githubOwner,

repo: this.githubRepo,

number: githubIssue.number,

body: bodyConverted,

})

.catch(x => {

console.error('could not create GitHub issue comment!');

console.error(x);

process.exit(1);

});

return true;

}

}

// ----------------------------------------------------------------------------

/**

* Update the issue state (i.e., closed or open).

*/

async updateIssueState(githubIssue, issue) {

// default state is open so we don't have to update if the issue is closed.

if (issue.state !== 'closed' || githubIssue.state === 'closed') return;

let props = {

owner: this.githubOwner,

repo: this.githubRepo,

number: githubIssue.number,

state: issue.state,

milestone: issue.milestone,

labels: issue.labels,

assignees: issue.assignees

};

await utils.sleep(2000);

if (settings.debug) {

return Promise.resolve();

}

// make the state update

return await this.githubApi.issues.update(props);

}

// ----------------------------------------------------------------------------

/**

* Create a GitHub milestone from a GitLab milestone

*/

async createMilestone(milestone) {

// convert from GitLab to GitHub

let githubMilestone = {

owner: this.githubOwner,

repo: this.githubRepo,

title: milestone.title,

description: milestone.description,

state: milestone.state === 'active' ? 'open' : 'closed',

};

if (milestone.due_date) {

githubMilestone.due_on = milestone.due_date + 'T00:00:00Z';

}

await utils.sleep(2000);

if (settings.debug) return Promise.resolve();

// create the GitHub milestone

return await this.githubApi.issues.createMilestone(githubMilestone);

}

// ----------------------------------------------------------------------------

/**

* Create a GitHub label from a GitLab label

*/

async createLabel(label) {

// convert from GitLab to GitHub

let githubLabel = {

owner: this.githubOwner,

repo: this.githubRepo,

name: label.name,

color: label.color.substr(1), // remove leading "#" because gitlab returns it but github wants the color without it

};

await utils.sleep(2000);

if (settings.debug) return Promise.resolve();

// create the GitHub label

return await this.githubApi.issues.createLabel(githubLabel);

}

// ----------------------------------------------------------------------------

/**

* Create a pull request, set its data, and set its comments

* @param milestones a list of the milestones that exist in the GitHub repository

* @param pullRequest the GitLab pull request that we want to migrate

* @returns {Promise<void>}

*/

async createPullRequestAndComments(milestones, pullRequest) {

let githubPullRequestData = await this.createPullRequest(pullRequest);

let githubPullRequest = githubPullRequestData.data;

// data is set to null if one of the branches does not exist and the pull request cannot be created

if (githubPullRequest) {

// Add milestones, labels, and other attributes from the Issues API

await this.updatePullRequestData(

githubPullRequest,

pullRequest,

milestones

);

// add any comments/nodes associated with this pull request

await this.createPullRequestComments(githubPullRequest, pullRequest);

// Make sure to close the GitHub pull request if it is closed or merged in GitLab

await this.updatePullRequestState(githubPullRequest, pullRequest);

}

}

// ----------------------------------------------------------------------------

/**

* Create a pull request. A pull request can only be created if both the target and source branches exist on the GitHub

* repository. In many cases, the source branch is deleted when the merge occurs, and the merge request may not be able

* to be migrated. In this case, an issue is created instead with a 'gitlab merge request' label.

* @param pullRequest the GitLab pull request object that we want to duplicate

* @returns {Promise<Promise<{data: null}>|Promise<Github.Response<Github.PullsCreateResponse>>|Promise<{data: *}>>}

*/

async createPullRequest(pullRequest) {

let canCreate = true;

// Check to see if the target branch exists in GitHub - if it does not exist, we cannot create a pull request

try {

await this.githubApi.repos.getBranch({

owner: this.githubOwner,

repo: this.githubRepo,

branch: pullRequest.target_branch,

});

} catch (err) {

let gitlabBranches = await this.gitlabHelper.getAllBranches();

if (gitlabBranches.find(m => m.name === pullRequest.target_branch)) {

// Need to move that branch over to GitHub!

console.error(

`The '${pullRequest.target_branch}' branch exists on GitLab but has not been migrated to GitHub. Please migrate the branch before migrating pull request #${pullRequest.iid}.`

);

return Promise.resolve({ data: null });

} else {

console.error(

`Merge request ${pullRequest.iid} (target branch '${pullRequest.target_branch}' does not exist => cannot migrate pull request, creating an issue instead.`

);

canCreate = false;

}

}

// Check to see if the source branch exists in GitHub - if it does not exist, we cannot create a pull request

try {

await this.githubApi.repos.getBranch({

owner: this.githubOwner,

repo: this.githubRepo,

branch: pullRequest.source_branch,

});

} catch (err) {

let gitlabBranches = await this.gitlabHelper.getAllBranches();

if (gitlabBranches.find(m => m.name === pullRequest.source_branch)) {

// Need to move that branch over to GitHub!

console.error(

`The '${pullRequest.source_branch}' branch exists on GitLab but has not been migrated to GitHub. Please migrate the branch before migrating pull request #${pullRequest.iid}.`

);

return Promise.resolve({ data: null });

} else {

console.error(

`Pull request #${pullRequest.iid} (source branch '${pullRequest.source_branch}' does not exist => cannot migrate pull request, creating an issue instead.`

);

canCreate = false;

}

}

if (settings.debug) return Promise.resolve({ data: pullRequest });

if (canCreate) {

let bodyConverted = this.convertIssuesAndComments(

pullRequest.description,

pullRequest

);

// GitHub API Documentation to create a pull request: https://developer.github.com/v3/pulls/#create-a-pull-request

let props = {

owner: this.githubOwner,

repo: this.githubRepo,

title: pullRequest.title.trim(),

body: bodyConverted,

head: pullRequest.source_branch,

base: pullRequest.target_branch,

};

await utils.sleep(2000);

// create the GitHub pull request from the GitLab issue

return this.githubApi.pulls.create(props);

} else {

// Create an issue with a descriptive title

let mergeStr =

'_Merges ' +

pullRequest.source_branch +

' -> ' +

pullRequest.target_branch +

'_\n\n';

let bodyConverted = this.convertIssuesAndComments(

mergeStr + pullRequest.description,

pullRequest

);

let props = {

owner: this.githubOwner,

repo: this.githubRepo,

title: pullRequest.title.trim() + ' - [' + pullRequest.state + ']',

body: bodyConverted,

};

// Add a label to indicate the issue is a merge request

pullRequest.labels.push('gitlab merge request');

return this.githubApi.issues.create(props);

}

}

// ----------------------------------------------------------------------------

/**

* Create comments for the pull request

* @param githubPullRequest the GitHub pull request object

* @param pullRequest the GitLab pull request object

* @returns {Promise<void>}

*/

async createPullRequestComments(githubPullRequest, pullRequest) {

console.log('\tMigrating pull request comments...');

if (!pullRequest.iid) {

console.log(

'\t...this is a placeholder for a deleted GitLab merge request, no comments are created.'

);

return Promise.resolve();

}

let notes = await this.gitlabHelper.getAllMergeRequestNotes(

pullRequest.iid

);

// if there are no notes, then there is nothing to do!

if (notes.length === 0) {

console.log(

`\t...no pull request comments available, nothing to migrate.`

);

return;

}

// Sort notes in ascending order of when they were created (by id)

notes = notes.sort((a, b) => a.id - b.id);

let nrOfMigratedNotes = 0;

for (let note of notes) {

const gotMigrated = await this.processNote(note, githubPullRequest);

if (gotMigrated) {

nrOfMigratedNotes++;

}

}

console.log(

`\t...Done creating pull request comments (migrated ${nrOfMigratedNotes} pull request comments, skipped ${notes.length -

nrOfMigratedNotes} pull request comments)`

);

}

// ----------------------------------------------------------------------------

/**

* Update the pull request data. The GitHub Pull Request API does not supply mechanisms to set the milestone, assignee,

* or labels; these data are set via the Issues API in this function

* @param githubPullRequest the GitHub pull request object

* @param pullRequest the GitLab pull request object

* @param milestones a list of Milestones that exist in the GitHub repo

* @returns {Promise<Github.Response<Github.IssuesUpdateResponse>>}

*/

async updatePullRequestData(githubPullRequest, pullRequest, milestones) {

let props = {

owner: this.githubOwner,

repo: this.githubRepo,

number: githubPullRequest.number || githubPullRequest.iid,

};

//

// Pull Request Assignee

//

// If the GitLab merge request has an assignee, make sure to carry it over --

// but only if the username is a valid GitHub username

if (pullRequest.assignee) {

props.assignees = [];

if (pullRequest.assignee.username === settings.github.username) {

props.assignees.push(settings.github.username);

} else if (

settings.usermap &&

settings.usermap[pullRequest.assignee.username]

) {

// Get GitHub username from settings

props.assignees.push(settings.usermap[pullRequest.assignee.username]);

}

}

//

// Pull Request Milestone

//

// if the GitLab merge request has an associated milestone, make sure to attach it

if (pullRequest.milestone) {

let milestone = milestones.find(

m => m.title === pullRequest.milestone.title

);

if (milestone) {

props.milestone = milestone.number;

}

}

//

// Merge Request Labels

//

// make sure to add any labels that existed in GitLab

if (pullRequest.labels) {

props.labels = pullRequest.labels.filter(l => {

if (pullRequest.state !== 'closed') return true;

let lower = l.toLowerCase();

// ignore any labels that should have been removed when the issue was closed

return lower !== 'doing' && lower !== 'to do';

});

}

return await this.githubApi.issues.update(props);

}

// ----------------------------------------------------------------------------

/**

* Update the pull request state

* @param githubPullRequest GitHub pull request object

* @param pullRequest GitLab pull request object

* @returns {Promise<Promise<Github.AnyResponse>|Github.Response<Github.PullsUpdateResponse>|Promise<void>>}

*/

async updatePullRequestState(githubPullRequest, pullRequest) {

if (

pullRequest.state === 'merged' &&

githubPullRequest.state !== 'closed' &&

!settings.debug

) {

// Merging the pull request adds new commits to the tree; to avoid that, just close the merge requests

pullRequest.state = 'closed';

}

// Default state is open so we don't have to update if the request is closed

if (pullRequest.state !== 'closed' || githubPullRequest.state === 'closed')

return;

let props = {

owner: this.githubOwner,

repo: this.githubRepo,

number: githubPullRequest.number,

state: pullRequest.state,

};

await utils.sleep(2000);

if (settings.debug) {

return Promise.resolve();

}

// Use the Issues API; all pull requests are issues, and we're not modifying any pull request-sepecific fields. This

// then works for merge requests that cannot be created and are migrated as issues.

return await this.githubApi.issues.update(props);

}

// ----------------------------------------------------------------------------

/**

* TODO description

*/

async createIssueAndComments(milestones, issue) {

// create the issue in GitHub

const githubIssueData = await this.createIssue(milestones, issue);

const githubIssue = githubIssueData.data;

// add any comments/notes associated with this issue

await this.createIssueComments(githubIssue, issue);

// make sure to close the GitHub issue if it is closed in GitLab

await this.updateIssueState(githubIssue, issue);

}

// ----------------------------------------------------------------------------

// TODO fix unexpected type coercion risk

/**

* Converts issue body and issue comments from GitLab to GitHub. That means:

* - Add a line at the beginning indicating which original user created the

* issue or the comment and when - because the GitHub API creates everything

* as the API user

* - Change username from GitLab to GitHub in "mentions" (@username)

*/

convertIssuesAndComments(str, item) {

if (

(!settings.usermap || Object.keys(settings.usermap).length === 0) &&

(!settings.projectmap || Object.keys(settings.projectmap).length === 0)

) {

return GithubHelper.addMigrationLine(str, item);

} else {

// - Replace userids as defined in settings.usermap.

// They all start with '@' in the issues but we have them without in usermap

// - Replace cross-project issue references. They are matched on org/project# so 'matched' ends with '#'

// They all have a '#' right after the project name in the issues but we have them without in projectmap

let strWithMigLine = GithubHelper.addMigrationLine(str, item);

strWithMigLine = strWithMigLine.replace(

this.userProjectRegex,

matched => {

if (matched.startsWith('@')) {

// this is a userid

return '@' + settings.usermap[matched.substr(1)];

} else if (matched.endsWith('#')) {

// this is a cross-project issue reference

return (

settings.projectmap[matched.substring(0, matched.length - 1)] +

'#'

);

} else {

// something went wrong, do nothing

return matched;

}

}

);

return strWithMigLine;

}

}

// ----------------------------------------------------------------------------

/**

* Adds a line of text at the beginning of a comment that indicates who, when

* and from GitLab.

*/

static addMigrationLine(str, item) {

if (!item || !item.author || !item.author.username || !item.created_at) {

return str;

}

const dateformatOptions = {

month: 'short',

day: 'numeric',

year: 'numeric',

hour: 'numeric',

minute: 'numeric',

hour12: false,

};

const formattedDate = new Date(item.created_at).toLocaleString(

'en-US',

dateformatOptions

);

return `In GitLab by @${item.author.username} on ${formattedDate}\n\n${str}`;

}

}