public async Task OnToInputBlur()
{
if (string.IsNullOrEmpty(ToValue))
{
ToProgressBarText = "";
ToProgressBarStyle = ProgressBarStyle.None;
DestinationRepoMoveData = null;
return;
}
ToProgressBarText = "Looking for repo...";
ToProgressBarStyle = ProgressBarStyle.InProgress;
NotifyStateChanged();
var val = ToValue;
// If pattern is not in required format 'owner/repo', try to normalize
if (!IsValidRepoFormat(val))
{
ToValue = NormalizeRepoFormat(val);
}
val = ToValue;
// If pattern is STILL not in required format 'owner/repo', abort
if (!IsValidRepoFormat(val))
{
// TODO: Set validation error somehow?
ToProgressBarText = "Invalid repo format";
ToProgressBarStyle = ProgressBarStyle.Error;
return;
}
var shortNameParts = val.Split('/');
var toOwner = shortNameParts[0];
var toRepo = shortNameParts[1];
ToRepoQueryInProgress = true;
NotifyStateChanged();
IErrorResult getRepoDataError = null;
try
{
DestinationRepoMoveData = await IssueMoverService.GetRepoData(toOwner, toRepo);
if (DestinationRepoMoveData.HasErrors())
{
getRepoDataError = DestinationRepoMoveData;
}
}
catch (Exception ex)
{
getRepoDataError = new ErrorResult
{
ExceptionMessage = ex.Message,
ExceptionStackTrace = ex.StackTrace,
};
}
if (getRepoDataError != null)
{
DestinationRepoMoveData = null;
AddJsonLog(new ErrorLogEntry
{
Description = "Error calling 'getrepodata'",
ErrorResult = getRepoDataError,
});
ToRepoQueryInProgress = false;
ToProgressBarText = $"Error!";
ToProgressBarStyle = ProgressBarStyle.Error;
return;
}
AddJsonLog(DestinationRepoMoveData);
ToRepoQueryInProgress = false;
ToProgressBarText = $"Found repo, {DestinationRepoMoveData.OpenIssueCount} open issue(s)";
ToProgressBarStyle = ProgressBarStyle.Success;
}
public async Task OnMoveButtonClick()
{
IssueMoveStates = new List <IssueMoveState>();
try
{
MoveInProgress = true;
// Check From/To are valid
// TODO: Is this needed? Would we be here if it wasn't valid?
// Create destination labels
if (ShouldCreateDestinationLabels)
{
var createLabelState = new IssueMoveState {
Description = "Creating labels"
};
IssueMoveStates.Add(createLabelState);
NotifyStateChanged();
if (OriginalIssueMoveData.Labels.Any())
{
IErrorResult labelCreateResultError = null;
try
{
var labelCreateResult = await IssueMoverService.CreateLabels(DestinationRepoMoveData.Owner, DestinationRepoMoveData.Repo, new LabelCreateRequest { Labels = OriginalIssueMoveData.Labels, });
if (labelCreateResult.HasErrors())
{
labelCreateResultError = labelCreateResult;
}
AddJsonLog(labelCreateResult);
}
catch (Exception ex)
{
labelCreateResultError = new ErrorResult
{
ExceptionMessage = ex.Message,
ExceptionStackTrace = ex.StackTrace,
};
}
if (labelCreateResultError != null)
{
AddJsonLog(new ErrorLogEntry
{
Description = "Error calling 'createlabels'",
ErrorResult = labelCreateResultError,
});
createLabelState.Result = "Error! (skipping)";
createLabelState.Success = false;
NotifyStateChanged();
// No need to abort if this failed because it's optional, so continue to next step
}
else
{
createLabelState.Result = "Done!";
createLabelState.Success = true;
NotifyStateChanged();
}
}
else
{
createLabelState.Result = "Skipped (no labels on issue)";
createLabelState.Success = true;
NotifyStateChanged();
}
}
// Create destination milestone
if (ShouldCreateDestinationMilestone)
{
var createMilestoneState = new IssueMoveState {
Description = "Creating milestone"
};
IssueMoveStates.Add(createMilestoneState);
NotifyStateChanged();
if (!string.IsNullOrEmpty(OriginalIssueMoveData.Milestone))
{
IErrorResult milestoneCreateResultError = null;
try
{
var milestoneCreateResult = await IssueMoverService.CreateMilestone(DestinationRepoMoveData.Owner, DestinationRepoMoveData.Repo, new MilestoneCreateRequest { Milestone = OriginalIssueMoveData.Milestone, });
if (milestoneCreateResult.HasErrors())
{
milestoneCreateResultError = milestoneCreateResult;
}
AddJsonLog(milestoneCreateResult);
}
catch (Exception ex)
{
milestoneCreateResultError = new ErrorResult
{
ExceptionMessage = ex.Message,
ExceptionStackTrace = ex.StackTrace,
};
}
if (milestoneCreateResultError != null)
{
AddJsonLog(new ErrorLogEntry
{
Description = "Error calling 'createmilestone'",
ErrorResult = milestoneCreateResultError,
});
createMilestoneState.Result = "Error! (skipping)";
createMilestoneState.Success = false;
NotifyStateChanged();
// No need to abort if this failed because it's optional, so continue to next step
}
else
{
createMilestoneState.Result = "Done!";
createMilestoneState.Success = true;
NotifyStateChanged();
}
}
else
{
createMilestoneState.Result = "Skipped (no milestone on issue)";
createMilestoneState.Success = true;
NotifyStateChanged();
}
}
// Create destination issue
var moveIssueState = new IssueMoveState {
Description = "Moving issue"
};
IssueMoveStates.Add(moveIssueState);
NotifyStateChanged();
var destinationIssueNumber = -1;
var destinationIssueHtmlUrl = string.Empty;
IErrorResult issueMoveResultError = null;
try
{
var issueMoveResult = await IssueMoverService.MoveIssue(DestinationRepoMoveData.Owner, DestinationRepoMoveData.Repo,
new IssueMoveRequest
{
Title = OriginalIssueMoveData.Title,
Body = GetDestinationBody(OriginalIssueMoveData),
Assignees = OriginalIssueMoveData.Assignees,
Milestone = ShouldCreateDestinationMilestone ? OriginalIssueMoveData.Milestone : null,
Labels = ShouldCreateDestinationLabels ? OriginalIssueMoveData.Labels.Select(l => l.Text).ToArray() : null,
});
if (issueMoveResult.HasErrors())
{
issueMoveResultError = issueMoveResult;
}
AddJsonLog(issueMoveResult);
destinationIssueNumber = issueMoveResult.IssueNumber;
destinationIssueHtmlUrl = issueMoveResult.HtmlUrl;
}
catch (Exception ex)
{
issueMoveResultError = new ErrorResult
{
ExceptionMessage = ex.Message,
ExceptionStackTrace = ex.StackTrace,
};
}
if (issueMoveResultError != null)
{
AddJsonLog(new ErrorLogEntry
{
Description = "Error calling 'moveissue'",
ErrorResult = issueMoveResultError,
});
moveIssueState.Result = "Error!";
moveIssueState.Success = false;
IssueMoveStates.Add(new IssueMoveState
{
StateType = IssueMoveStateType.FatalError,
ErrorResult = issueMoveResultError,
Description = "Fatal error",
});
return;
}
moveIssueState.Result = "Done!";
moveIssueState.Success = true;
// Create destination comments
var moveCommentState = new IssueMoveState {
Description = "Moving comments"
};
IssueMoveStates.Add(moveCommentState);
NotifyStateChanged();
if (OriginalIssueMoveData.Comments.Any())
{
for (var i = 0; i < OriginalIssueMoveData.Comments.Count; i++)
{
var commentData = OriginalIssueMoveData.Comments[i];
IErrorResult commentMoveResultError = null;
try
{
var commentMoveResult = await IssueMoverService.MoveComment(DestinationRepoMoveData.Owner, DestinationRepoMoveData.Repo,
new CommentMoveRequest
{
IssueNumber = destinationIssueNumber,
Text = GetDestinationComment(OriginalIssueMoveData, commentData.Author, commentData.Text, commentData.Date),
});
if (commentMoveResult.HasErrors())
{
commentMoveResultError = commentMoveResult;
}
moveCommentState.Description = $"Moving comment {i + 1}/{OriginalIssueMoveData.Comments.Count}";
AddJsonLog(commentMoveResult);
}
catch (Exception ex)
{
commentMoveResultError = new ErrorResult
{
ExceptionMessage = ex.Message,
ExceptionStackTrace = ex.StackTrace,
};
}
if (commentMoveResultError != null)
{
AddJsonLog(new ErrorLogEntry
{
Description = $"Error calling 'movecomment' for comment #{i + 1}",
ErrorResult = commentMoveResultError,
});
moveCommentState.Result = "Error!";
moveCommentState.Success = false;
IssueMoveStates.Add(new IssueMoveState
{
StateType = IssueMoveStateType.FatalError,
ErrorResult = commentMoveResultError,
Description = "Fatal error",
});
return;
}
NotifyStateChanged();
}
moveCommentState.Result = "Done!";
moveCommentState.Success = true;
}
else
{
moveCommentState.Result = "Skipped (no comments)";
moveCommentState.Success = true;
NotifyStateChanged();
}
// Add old issue close message
var addCloseCommentState = new IssueMoveState {
Description = "Adding comment to original issue"
};
IssueMoveStates.Add(addCloseCommentState);
NotifyStateChanged();
IErrorResult closeCommentResultError = null;
try
{
var issueCloseCommentResult = await IssueMoverService.CloseIssueComment(OriginalIssueMoveData.RepoOwner, OriginalIssueMoveData.RepoName,
new IssueCloseCommentRequest
{
IssueNumber = OriginalIssueMoveData.Number,
Comment = $"This issue was moved to {DestinationRepoMoveData.Owner}/{DestinationRepoMoveData.Repo}#{destinationIssueNumber}",
});
if (issueCloseCommentResult.HasErrors())
{
closeCommentResultError = issueCloseCommentResult;
}
AddJsonLog(issueCloseCommentResult);
}
catch (Exception ex)
{
closeCommentResultError = new ErrorResult
{
ExceptionMessage = ex.Message,
ExceptionStackTrace = ex.StackTrace,
};
}
if (closeCommentResultError != null)
{
AddJsonLog(new ErrorLogEntry
{
Description = $"Error calling 'closeissuecomment'",
ErrorResult = closeCommentResultError,
});
addCloseCommentState.Result = "Error!";
addCloseCommentState.Success = false;
IssueMoveStates.Add(new IssueMoveState
{
StateType = IssueMoveStateType.FatalError,
ErrorResult = closeCommentResultError,
Description = "Fatal error",
});
return;
}
addCloseCommentState.Result = "Done!";
addCloseCommentState.Success = true;
// Lock old issue
if (ShouldLockOriginalIssue)
{
var lockIssueState = new IssueMoveState {
Description = "Locking original issue"
};
IssueMoveStates.Add(lockIssueState);
NotifyStateChanged();
IErrorResult lockIssueResultError = null;
try
{
var issueLockResult = await IssueMoverService.LockIssue(OriginalIssueMoveData.RepoOwner, OriginalIssueMoveData.RepoName,
new IssueLockRequest
{
IssueNumber = OriginalIssueMoveData.Number,
});
if (issueLockResult.HasErrors())
{
lockIssueResultError = issueLockResult;
}
AddJsonLog(issueLockResult);
}
catch (Exception ex)
{
lockIssueResultError = new ErrorResult
{
ExceptionMessage = ex.Message,
ExceptionStackTrace = ex.StackTrace,
};
}
if (lockIssueResultError != null)
{
AddJsonLog(new ErrorLogEntry
{
Description = $"Error calling 'lockissue'",
ErrorResult = lockIssueResultError,
});
lockIssueState.Result = "Error! (skipping)";
lockIssueState.Success = false;
NotifyStateChanged();
// No need to abort if this failed because it's optional, so continue to next step
}
else
{
lockIssueState.Result = "Done!";
lockIssueState.Success = true;
NotifyStateChanged();
}
}
// Close old issue
var closeIssueState = new IssueMoveState {
Description = "Closing original issue"
};
IssueMoveStates.Add(closeIssueState);
NotifyStateChanged();
IErrorResult closeIssueResultError = null;
try
{
var issueCloseResult = await IssueMoverService.CloseIssue(OriginalIssueMoveData.RepoOwner, OriginalIssueMoveData.RepoName,
new IssueCloseRequest
{
IssueNumber = OriginalIssueMoveData.Number,
});
if (issueCloseResult.HasErrors())
{
closeIssueResultError = issueCloseResult;
}
AddJsonLog(issueCloseResult);
}
catch (Exception ex)
{
closeIssueResultError = new ErrorResult
{
ExceptionMessage = ex.Message,
ExceptionStackTrace = ex.StackTrace,
};
}
if (closeIssueResultError != null)
{
AddJsonLog(new ErrorLogEntry
{
Description = $"Error calling 'closeissue'",
ErrorResult = closeIssueResultError,
});
closeIssueState.Result = "Error!";
closeIssueState.Success = false;
IssueMoveStates.Add(new IssueMoveState
{
StateType = IssueMoveStateType.FatalError,
ErrorResult = closeIssueResultError,
Description = "Fatal error",
});
return;
}
closeIssueState.Result = "Done!";
closeIssueState.Success = true;
NotifyStateChanged();
IssueMoveStates.Add(new IssueMoveState
{
StateType = IssueMoveStateType.LinkResult,
Description = $"Moved to new issue #{destinationIssueNumber}",
Link = destinationIssueHtmlUrl,
});
// Reset states
MoveInProgress = false;
}
catch (Exception ex)
{
var overallErrorResult = new ErrorResult
{
ExceptionMessage = ex.Message,
ExceptionStackTrace = ex.StackTrace,
};
AddJsonLog(new ErrorLogEntry
{
Description = "Unknown error during move operation",
ErrorResult = overallErrorResult,
});
var outerState = new IssueMoveState {
Description = "Error"
};
outerState.Result = "Unknown error during move operation";
outerState.Success = false;
IssueMoveStates.Add(outerState);
IssueMoveStates.Add(new IssueMoveState
{
StateType = IssueMoveStateType.FatalError,
ErrorResult = overallErrorResult,
Description = "Fatal error",
});
}
}
public async Task OnFromInputBlur()
{
if (string.IsNullOrEmpty(FromValue))
{
FromProgressBarText = "";
FromProgressBarStyle = ProgressBarStyle.None;
OriginalIssueMoveData = null;
return;
}
FromProgressBarText = "Looking for issue...";
FromProgressBarStyle = ProgressBarStyle.InProgress;
NotifyStateChanged();
var val = FromValue;
// If pattern is not in required format 'owner/repo#123', try to normalize
if (!IsValidIssueFormat(val))
{
FromValue = NormalizeIssueFormat(val);
}
val = FromValue;
// If pattern is STILL not in required format 'owner/repo#123', abort
if (!IsValidIssueFormat(val))
{
// TODO: Set validation error somehow?
FromProgressBarText = "Invalid issue format";
FromProgressBarStyle = ProgressBarStyle.Error;
return;
}
var shortNameParts = val.Split('/', '#');
var fromOwner = shortNameParts[0];
var fromRepo = shortNameParts[1];
var fromIssueNumber = int.Parse(shortNameParts[2], CultureInfo.InvariantCulture);
IssueQueryInProgress = true;
NotifyStateChanged();
IErrorResult getMoveDataError = null;
try
{
OriginalIssueMoveData = await IssueMoverService.GetIssueMoveData(fromOwner, fromRepo, fromIssueNumber);
if (OriginalIssueMoveData.HasErrors())
{
getMoveDataError = OriginalIssueMoveData;
}
}
catch (Exception ex)
{
getMoveDataError = new ErrorResult
{
ExceptionMessage = ex.Message,
ExceptionStackTrace = ex.StackTrace,
};
}
if (getMoveDataError != null)
{
OriginalIssueMoveData = null;
AddJsonLog(new ErrorLogEntry
{
Description = "Error calling 'getmovedata'",
ErrorResult = getMoveDataError,
});
IssueQueryInProgress = false;
FromProgressBarText = $"Error!";
FromProgressBarStyle = ProgressBarStyle.Error;
return;
}
AddJsonLog(OriginalIssueMoveData);
IssueQueryInProgress = false;
if (OriginalIssueMoveData.IsPullRequest)
{
FromProgressBarText = $"Found #{OriginalIssueMoveData.Number}, but it's a pull request";
FromProgressBarStyle = ProgressBarStyle.Error;
}
else if (OriginalIssueMoveData.State == IssueState.Closed)
{
FromProgressBarText = $"Found #{OriginalIssueMoveData.Number}, but it's closed";
FromProgressBarStyle = ProgressBarStyle.Error;
}
else
{
FromProgressBarText = $"Found issue #{OriginalIssueMoveData.Number}";
FromProgressBarStyle = ProgressBarStyle.Success;
}
}
