private void saveSelectedValues()
{
ParameterStore store = ParameterStoreManager.Instance.getStoreFor(ParameterStoreManager.StoreType.SETTINGS);
store.storeParameter(PROJECT + server.GUID, comboProjects.SelectedIndex);
store.storeParameter(ISSUE_TYPE + server.GUID, comboTypes.SelectedIndex);
store.storeParameter(PRIORITY + server.GUID, comboPriorities.SelectedIndex);
store.storeParameter(COMPS_SIZE + server.GUID, listComponents.SelectedIndices.Count);
int i = 0;
foreach (int index in listComponents.SelectedIndices)
{
store.storeParameter(COMPS_SEL + (i++) + "_" + server.GUID, index);
}
store.storeParameter(AFFECTS_SIZE + server.GUID, listAffectsVersions.SelectedIndices.Count);
i = 0;
foreach (int index in listAffectsVersions.SelectedIndices)
{
store.storeParameter(AFFECTS_SEL + (i++) + "_" + server.GUID, index);
}
store.storeParameter(FIXES_SIZE + server.GUID, listFixVersions.SelectedIndices.Count);
i = 0;
foreach (int index in listFixVersions.SelectedIndices)
{
store.storeParameter(FIXES_SEL + (i++) + "_" + server.GUID, index);
}
}
private void fillIssueTypes(ICollection <JiraNamedEntity> issueTypes, ParameterStore store)
{
ImageList imageList = new ImageList();
comboTypes.Items.Clear();
int i = 0;
foreach (var type in issueTypes)
{
ComboBoxWithImagesItem <JiraNamedEntity> item = new ComboBoxWithImagesItem <JiraNamedEntity>(type, i);
imageList.Images.Add(ImageCache.Instance.getImage(server, type.IconUrl).Img);
comboTypes.Items.Add(item);
++i;
}
comboTypes.ImageList = imageList;
textDescription.IssueType = -1;
if (initialUpdate)
{
if (issueTypes.Count > 0)
{
int idx = store.loadParameter(ISSUE_TYPE + server.GUID, -1);
if (idx != -1 && comboTypes.Items.Count > idx)
{
comboTypes.SelectedIndex = idx;
}
}
}
}
public void load()
{
lock (this) {
issues.Clear();
ParameterStore store = ParameterStoreManager.Instance.getStoreFor(ParameterStoreManager.StoreType.SETTINGS);
int count = store.loadParameter(RECENTLY_VIEWED_COUNT, -1);
if (count != -1)
{
try {
if (count > MAX_ITEMS)
{
count = MAX_ITEMS;
}
for (int i = 1; i <= count; ++i)
{
string guidStr = store.loadParameter(RECENTLY_VIEWED_ISSUE_SERVER_GUID + i, null);
Guid guid = new Guid(guidStr);
string key = store.loadParameter(RECENTLY_VIEWED_ISSUE_KEY + i, null);
RecentlyViewedIssue issue = new RecentlyViewedIssue(guid, key);
issues.Add(issue);
}
}
catch (Exception e) {
Debug.WriteLine(e);
}
}
}
}
private void fillComponents(IEnumerable <JiraNamedEntity> comps, ParameterStore store)
{
listComponents.Items.Clear();
foreach (var comp in comps)
{
listComponents.Items.Add(comp);
}
if (!initialUpdate)
{
return;
}
int cnt = store.loadParameter(COMPS_SIZE + server.GUID, 0);
if (cnt <= 0)
{
return;
}
for (int i = 0; i < cnt; ++i)
{
int sel = store.loadParameter(COMPS_SEL + i + "_" + server.GUID, -1);
if (sel == -1)
{
continue;
}
if (listComponents.Items.Count > sel)
{
listComponents.SelectedIndices.Add(sel);
}
}
}
protected JiraPresetFilter(JiraServer server, string name)
{
this.server = server;
baseName = name;
Name = baseName;
ParameterStore store = ParameterStoreManager.Instance.getStoreFor(ParameterStoreManager.StoreType.SETTINGS);
string paramName = getSettingName();
string projectKey = store.loadParameter(paramName, null);
if (projectKey != null)
{
SortedDictionary <string, JiraProject> dictionary = JiraServerCache.Instance.getProjects(server);
foreach (JiraProject p in dictionary.Values)
{
if (!p.Key.Equals(projectKey))
{
continue;
}
project = p;
break;
}
}
setNameAndProject();
}
public TrainingSet(List <Patient> patients)
{
var bucketConfig = ParameterStore.GetBucketConfig();
foreach (var bucketSpec in bucketConfig.Buckets)
{
var bucketList = new List <Bucket>();
var bucketType = translateBucketType(bucketSpec);
// create delegate value accessor to perform faster
var valueAccessor = (Func <PatientSample, double?>)
Delegate.CreateDelegate(typeof(Func <PatientSample, double?>), null, typeof(PatientSample).GetProperty(bucketSpec.PropertyName).GetGetMethod());
// create a lambda for bucket number filtering. The first bucket is 6 hours and the rest are 4
Func <PatientSample, BucketSpec, bool> bucketNumberFilter = (ps, bs) => ps.TimeBeforeSepsis > (bs.BucketNumber == 1 ? -6 : bs.BucketNumber * -4 - 2);
// for each patient, create a bucket of their samples
foreach (var patient in patients)
{
var bucket = new Bucket(bucketType, bucketSpec.PropertyName, bucketSpec.BucketNumber, patient.IsSeptic);
var appropriateSamples = patient.PatientSampleDeltas
.Where(ps => bucketNumberFilter(ps, bucketSpec) && valueAccessor(ps).HasValue)
.Select(valueAccessor);
bucket.AddSamples(appropriateSamples);
if (!bucket.Empty /* to check */ && bucketSpec.BucketNumber == 1)
{
bucketList.Add(bucket);
}
}
_totalTrainingSets.Add(bucketSpec, bucketList);
}
}
private void createAndFillTestTree(ICollection <BambooTest> tests)
{
labelNoTestsFound.Visible = false;
toolStripContainerTests.Dock = DockStyle.Fill;
toolStripContainerTests.TopToolStripPanel.Controls.Add(testResultsToolStrip);
testResultsToolStrip.Dock = DockStyle.None;
testResultsToolStrip.GripStyle = ToolStripGripStyle.Hidden;
testResultsToolStrip.Items.AddRange(new ToolStripItem[] { buttonFailedOnly, buttonOpenTest, buttonRunTestInVs, buttonDebugTestInVs });
testResultsToolStrip.Location = new System.Drawing.Point(3, 0);
testResultsToolStrip.Size = new System.Drawing.Size(126, 25);
testResultsToolStrip.TabIndex = 0;
testResultsToolStrip.Visible = true;
ParameterStore store = ParameterStoreManager.Instance.getStoreFor(ParameterStoreManager.StoreType.SETTINGS);
bool failedOnly = store.loadParameter(SHOW_FAILED_TESTS_ONLY, 0) > 0;
testResultTree = new BambooTestResultTree {
Model = new TestResultTreeModel(tests, failedOnly)
};
toolStripContainerTests.ContentPanel.Controls.Add(testResultTree);
testResultTree.SelectionChanged += testResultTree_SelectionChanged;
testResultTree.MouseDoubleClick += testResultTree_MouseDoubleClick;
testResultTree.KeyPress += testResultTree_KeyPress;
buttonFailedOnly.Checked = failedOnly;
buttonFailedOnly.CheckedChanged += buttonFailedOnly_CheckedChanged;
buttonOpenTest.Click += buttonOpenTest_Click;
buttonRunTestInVs.Click += buttonRunTestInVs_Click;
buttonDebugTestInVs.Click += buttonDebugTestInVs_Click;
updateTestButtons();
testResultTree.ExpandAll();
}
public void restoreSelectedIndex()
{
ParameterStore store = ParameterStoreManager.Instance.getStoreFor(ParameterStoreManager.StoreType.SETTINGS);
int selectedIndex = store.loadParameter(SELECTED_INDEX, 0);
SelectedIndex = Items.Count > selectedIndex ? selectedIndex : 0;
}
private void loadPastActiveIssues(ParameterStore store)
{
pastActiveIssues.Clear();
int pastIssueCount = Math.Min(store.loadParameter(PAST_ACTIVE_ISSUE_COUNT, 0), ACTIVE_ISSUE_LIST_SIZE);
for (int i = 0; i < pastIssueCount; ++i)
{
string key = store.loadParameter(PAST_ACTIVE_ISSUE_KEY + i, null);
string guid = store.loadParameter(PAST_ACTIVE_ISSUE_SERVER_GUID + i, null);
if (key == null || guid == null)
{
continue;
}
ICollection <JiraServer> jiraServers = JiraServerModel.Instance.getAllServers();
foreach (ActiveIssue issue in from server in jiraServers
where server.GUID.ToString().Equals(guid)
select new ActiveIssue(key, guid)
{
Enabled = server.Enabled
})
{
pastActiveIssues.AddLast(issue);
break;
}
}
savePastActiveIssuesAndSetupDropDown();
setNoIssueActiveInDropDown();
}
private void loadColumnWidths()
{
ParameterStore store = ParameterStoreManager.Instance.getStoreFor(ParameterStoreManager.StoreType.SETTINGS);
statusWidth = store.loadParameter(JIRA_STATUS_COLUMN_WIDTH, STATUS_WIDTH_DEFAULT);
updatedWidth = store.loadParameter(JIRA_UPDATED_COLUMN_WIDTH, UPDATED_WIDTH_DEFAULT);
}
static async Task Main(string[] args)
{
ParameterStore parameterStore = new ParameterStore();
if (await parameterStore.InitializeAsync(args))
{
ISynchronizer Synchronizer = new DefaultSynchronizer(_logger, await parameterStore.QueryParameterAsync <UriParameter>(), await parameterStore.QueryParameterAsync <OautTokenParameter>());
OrganizationNameParameter sourceOrganizationNameParameter = await parameterStore.QueryParameterAsync <SourceOrganizationNameParameter>();
OrganizationNameParameter targetOrganizationParameter = await parameterStore.QueryParameterAsync <TargetOrganizationNameParameter>() ?? sourceOrganizationNameParameter;
SourceRepositoryNameParameter sourceRepositoryNameParameter = await parameterStore.QueryParameterAsync <SourceRepositoryNameParameter>();
TargetRepositoryNameParameter targetRepositoryNameParameter = await parameterStore.QueryParameterAsync <TargetRepositoryNameParameter>();
StrictFlagParameter strictFlagParameter = await parameterStore.QueryParameterAsync <StrictFlagParameter>();
if (targetRepositoryNameParameter == null)
{
await Synchronizer.SynchronizeAsync(sourceOrganizationNameParameter, sourceRepositoryNameParameter, targetOrganizationParameter, strictFlagParameter);
}
else
{
await Synchronizer.SynchronizeAsync(sourceOrganizationNameParameter, await parameterStore.QueryParameterAsync <SourceRepositoryNameParameter>(), targetOrganizationParameter, targetRepositoryNameParameter, strictFlagParameter);
}
}
else
{
await WriteHelpAsync();
}
Console.ReadKey();
}
protected override void loadCustomServerParameters(ParameterStore store, BambooServer server)
{
server.UseFavourites = store.loadParameter(USE_FAVOURITES + "_" + server.GUID, 1) > 0;
server.ShowBranches = store.loadParameter(SHOW_BRANCHES + "_" + server.GUID, 1) > 0;
server.ShowMyBranchesOnly = store.loadParameter(MY_BRANCHES_ONLY + "_" + server.GUID, 0) > 0;
string keyString = store.loadParameter(PLAN_KEYS + "_" + server.GUID, "");
setPlanKeysFromString(server, keyString);
}
private static void loadAssignee(ParameterStore store, Guid key, JiraCustomFilter f)
{
string assigneeString = store.loadParameter(getParamKey(key, FILTER_ASSIGNEE), UserType.UNDEFINED.ToString());
try {
f.Assignee = (UserType)Enum.Parse(typeof(UserType), assigneeString);
} catch (Exception) {
f.Assignee = UserType.UNDEFINED;
}
}
protected override void saveCustomServerParameters(ParameterStore store, BambooServer server)
{
store.storeParameter(USE_FAVOURITES + "_" + server.GUID, server.UseFavourites ? 1 : 0);
store.storeParameter(SHOW_BRANCHES + "_" + server.GUID, server.ShowBranches ? 1 : 0);
store.storeParameter(MY_BRANCHES_ONLY + "_" + server.GUID, server.ShowMyBranchesOnly ? 1 : 0);
string planKeys = getPlanKeysStringFromPlans(server);
store.storeParameter(PLAN_KEYS + "_" + server.GUID, planKeys.Trim());
}
private static void loadReporter(ParameterStore store, Guid key, JiraCustomFilter f)
{
string reporterString = store.loadParameter(getParamKey(key, FILTER_REPORTER), UserType.UNDEFINED.ToString());
try {
f.Reporter = (UserType)Enum.Parse(typeof(UserType), reporterString);
} catch (Exception) {
f.Reporter = UserType.UNDEFINED;
}
}
private void loadColumnWidths()
{
ParameterStore store = ParameterStoreManager.Instance.getStoreFor(ParameterStoreManager.StoreType.SETTINGS);
statusWidth = store.loadParameter(BAMBOO_STATUS_COLUMN_WIDTH, STATUS_AND_KEY_WIDTH_DEFAULT);
testsWidth = store.loadParameter(BAMBOO_TESTS_COLUMN_WIDTH, TESTS_WIDTH_DEFAULT);
completedWidth = store.loadParameter(BAMBOO_COMPLETED_COLUMN_WIDTH, COMPLETED_WIDTH_DEFAULT);
durationWidth = store.loadParameter(BAMBOO_DURATION_COLUMN_WIDTH, DURATION_WIDTH_DEFAULT);
serverWidth = store.loadParameter(BAMBOO_SERVER_COLUMN_WIDTH, SERVER_WIDTH_DEFAULT);
}
private void saveColumnWidths()
{
statusWidth = colStatus.Width;
updatedWidth = colUpdated.Width;
ParameterStore store = ParameterStoreManager.Instance.getStoreFor(ParameterStoreManager.StoreType.SETTINGS);
store.storeParameter(JIRA_STATUS_COLUMN_WIDTH, statusWidth);
store.storeParameter(JIRA_UPDATED_COLUMN_WIDTH, updatedWidth);
}
private void setProject(JiraProject p)
{
project = p;
ParameterStore store = ParameterStoreManager.Instance.getStoreFor(ParameterStoreManager.StoreType.SETTINGS);
string paramName = getSettingName();
store.storeParameter(paramName, project != null ? project.Key : null);
setNameAndProject();
}
private static void storePriorities(ParameterStore store, Guid key, JiraCustomFilter f)
{
int i = 0;
store.storeParameter(getParamKey(key, FILTER_PRIORITIES_COUNT), f.Priorities.Count);
foreach (JiraNamedEntity priority in f.Priorities)
{
store.storeParameter(getParamKey(key, FILTER_PRIORITIES_ID + i), priority.Id);
store.storeParameter(getParamKey(key, FILTER_PRIORITIES_NAME + i), priority.Name);
++i;
}
}
private static void loadProjects(ParameterStore store, Guid key, JiraCustomFilter f)
{
int count = store.loadParameter(getParamKey(key, FILTER_PROJECT_COUNT), 0);
for (int i = 0; i < count; ++i)
{
int id = store.loadParameter(getParamKey(key, FILTER_PROJECT_ID + i), 0);
string projectKey = store.loadParameter(getParamKey(key, FILTER_PROJECT_KEY + i), null);
JiraProject proj = new JiraProject(id, projectKey, projectKey);
f.Projects.Add(proj);
}
}
private static void storeProjects(ParameterStore store, Guid key, JiraCustomFilter f)
{
store.storeParameter(getParamKey(key, FILTER_PROJECT_COUNT), f.Projects.Count);
int i = 0;
foreach (JiraProject project in f.Projects)
{
store.storeParameter(getParamKey(key, FILTER_PROJECT_ID + i), project.Id);
store.storeParameter(getParamKey(key, FILTER_PROJECT_KEY + i), project.Key);
++i;
}
}
private static void loadIssueTypes(ParameterStore store, Guid key, JiraCustomFilter f)
{
int count = store.loadParameter(getParamKey(key, FILTER_ISSUE_TYPE_COUNT), 0);
for (int i = 0; i < count; ++i)
{
int id = store.loadParameter(getParamKey(key, FILTER_ISSUE_TYPE_ID + i), 0);
string name = store.loadParameter(getParamKey(key, FILTER_ISSUE_TYPE_NAME + i), null);
JiraNamedEntity issueType = new JiraNamedEntity(id, name, null);
f.IssueTypes.Add(issueType);
}
}
private static void storeIssueTypes(ParameterStore store, Guid key, JiraCustomFilter f)
{
int i = 0;
store.storeParameter(getParamKey(key, FILTER_ISSUE_TYPE_COUNT), f.IssueTypes.Count);
foreach (JiraNamedEntity issueType in f.IssueTypes)
{
store.storeParameter(getParamKey(key, FILTER_ISSUE_TYPE_ID + i), issueType.Id);
store.storeParameter(getParamKey(key, FILTER_ISSUE_TYPE_NAME + i), issueType.Name);
++i;
}
}
private static void loadFixVersions(ParameterStore store, Guid key, JiraCustomFilter f)
{
int count = store.loadParameter(getParamKey(key, FILTER_FIXFORVERSIONS_COUNT), 0);
for (int i = 0; i < count; ++i)
{
int id = store.loadParameter(getParamKey(key, FILTER_FIXFORVERSIONS_ID + i), 0);
string name = store.loadParameter(getParamKey(key, FILTER_FIXFORVERSIONS_NAME + i), null);
JiraNamedEntity fixVersion = new JiraNamedEntity(id, name, null);
f.FixForVersions.Add(fixVersion);
}
}
private static void storeFixVersions(ParameterStore store, Guid key, JiraCustomFilter f)
{
int i = 0;
store.storeParameter(getParamKey(key, FILTER_FIXFORVERSIONS_COUNT), f.FixForVersions.Count);
foreach (JiraNamedEntity version in f.FixForVersions)
{
store.storeParameter(getParamKey(key, FILTER_FIXFORVERSIONS_ID + i), version.Id);
store.storeParameter(getParamKey(key, FILTER_FIXFORVERSIONS_NAME + i), version.Name);
++i;
}
}
private static void loadComponents(ParameterStore store, Guid key, JiraCustomFilter f)
{
int count = store.loadParameter(getParamKey(key, FILTER_COMPONENTS_COUNT), 0);
for (int i = 0; i < count; ++i)
{
int id = store.loadParameter(getParamKey(key, FILTER_COMPONENTS_ID + i), 0);
string name = store.loadParameter(getParamKey(key, FILTER_COMPONENTS_NAME + i), null);
JiraNamedEntity comp = new JiraNamedEntity(id, name, null);
f.Components.Add(comp);
}
}
private static void storeComponents(ParameterStore store, Guid key, JiraCustomFilter f)
{
int i = 0;
store.storeParameter(getParamKey(key, FILTER_COMPONENTS_COUNT), f.Components.Count);
foreach (JiraNamedEntity comp in f.Components)
{
store.storeParameter(getParamKey(key, FILTER_COMPONENTS_ID + i), comp.Id);
store.storeParameter(getParamKey(key, FILTER_COMPONENTS_NAME + i), comp.Name);
++i;
}
}
private static void loadPriorities(ParameterStore store, Guid key, JiraCustomFilter f)
{
int count = store.loadParameter(getParamKey(key, FILTER_PRIORITIES_COUNT), 0);
for (int i = 0; i < count; ++i)
{
int id = store.loadParameter(getParamKey(key, FILTER_PRIORITIES_ID + i), 0);
string name = store.loadParameter(getParamKey(key, FILTER_PRIORITIES_NAME + i), null);
JiraNamedEntity priority = new JiraNamedEntity(id, name, null);
f.Priorities.Add(priority);
}
}
private static void loadStatuses(ParameterStore store, Guid key, JiraCustomFilter f)
{
int count = store.loadParameter(getParamKey(key, FILTER_STATUSES_COUNT), 0);
for (int i = 0; i < count; ++i)
{
int id = store.loadParameter(getParamKey(key, FILTER_STATUSES_ID + i), 0);
string name = store.loadParameter(getParamKey(key, FILTER_STATUSES_NAME + i), null);
JiraNamedEntity status = new JiraNamedEntity(id, name, null);
f.Statuses.Add(status);
}
}
private static void storeStatuses(ParameterStore store, Guid key, JiraCustomFilter f)
{
int i = 0;
store.storeParameter(getParamKey(key, FILTER_STATUSES_COUNT), f.Statuses.Count);
foreach (JiraNamedEntity status in f.Statuses)
{
store.storeParameter(getParamKey(key, FILTER_STATUSES_ID + i), status.Id);
store.storeParameter(getParamKey(key, FILTER_STATUSES_NAME + i), status.Name);
++i;
}
}
