private static void runAction(Control owner, JiraNamedEntity action, JiraIssueListModel model,
JiraIssue issue, List <JiraField> fields, StatusLabel status, Action onFinish)
{
JiraIssue issueWithTime = SmartJiraServerFacade.Instance.getIssue(issue.Server, issue.Key);
issueWithTime.SecurityLevel = SmartJiraServerFacade.Instance.getSecurityLevel(issue);
object rawIssueObject = SmartJiraServerFacade.Instance.getRawIssueObject(issue);
List <JiraField> fieldsWithValues = JiraActionFieldType.fillFieldValues(issue, rawIssueObject, fields);
// PLVS-133 - this should never happen but does?
if (model == null)
{
owner.Invoke(new MethodInvoker(()
=>
PlvsUtils.showError("Issue List Model was null, please report this as a bug",
new Exception("IssueActionRunner.runAction()"))));
model = JiraIssueListModelImpl.Instance;
}
if (fieldsWithValues == null || fieldsWithValues.Count == 0)
{
runActionWithoutFields(owner, action, model, issue, status, onFinish);
}
else
{
owner.Invoke(new MethodInvoker(() =>
new IssueWorkflowAction(issue, action, model, fieldsWithValues, status, onFinish).initAndShowDialog()));
}
}
public string GetWorkItemDescription(string linkData, string releaseNotePrefix, string releaseNote)
{
var store = Substitute.For <IJiraConfigurationStore>();
var jiraClient = Substitute.For <IJiraRestClient>();
var jiraClientLazy = new Lazy <IJiraRestClient>(() => jiraClient);
var jiraIssue = new JiraIssue
{
Key = linkData,
Fields = new JiraIssueFields
{
Summary = "Test title",
Comments = new JiraIssueComments
{
Total = 1,
Comments = new[]
{
new JiraIssueComment
{
Body = releaseNote
}
}
}
}
};
jiraClient.GetIssues(Arg.Any <string[]>()).Returns(ResultFromExtension <JiraIssue[]> .Success(new[] { jiraIssue }));
return(new WorkItemLinkMapper(store, new CommentParser(), jiraClientLazy, Substitute.For <ISystemLog>()).GetReleaseNote(jiraIssue, releaseNotePrefix));
}
public void ShouldGetDoneDateForInProgressDateWithNoInProgressStateMaps()
{
var jiraStates = new List <JiraState>()
{
new JiraState(new DateTime(2020, 10, 7), "TO_DO", "DOING"),
new JiraState(new DateTime(2020, 10, 8), "DOING", "VALIDATING"),
new JiraState(new DateTime(2020, 10, 9), "VALIDATING", "DONE")
};
var partialWorkflowMap = new List <WorkflowMap>()
{
new WorkflowMap(new string[] { "TO_DO" }, "STUFF TO DO", StateType.ToDo, "TEST_TYPE", 1),
new WorkflowMap(new string[] { "DONE" }, "FINISHED", StateType.Done, "TEST_TYPE", 4)
};
var testIssue = new JiraIssue("TEST_KEY", "DESCRIPTION")
{
JiraStates = jiraStates,
Type = "TEST_TYPE",
Status = "DONE"
};
var target = IssueTimeInStateMapper.GetInProgressDate(testIssue, partialWorkflowMap);
Assert.AreEqual(new DateTime(2020, 10, 9), target);
}
private WorkItemStatus GetWorkItemStatus(JiraIssue jiraIssue, IEnumerable <GitHubPullRequest> pullRequests)
{
WorkItemStatus status = jiraIssue.WorkItemStatus;
if (pullRequests.Count() > 0)
{
status |= WorkItemStatus.PullRequestCreated;
if (pullRequests.Any(p => p.HasBeenReviewed))
{
status |= WorkItemStatus.PullRequestReviewed;
}
if (pullRequests.Any(p => p.HasRequestedChanges))
{
status |= WorkItemStatus.PullRequestChangesRequested;
}
if (pullRequests.Any(p => p.IsApproved))
{
status |= WorkItemStatus.PullRequestApproved;
}
if (pullRequests.Any(p => p.IsReadyForQA))
{
status |= WorkItemStatus.ReadyForQA;
}
}
return(status);
}
public void ShouldHaveOnlyOneResultForEachState()
{
var jiraStates = new List <JiraState>()
{
new JiraState(new DateTime(2020, 10, 7), "", "TO_DO"),
new JiraState(new DateTime(2020, 10, 7), "TO_DO", "DOING"),
new JiraState(new DateTime(2020, 10, 8), "DOING", "VALIDATING"),
new JiraState(new DateTime(2020, 10, 9), "VALIDATING", "DOING"),
new JiraState(new DateTime(2020, 10, 10), "DOING", "VALIDATING"),
new JiraState(new DateTime(2020, 10, 11), "VALIDATING", "DONE"),
new JiraState(new DateTime(2020, 10, 11), "DONE", "TO_DO"),
new JiraState(new DateTime(2020, 10, 11), "TO_DO", "DONE")
};
var testIssue = new JiraIssue("TEST_KEY", "DESCRIPTION")
{
JiraStates = jiraStates,
Type = "TEST_TYPE"
};
var target = IssueTimeInStateMapper.GetTimeInStates(testIssue, _mockWorkflowMap);
Assert.AreEqual(_mockWorkflowMap.Count, target.Count);
_mockWorkflowMap.ForEach(map =>
{
Assert.AreEqual(1, target.Where(state => state.StateName.Equals(map.MappedState)).Count());
});
}
public void ShouldFindEarliestInProgressStateAfterLastToDoState()
{
var jiraStates = new List <JiraState>()
{
new JiraState(new DateTime(2020, 10, 7), "TO_DO", "DOING"),
new JiraState(new DateTime(2020, 10, 8), "DOING", "VALIDATING"),
new JiraState(new DateTime(2020, 10, 9), "VALIDATING", "TO_DO"),
new JiraState(new DateTime(2020, 10, 10), "TO_DO", "DOING"),
new JiraState(new DateTime(2020, 10, 11), "DOING", "VALIDATING"),
new JiraState(new DateTime(2020, 10, 12), "VALIDATING", "DONE")
};
var testIssue = new JiraIssue("TEST_KEY", "DESCRIPTION")
{
JiraStates = jiraStates,
Type = "TEST_TYPE"
};
var target = IssueTimeInStateMapper.GetTimeInStates(testIssue, _mockWorkflowMap);
Assert.IsTrue(target.Any(state => state.StateName.Equals("DOING STUFF") && state.Date.Equals(new DateTime(2020, 10, 10))));
Assert.IsFalse(target.Any(state => state.StateName.Equals("DOING STUFF") && state.Date.Equals(new DateTime(2020, 10, 7))));
Assert.IsTrue(target.Any(state => state.StateName.Equals("TESTING STUFF") && state.Date.Equals(new DateTime(2020, 10, 11))));
Assert.IsFalse(target.Any(state => state.StateName.Equals("TESTING STUFF") && state.Date.Equals(new DateTime(2020, 10, 8))));
}
public void DuplicatesGetIgnored()
{
var store = Substitute.For <IJiraConfigurationStore>();
var jiraClient = Substitute.For <IJiraRestClient>();
var jiraClientLazy = new Lazy <IJiraRestClient>(() => jiraClient);
store.GetBaseUrl().Returns("https://github.com");
store.GetIsEnabled().Returns(true);
store.GetJiraUsername().Returns("user");
store.GetJiraPassword().Returns("password".ToSensitiveString());
var jiraIssue = new JiraIssue
{
Key = "JRE-1234",
Fields = new JiraIssueFields
{
Comments = new JiraIssueComments()
}
};
jiraClient.GetIssues(Arg.Any <string[]>()).Returns(ResultFromExtension <JiraIssue[]> .Success(new[] { jiraIssue }));
var mapper = new WorkItemLinkMapper(store, new CommentParser(), jiraClientLazy, Substitute.For <ISystemLog>());
var workItems = mapper.Map(
new OctopusBuildInformation
{
Commits = new[]
public List <JiraField> getFieldsForAction(JiraIssue issue, int id)
{
#if PLVS_133_WORKAROUND
object[] fields = service.getFieldsForAction(Token, issue.Key, id.ToString());
if (fields == null)
{
return(new List <JiraField>());
}
return((from field in fields
where field != null
let fieldId = field.GetType().GetProperty("id")
let name = field.GetType().GetProperty("name")
select new JiraField((string)fieldId.GetValue(field, null), (string)name.GetValue(field, null)))
.ToList());
#else
RemoteField[] fields = service.getFieldsForAction(Token, issue.Key, id.ToString());
if (fields == null)
{
return(new List <JiraField>());
}
return((from field in fields
where field != null
select new JiraField(field.id, field.name)).ToList());
#endif
}
public IssueUpdatedMessage(JiraIssue issue, IEnumerable<RawChangelogItem> changes, DateTime occurred, RawUserInfo author)
{
Issue = issue;
Changes = changes;
Occurred = occurred;
Author = author;
}
public static JiraIssue ToJiraIssue(this SdpApi sdpIncident, string projectKey, string sdpBaseUrl, JiraIssueType issueType)
{
var jiraIssue = new JiraIssue();
jiraIssue.Fields = new Fields()
{
Project = new Project()
{
Key = projectKey
},
Description =
sdpIncident.Response.Operation.Details.Parameters.First(p => p.Name == SdpParaNames.ShortDescription)
.Value,
IssueType = new IssueType()
{
Name = issueType.ToString()
},
Summary =
sdpIncident.Response.Operation.Details.Parameters.First(p => p.Name == SdpParaNames.Subject)
.Value
};
var incidentId =
sdpIncident.Response.Operation.Details.Parameters.First(p => p.Name == SdpParaNames.WorkOrderId)
.Value;
jiraIssue.Fields.Description = jiraIssue.Fields.Description + Environment.NewLine + Environment.NewLine;
jiraIssue.Fields.Description = jiraIssue.Fields.Description + "Click below link to view in SDP" + Environment.NewLine;
jiraIssue.Fields.Description = jiraIssue.Fields.Description + string.Format(sdpBaseUrl, incidentId);
return(jiraIssue);
}
private void loadPastActiveIssuesDetailsWorker(int gen, IEnumerable <ActiveIssue> past)
{
List <JiraIssue> issues = (from pastIssue in past
let server = JiraServerModel.Instance.getServer(new Guid(pastIssue.ServerGuid))
where server != null && server.Enabled
select getIssueFromModelOrServer(server, pastIssue.Key)
into issue where issue != null select issue).ToList();
container.safeInvoke(new MethodInvoker(() => {
if (gen != generation)
{
return;
}
foreach (JiraIssue issue in issues)
{
JiraIssue issueCopy = issue;
foreach (PastActiveIssueMenuItem it in
activeIssueDropDown.DropDown.Items.Cast
<PastActiveIssueMenuItem>().Where(
it =>
it.Issue.Key.Equals(issueCopy.Key) &&
it.Issue.ServerGuid.Equals(issueCopy.Server.GUID.ToString())))
{
it.Text = getShortIssueSummary(issue);
ImageCache.ImageInfo imageInfo = ImageCache.Instance.getImage(issue.Server, issue.IssueTypeIconUrl);
it.Image = imageInfo != null ? imageInfo.Img : null;
}
}
}));
}
public override string getRenderedContent(JiraIssue issue, string markup)
{
using (var rest = new RestClient(issue.Server)) {
return(rest.getRenderedContent(issue.Key, -1, -1, markup));
// return setSessionCookieAndWrapExceptions(issue.Server, rest, () => rest.getRenderedContent(issue.Key, -1, -1, markup));
}
}
private void addComment(JiraIssue issue)
{
SmartJiraServerFacade facade = SmartJiraServerFacade.Instance;
NewIssueComment dlg = new NewIssueComment(issue, facade);
dlg.ShowDialog();
if (dlg.DialogResult != DialogResult.OK)
{
return;
}
Thread addCommentThread =
PlvsUtils.createThread(delegate {
try {
jiraStatus.setInfo("Adding comment to issue...");
facade.addComment(issue, dlg.CommentBody);
issue = facade.getIssue(issue.Server, issue.Key);
jiraStatus.setInfo("Comment added");
UsageCollector.Instance.bumpJiraIssuesOpen();
container.safeInvoke(new MethodInvoker(() => JiraIssueListModelImpl.Instance.updateIssue(issue)));
} catch (Exception ex) {
jiraStatus.setError("Adding comment failed", ex);
}
});
addCommentThread.Start();
}
private void ChangeIssueStatusInternal(JiraIssue issue, string toStatus)
{
this.log.LogDebug($"Changing {issue.Id} to {toStatus} status...");
// get available actions for the issue (e.g. "Resolve issue" or "Close issue")
var availableActions = this.Service.getAvailableActions(this.Token, issue.Id);
// build a list of permitted action names and grab the id of the action that contains the newStatus (i.e. "Resolve issue" contains all but the last char in "Resolved")
var permittedActions = new List <string>();
string actionId = null;
string newStatusPart = toStatus.Substring(0, toStatus.Length - 1);
foreach (var action in availableActions)
{
permittedActions.Add(action.name);
if (action.name.Contains(newStatusPart))
{
actionId = action.id;
}
}
if (actionId == null)
{
this.log.LogError($"Changing the status to {toStatus} is not permitted in the current workflow. The only permitted statuses are: {string.Join(", ", availableActions.Select(a => a.name))}");
}
else
{
this.Service.progressWorkflowAction(
this.Token,
issue.Id,
actionId,
new RemoteFieldValue[0]
);
}
}
private void logWorkWorker(Action action, Action finished, bool closeDialogOnFinish)
{
try {
status.setInfo("Logging work for issue " + issue.Key + "...");
action();
status.setInfo("Logged work for issue " + issue.Key);
UsageCollector.Instance.bumpJiraIssuesOpen();
JiraIssue updatedIssue = facade.getIssue(issue.Server, issue.Key);
parent.safeInvoke(new MethodInvoker(() => {
model.updateIssue(updatedIssue);
if (activeIssueManager.isActive(issue))
{
activeIssueManager.resetTimeSpent();
}
}));
} catch (Exception e) {
status.setError("Failed to log work for issue " + issue.Key, e);
}
parent.safeInvoke(new MethodInvoker(() => {
if (closeDialogOnFinish)
{
Close();
}
if (finished != null)
{
finished();
}
}));
}
private void notifyListenersOfIssueChange(JiraIssue issue)
{
foreach (var l in listeners)
{
l.issueChanged(issue);
}
}
private void notifyListenersOfIssueChange(JiraIssue issue)
{
if (IssueChanged != null)
{
IssueChanged(this, new IssueChangedEventArgs(issue));
}
}
public void updateIssue(JiraIssue issue)
{
bool found = false;
bool differs = false;
lock (issues) {
foreach (var i in Issues)
{
if (!i.Id.Equals(issue.Id))
{
continue;
}
if (!i.Server.GUID.Equals(issue.Server.GUID))
{
continue;
}
found = true;
if (!i.Equals(issue))
{
issues[issue.Server.GUID + issue.Key] = issue;
differs = true;
}
break;
}
}
// issue might not be in the model, but somebody still modified it.
// Let's tell other parties that just might be interested in that
if (!found || differs)
{
notifyListenersOfIssueChange(issue);
}
}
private Story ToStory(JiraIssue source)
{
return(new Story
{
Id = source.Key
});
}
private static void addTimeFields(JiraIssue issue, bool useRestApi, ICollection <JiraField> result)
{
if (useRestApi)
{
return;
}
var originalEstimate = issue.OriginalEstimateInSeconds;
var remainingEstimate = issue.RemainingEstimateInSeconds;
var timeSpent = issue.TimeSpentInSeconds;
if (originalEstimate != 0)
{
var originalEstimateField = new JiraField(TIMEORIGINALESTIMATE, "Original Estimate");
originalEstimateField.Values.Add(originalEstimate.ToString());
result.Add(originalEstimateField);
}
if (remainingEstimate != 0)
{
var remainingEstimateField = new JiraField(TIMEESTIMATE, "Remaining Estimate");
remainingEstimateField.Values.Add(remainingEstimate.ToString());
result.Add(remainingEstimateField);
}
if (timeSpent != 0)
{
var timeSpentField = new JiraField(TIMESPENT, "Time Spent");
timeSpentField.Values.Add(timeSpent.ToString());
result.Add(timeSpentField);
}
}
private static JiraField fillField(JiraIssue issue, object rawIssueObject, JiraField field)
{
JiraField result = new JiraField(field);
if (TypeMap.ContainsKey(field.Id))
{
WidgetTypeAndFieldFiller widgetTypeAndFieldFiller = TypeMap[field.Id];
result.Values = widgetTypeAndFieldFiller.Filler.getFieldValues(field.Id, issue, rawIssueObject);
result.SettablePropertyName = widgetTypeAndFieldFiller.Filler.getSettablePropertyName(field.Id, issue, rawIssueObject);
}
else
{
try {
result.Values = CustomFieldFiller.getFieldValues(field.Id, issue, rawIssueObject);
result.SettablePropertyName = CustomFieldFiller.getSettablePropertyName(field.Id, issue, rawIssueObject);
} catch (Exception) {
if (!field.Required)
{
return(null);
}
throw;
}
}
return(result);
}
private void selectJiraToolStripMenuItem_Click(object sender, EventArgs e)
{
ToolStripMenuItem clickedItem = (ToolStripMenuItem)sender;
selectedIssue = (JiraIssue)clickedItem.Tag;
jiraKey.Text = selectedIssue.Key;
}
private void updateForm()
{
if (jiraConnector.isLoggedIn)
{
JiraFilter[] filters = jiraConnector.getFilters();
if (filters.Length > 0)
{
foreach (JiraFilter filter in filters)
{
jiraFilterBox.Items.Add(filter);
}
jiraFilterBox.SelectedIndex = 0;
}
changeModus(true);
if (config.LastUsedJira != null)
{
selectedIssue = jiraConnector.getIssue(config.LastUsedJira);
if (selectedIssue != null)
{
jiraKey.Text = config.LastUsedJira;
uploadButton.Enabled = true;
}
}
}
}
public static Dictionary <string, object> GetCsvFields(JiraIssue issue)
{
var fieldsToWrite = new Dictionary <string, object>
{
{ "Key", issue.Key },
{ "Description", issue.Description },
{ "Type", issue.Type },
{ "Team", issue.Team },
{ "Status", issue.Status },
{ "Labels", string.Join(" | ", issue.Labels) },
{ "InProgressDate", issue.InProgressDate.ToDisplayDate() },
{ "DoneDate", issue.DoneDate.ToDisplayDate() },
{ "CycleTime", issue.CycleTime?.ToString() ?? string.Empty }
};
foreach (var state in issue.TimeInStates)
{
fieldsToWrite.Add(state.StateName, state.Date.ToDisplayDate());
}
foreach (var state in issue.TimeInStates)
{
fieldsToWrite.Add($"{state.StateName} (days)", (state.DaysInState <= 0) ? "" : state.DaysInState.ToString());
}
return(fieldsToWrite);
}
public IssueWorkflowAction(
JiraIssue issue, JiraNamedEntity action, JiraIssueListModel model,
List <JiraField> fields, StatusLabel status, Action onFinish)
{
this.issue = issue;
this.action = action;
this.model = model;
this.fields = JiraActionFieldType.sortFieldList(fields);
this.status = status;
this.onFinish = onFinish;
InitializeComponent();
Text = issue.Key + ": " + action.Name;
ClientSize = new Size(INITIAL_WIDTH, INITIAL_HEIGHT + buttonOk.Height + 3 * MARGIN);
buttonOk.Enabled = false;
StartPosition = FormStartPosition.CenterParent;
panelThrobber.Visible = true;
panelContent.Visible = false;
}
public static JiraIssue MapJiraIssue(JToken issueJson)
{
if (!issueJson.Children().Any())
{
throw new InvalidJiraSourceException($"The source data from Jira is an invalid JSON object.");
}
var fields = issueJson.GetMatchingToken("fields").ToList();
var issueKey = issueJson.GetMatchingToken("key").Value <string>();
var changeLog = issueJson.GetMatchingToken("changelog");
var issueSummary = fields.GetMatchingProperty("summary").Value.ToString();
var labels = fields.GetMatchingProperty("labels").Value;
var jiraIssue = new JiraIssue(issueKey, issueSummary)
{
Type = fields.GetMatchingProperty("issuetype").Value["name"].ToString(),
Status = fields.GetMatchingProperty("status").Value["name"].ToString(),
Labels = labels.Values <string>().ToArray(),
HasMoreChangeHistory = changeLog == null || changeLog.GetMatchingToken("maxResults").Value <int>() < changeLog.GetMatchingToken("total").Value <int>()
};
if (!jiraIssue.HasMoreChangeHistory)
{
jiraIssue.JiraStates = JiraStateMapper.MapStates(changeLog?.GetMatchingToken("histories").ToList());
}
return(jiraIssue);
}
protected override AbstractIssueGroupNode findGroupNode(JiraIssue issue)
{
JiraNamedEntity prio = UNKNOWN_PRIORITY;
if (!groupNodes.ContainsKey(issue.PriorityId))
{
List <JiraNamedEntity> priorities = JiraServerCache.Instance.getPriorities(issue.Server);
foreach (JiraNamedEntity priority in priorities)
{
if (priority.Id != issue.PriorityId)
{
continue;
}
prio = priority;
break;
}
ByPriorityIssueGroupNode groupNode =
prio.Id == UNKNOWN_PRIORITY.Id ? unknownPriorityNode : new ByPriorityIssueGroupNode(issue.Server, prio);
groupNodes[prio.Id] = groupNode;
if (prio.Id == UNKNOWN_PRIORITY.Id)
{
issuesWithUnknownPriority.Add(issue);
}
return(groupNode);
}
// all issues with unknown priority must be put in one bucket, once it is created
foreach (var i in issuesWithUnknownPriority)
{
if (i.Id == issue.Id && i.Server.GUID.Equals(issue.Server.GUID))
{
return(groupNodes[UNKNOWN_PRIORITY.Id]);
}
}
return(groupNodes[issue.PriorityId]);
}
public void TestStepMapVerification()
{
var project = new JiraProject {
Key = "TEST", Name = "Test project"
};
using (var transaction = Session.BeginTransaction())
{
Session.Save(project);
JiraIssue issue = new JiraIssue
{
Id = 1,
Project = project
};
Session.Save(issue);
new PersistenceSpecification <TestStep>(Session)
.CheckProperty(p => p.Id, 1)
.CheckProperty(p => p.Data, "Data")
.CheckProperty(p => p.Order, 1)
.CheckProperty(p => p.ExpectedResult, "Result")
.CheckProperty(p => p.Step, "Step")
.CheckReference(p => p.Issue, issue)
.VerifyTheMappings();
}
}
public bool containsUser(JiraIssue issue)
{
foreach (var user in this.selectedUsers)
{
if (user.full_name == issue.Assignee)
{
return(true);
}
else
{
foreach (var field in issue.CustomFields)
{
if (field.Name == this.specificUserFieldId)
{
foreach (var value in field.Values)
{
if (value == user.full_name)
{
return(true);
}
}
}
}
}
}
return(false);
}
public string GetWorkItemDescription(string linkData, string releaseNotePrefix, string releaseNote)
{
var store = Substitute.For <IJiraConfigurationStore>();
var jiraClient = Substitute.For <IJiraRestClient>();
var jiraClientLazy = new Lazy <IJiraRestClient>(() => jiraClient);
var jiraIssue = new JiraIssue
{
Key = linkData,
Fields = new JiraIssueFields
{
Summary = "Test title",
Comments = new JiraIssueComments
{
Total = 1
}
}
};
jiraClient.GetIssue(Arg.Is(linkData)).Returns(jiraIssue);
jiraClient.GetIssueComments(Arg.Is(linkData)).Returns(new JiraIssueComments
{
Comments = new [] { new JiraIssueComment {
Body = releaseNote
} }
});
return(new WorkItemLinkMapper(store, new CommentParser(), jiraClientLazy).GetReleaseNote(jiraIssue, releaseNotePrefix));
}
public void openIssue(JiraIssue issue, JiraActiveIssueManager activeIssueManager)
{
FrameVisible = true;
string key = getIssueTabKey(issue);
if (!issueTabs.TabPages.ContainsKey(key))
{
TabPage issueTab = new TabPage {
Name = key, Text = issue.Key
};
// IssueDetailsPanel issuePanel = new IssueDetailsPanel(model, Solution, issue, issueTab, this, buttonCloseClicked, activeIssueManager);
IssueDetailsPanel issuePanel = new IssueDetailsPanel(model, Solution, issue, this, activeIssueManager);
RecentlyViewedIssuesModel.Instance.add(issue);
issueTab.Controls.Add(issuePanel);
issueTab.ToolTipText = Resources.MIDDLE_CLICK_TO_CLOSE;
issuePanel.Dock = DockStyle.Fill;
issueTabs.TabPages.Add(issueTab);
issueTabs.PostRemoveTabPage = idx => {
issuePanel.closed();
if (issueTabs.TabPages.Count == 0)
{
Instance.FrameVisible = false;
}
};
}
issueTabs.SelectTab(key);
UsageCollector.Instance.bumpJiraIssuesOpen();
}
public List<JiraNamedEntity> getActionsForIssue(JiraIssue issue)
{
RemoteNamedObject[] actions = service.getAvailableActions(token, issue.Key);
List<JiraNamedEntity> list = new List<JiraNamedEntity>();
foreach (RemoteNamedObject action in actions)
{
list.Add(new JiraNamedEntity(int.Parse(action.id), action.name, null));
}
return list;
}
public List<JiraField> getFieldsForAction(JiraIssue issue, int id)
{
RemoteField[] fields = service.getFieldsForAction(token, issue.Key, id.ToString());
List<JiraField> list = new List<JiraField>();
foreach (RemoteField field in fields)
{
list.Add(new JiraField(field.id, field.name));
}
return list;
}
public PivotJiraIssue(JiraIssue issue)
{
Key = issue.Key;
Project = issue.Project;
IsResolved = issue.BuiltInFields.Resolution != null;
Created = issue.Created;
Resolved = issue.Resolved ?? DateTime.MinValue;
Assignee = issue.Assignee;
Reporter = issue.Reporter;
StoryPoints = issue.StoryPoints;
Priority = issue.Priority;
Type = issue.BuiltInFields.IssueType.Name;
Resolution = (issue.BuiltInFields.Resolution ?? RawResolution.EmptyResolution).Name;
EpicName = issue.EpicName;
}
private void MainForm_Load(object sender, EventArgs e)
{
timer = new Timer();
timer.setTickHandler(new EventHandler(tickHandler));
this.mouseMessageFilter = new MouseMoveMessageFilter();
this.mouseMessageFilter.TargetForm = this;
Application.AddMessageFilter(this.mouseMessageFilter);
issuesFilterSource.Add(new JiraIssueFilter {
title = "My Open Issues",
ID = -1,
jql = "assignee = currentUser() AND resolution = Unresolved ORDER BY updatedDate DESC"
});
issuesFilterSource.Add( new JiraIssueFilter {
title = "Reported By Me",
ID = -2,
jql = "reporter = currentUser() ORDER BY createdDate DESC"
});
cbIssueFilters.DataSource = issuesFilterSource;
currentIssue = new JiraIssue
{
ID = 0,
title = "No Issue selected",
code = "0"
};
issuesSource.Add(currentIssue);
issueDataGrid.DataSource = issuesSource;
if (lastConnectSuccess)
{
updateIssuesFilters();
updateIssues();
}
}
private void issueDataGrid_SelectionChanged(object sender, EventArgs e)
{
JiraIssue selectedIssue;
foreach (DataGridViewRow row in issueDataGrid.SelectedRows)
{
selectedIssue = row.DataBoundItem as JiraIssue;
if(selectedIssue != null)
{
toggleTimerControls(selectedIssue.ID != 0);
lbCurIssue.Text = selectedIssue.title;
currentIssue.secondsElapsed = timer.secondsPassed;
timer.secondsPassed = selectedIssue.secondsElapsed;
currentIssue = selectedIssue;
if (timer.isRunning)
timer.stop();
tickHandler(sender, e);
break;
}
}
}
public OpenIssueDetailsMessage(JiraIssue issue)
{
Issue = issue;
}
public void runIssueActionWithoutParams(JiraIssue issue, int id)
{
service.progressWorkflowAction(token, issue.Key, id.ToString(), null);
}
public IssueDetailsViewModel(JiraIssue issue)
{
Issue = issue;
}
public void addComment(JiraIssue issue, string comment)
{
service.addComment(token, issue.Key, new RemoteComment {body = comment});
}
internal void AddComment(JiraIssue issue, string comment)
{
if (String.IsNullOrEmpty(comment)) return;
RemoteComment rc = new RemoteComment();
rc.author = CurrentUser.Id;
rc.body = comment;
rc.created = DateTime.Now;
_service.addComment(_token, issue.DisplayId, rc);
}
internal JiraAction[] GetActions(JiraIssue issue)
{
List<JiraAction> results = new List<JiraAction>();
try
{
RemoteNamedObject[] actionsAvailable = _service.getAvailableActions(_token, issue.DisplayId);
if (actionsAvailable != null)//dumbasses
foreach (RemoteNamedObject item in actionsAvailable)
results.Add(new JiraAction(item));
}
catch { }
return results.ToArray();
}
internal void ViewIssue(JiraIssue issue)
{
string url = String.Format("{0}/browse/{1}", _rootUrl, issue.DisplayId);
try { System.Diagnostics.Process.Start(url); }
catch (Exception e)
{ Log.Error(e, "Failed to view issue at uri = {0}.", url); }
}
internal void ProcessWorklog(JiraIssue issue, string timeSpent, TimeEstimateRecalcualationMethod method, string newTimeEstimate)
{
var remoteWorklog = new RemoteWorklog();
remoteWorklog.comment = "Time logged";
remoteWorklog.timeSpent = timeSpent;
remoteWorklog.startDate = DateTime.Now;
switch (method)
{
case TimeEstimateRecalcualationMethod.AdjustAutomatically:
_service.addWorklogAndAutoAdjustRemainingEstimate(_token, issue.DisplayId, remoteWorklog);
break;
case TimeEstimateRecalcualationMethod.DoNotChange:
_service.addWorklogAndRetainRemainingEstimate(_token, issue.DisplayId, remoteWorklog);
break;
case TimeEstimateRecalcualationMethod.SetToNewValue:
_service.addWorklogWithNewRemainingEstimate(_token, issue.DisplayId, remoteWorklog,
newTimeEstimate);
break;
default:
throw new ArgumentOutOfRangeException("ProcessWorklog");
}
}
internal void ProcessAction(JiraIssue issue, IIssueAction action, IIssueUser assignTo)
{
List<RemoteFieldValue> actionParams = new List<RemoteFieldValue>();
RemoteField[] fields = _service.getFieldsForAction(_token, issue.DisplayId, action.Id);
foreach (RemoteField field in fields)
{
RemoteFieldValue param = new RemoteFieldValue();
string paramName = param.id = field.id;
if (StringComparer.OrdinalIgnoreCase.Equals("Resolution", field.name))
param.values = new string[] { FindFixResolution() };
else if (StringComparer.OrdinalIgnoreCase.Equals("Assignee", field.name))
param.values = new string[] { assignTo.Id };
else if (StringComparer.OrdinalIgnoreCase.Equals("Worklog", paramName)) // JIRA 4.1 - worklogs are required!
continue;
else
{
param.values = issue.GetFieldValue(paramName);
if (param.values == null || param.values.Length == 0 || (param.values.Length == 1 && param.values[0] == null))
{
string setting = _settings(String.Format("{0}:{1}", action.Name, field.name));
if(setting != null)
param.values = new string[] { setting };
}
}
actionParams.Add(param);
}
RemoteIssue newIssue = _service.progressWorkflowAction(_token, issue.DisplayId, action.Id, actionParams.ToArray());
}
