public IEnumerable <IMitigation> Filter(IEnumerable <IMitigation> mitigations)
{
IEnumerable <IMitigation> result = null;
var items = mitigations?.ToArray();
if (items?.Any() ?? false)
{
var model = items.First().Model;
if (model != null)
{
var schemaManager = new DevOpsPropertySchemaManager(model);
var list = new List <IMitigation>();
foreach (var item in items)
{
if (string.CompareOrdinal(schemaManager.GetFirstSeenOn(item)?.IterationId, _iteration.Id) == 0)
{
list.Add(item);
}
}
if (list.Any())
{
result = list.AsReadOnly();
}
}
}
return(result);
}
private async void AutoLoad([NotNull] IMitigation mitigation, [NotNull] IDevOpsConnector connector,
[NotNull] DevOpsPropertySchemaManager schemaManager)
{
try
{
var devOpsItemInfos = (await connector.GetItemsAsync(mitigation.Name))?.ToArray();
if ((devOpsItemInfos?.Length ?? 0) == 1)
{
var info = devOpsItemInfos.First();
if (info?.Id >= 0)
{
var workItemInfo = await connector.GetWorkItemInfoAsync(info.Id);
if (workItemInfo != null)
{
schemaManager.SetDevOpsStatus(mitigation, connector, info.Id,
info.Url, info.AssignedTo, workItemInfo.Status);
}
}
}
}
finally
{
_countdown.Signal();
}
}
public static IDictionary <IMitigation, WorkItemSummary> GetMitigationsSummary([NotNull] IThreatModel model)
{
IDictionary <IMitigation, WorkItemSummary> result = null;
if (_connectors.TryGetValue(model.Id, out var connector))
{
var schemaManager = new DevOpsPropertySchemaManager(model);
var mitigations = model.GetUniqueMitigations()?.OrderBy(x => x.Name).ToArray();
if (mitigations?.Any() ?? false)
{
foreach (var mitigation in mitigations)
{
var info = schemaManager.GetDevOpsInfo(mitigation, connector);
if (info != null)
{
if (result == null)
{
result = new Dictionary <IMitigation, WorkItemSummary>();
}
result.Add(mitigation, new WorkItemSummary(info.Id, info.Status, info.AssignedTo));
}
}
}
}
return(result);
}
private void _ok_Click(object sender, EventArgs e)
{
if (_iterations.SelectedItem is Iteration iteration)
{
var schemaManager = new DevOpsPropertySchemaManager(_model);
schemaManager.SetFirstSeenOn(_mitigation, iteration);
}
}
public string GetValue([NotNull] IMitigation mitigation)
{
string result = null;
// ReSharper disable once PatternAlwaysOfType
if (mitigation.Model is IThreatModel model)
{
var schemaManager = new DevOpsPropertySchemaManager(model);
result = schemaManager.GetFirstSeenOn(mitigation)?.GetIteration(model)?.Name;
}
return(result);
}
public static async Task <bool> SetMitigationsStatusAsync([NotNull] IMitigation mitigation, WorkItemStatus status)
{
bool result = false;
var model = mitigation.Model;
if (model != null)
{
var connector = GetConnector(model);
if (connector?.IsConnected() ?? false)
{
var workItemInfo = await connector.GetWorkItemInfoAsync(mitigation).ConfigureAwait(false);
int id;
if (workItemInfo == null)
{
id = await connector.CreateWorkItemAsync(mitigation).ConfigureAwait(false);
if (id >= 0)
{
workItemInfo = await connector.GetWorkItemInfoAsync(id).ConfigureAwait(false);
}
}
else
{
id = workItemInfo.Id;
}
if (id >= 0)
{
if (await connector.SetWorkItemStateAsync(id, status).ConfigureAwait(false))
{
var schemaManager = new DevOpsPropertySchemaManager(model);
schemaManager.SetDevOpsStatus(mitigation, connector, id, workItemInfo?.Url, status);
result = true;
}
else
{
throw new WorkItemStateChangeException(mitigation,
workItemInfo?.Status ?? WorkItemStatus.Created, status);
}
}
else
{
throw new WorkItemCreationException(mitigation);
}
}
}
return(result);
}
private void LoadModel()
{
try
{
_loading = true;
ClearPalettes();
var schemaManager = new RoadmapPropertySchemaManager(_model);
var devOpsSchemaManager = new DevOpsPropertySchemaManager(_model);
var connector = DevOpsManager.GetConnector(_model);
IEnumerable <IMitigation> mitigations;
if (_filter == RoadmapStatus.NoActionRequired)
{
mitigations = _model?.GetUniqueMitigations()?
.Where(x => (schemaManager.GetStatus(x) != RoadmapStatus.NoActionRequired) ||
(connector != null && devOpsSchemaManager.GetDevOpsInfo(x, connector) != null))
.OrderBy(x => x.Name).ToArray();
}
else
{
mitigations = _model?.GetUniqueMitigations()?
.Where(x => schemaManager.GetStatus(x) == _filter)
.OrderBy(x => x.Name).ToArray();
}
if (mitigations?.Any() ?? false)
{
var summaries = DevOpsManager.GetMitigationsSummary(_model);
foreach (var mitigation in mitigations)
{
if (summaries?.ContainsKey(mitigation) ?? false)
{
var summary = summaries[mitigation];
AddItem(mitigation, summary.Status, summary.AssignedTo);
}
else
{
AddItem(mitigation, WorkItemStatus.Unknown, null);
}
}
RefreshNodes();
}
}
finally
{
_loading = false;
}
}
protected override bool SetFirst(object item)
{
bool result = false;
if (!_loading && item is IMitigation mitigation &&
MessageBox.Show(Form.ActiveForm, "This action is going to remove the Mitigation from the DevOps system. Are you sure?", "Mitigation removal",
MessageBoxButtons.YesNo, MessageBoxIcon.Warning, MessageBoxDefaultButton.Button2) == DialogResult.Yes)
{
result = Set(mitigation, 0);
var schemaManager = new DevOpsPropertySchemaManager(_model);
schemaManager.RemoveDevOpsInfos(mitigation);
}
return(result);
}
public bool Execute(IIdentity identity)
{
bool result = false;
if (identity is IThreatModel model)
{
var schemaManager = new DevOpsPropertySchemaManager(model);
var mitigations = model.Mitigations?
.Where(x => schemaManager.GetFirstSeenOn(x) == null)
.ToArray();
if (mitigations?.Any() ?? false)
{
var configSchemaManager = new DevOpsConfigPropertySchemaManager(model);
var iteration = configSchemaManager.CurrentIteration;
if (iteration != null)
{
if (MessageBox.Show(
$"You are about to assign {mitigations.Length} mitigations to the current iteration ('{iteration.Name}')." +
$"\nDo you confirm?", "Bulk assignment to Iteration", MessageBoxButtons.YesNo,
MessageBoxIcon.Information, MessageBoxDefaultButton.Button2) == DialogResult.Yes)
{
foreach (var mitigation in mitigations)
{
schemaManager.SetFirstSeenOn(mitigation, iteration);
}
result = true;
ShowMessage?.Invoke("Assignment to Iteration succeeded.");
}
}
else
{
ShowWarning?.Invoke("No current Iteration is defined.");
}
}
else
{
ShowMessage?.Invoke(
"Nothing to do, because all Mitigations have already been assigned to an Iteration.");
}
}
return(result);
}
public string GetValue([NotNull] IMitigation mitigation)
{
string result = null;
// ReSharper disable once PatternAlwaysOfType
if (mitigation.Model is IThreatModel model)
{
var connector = DevOpsManager.GetConnector(model);
if (connector != null)
{
var schemaManager = new DevOpsPropertySchemaManager(model);
var status = schemaManager.GetDevOpsInfo(mitigation, connector);
result = (status?.Status ?? WorkItemStatus.Unknown).GetEnumLabel();
}
}
return(result);
}
private static async Task <int> UpdateMitigationsAsync([NotNull] IThreatModel model, [NotNull] IDevOpsConnector connector)
{
int result = 0;
var schemaManager = new DevOpsPropertySchemaManager(model);
var mitigations = model.GetUniqueMitigations()?
.ToDictionary(x => x, x => schemaManager.GetDevOpsInfo(x, connector))
.ToArray();
if (mitigations?.Any() ?? false)
{
var infos = await connector
.GetWorkItemsInfoAsync(mitigations
.Select(x => x.Value?.Id ?? -1)
.Where(x => x >= 0)
);
if (infos != null)
{
foreach (var info in infos)
{
var pairs = mitigations
.Where(x => x.Value != null && x.Value.Id == info.Id)
.ToArray();
if (pairs.Any())
{
var pair = pairs.FirstOrDefault();
if (pair.Value.Status != info.Status ||
string.CompareOrdinal(pair.Value.AssignedTo, info.AssignedTo) != 0)
{
schemaManager.SetDevOpsStatus(pair.Key, connector, info.Id, info.Url, info.AssignedTo, info.Status);
result++;
}
}
}
}
}
return(result);
}
private async void _ok_Click(object sender, EventArgs e)
{
if (_objects.SelectedItem is IDevOpsItemInfo devOpsItemInfo)
{
var connector = DevOpsManager.GetConnector(_mitigation.Model);
if (connector != null)
{
var workItemInfo = await connector.GetWorkItemInfoAsync(devOpsItemInfo.Id);
if (workItemInfo != null)
{
var schemaManager = new DevOpsPropertySchemaManager(_mitigation.Model);
schemaManager.SetDevOpsStatus(_mitigation, connector, devOpsItemInfo.Id,
devOpsItemInfo.Url, devOpsItemInfo.AssignedTo, workItemInfo.Status);
SelectedItemInfo = devOpsItemInfo;
DialogResult = DialogResult.OK;
}
}
}
}
private void ItemOnMoveRequired(KanbanItem item)
{
if (item?.Item is IMitigation mitigation)
{
var connector = DevOpsManager.GetConnector(_model);
if (connector != null)
{
var indexInitial = GetPosition(item);
var schemaManager = new DevOpsPropertySchemaManager(_model);
var devOpsInfo = schemaManager.GetDevOpsInfo(mitigation, connector);
if (devOpsInfo != null)
{
var indexFinal = _captions.IndexOf(devOpsInfo.Status.GetEnumLabel());
Remove(item, indexInitial);
Add(item, indexFinal);
RefreshPalette(indexInitial);
RefreshPalette(indexFinal);
}
}
}
}
private void LoadModel()
{
var schemaManager = new DevOpsConfigPropertySchemaManager(_model);
var iterations = schemaManager.GetIterations()?.ToArray();
if (iterations?.Any() ?? false)
{
_iterations.Items.AddRange(iterations);
var propertySchemaManager = new DevOpsPropertySchemaManager(_model);
var firstSeenOn = propertySchemaManager.GetFirstSeenOn(_mitigation);
if (firstSeenOn != null)
{
var item = _iterations.Items.OfType <Iteration>()
.FirstOrDefault(x => string.CompareOrdinal(x.Id, firstSeenOn.IterationId) == 0);
if (item != null)
{
_iterations.SelectedItem = item;
}
}
}
}
public bool Execute(IIdentity identity)
{
bool result = false;
if (identity is IMitigation mitigation && mitigation.Model is IThreatModel model)
{
var schemaManager = new DevOpsPropertySchemaManager(model);
var iteration = schemaManager.GetFirstSeenOn(mitigation)?.GetIteration(model);
if (iteration != null)
{
if (MessageBox.Show(
$"You are about to unassign mitigation '{mitigation.Name}' from iteration '{iteration.Name}'." +
$"\nDo you confirm?", "Unassign from Iteration", MessageBoxButtons.YesNo,
MessageBoxIcon.Information, MessageBoxDefaultButton.Button2) == DialogResult.Yes)
{
schemaManager.SetFirstSeenOn(mitigation, null);
result = true;
}
}
}
return(result);
}
public bool Execute(IIdentity identity)
{
bool result = false;
if (identity is IThreatModel model)
{
var schemaManager = new DevOpsPropertySchemaManager(model);
var mitigations = model.Mitigations?
.Where(x => schemaManager.GetFirstSeenOn(x) != null)
.ToArray();
if (mitigations?.Any() ?? false)
{
var configSchemaManager = new DevOpsConfigPropertySchemaManager(model);
if (MessageBox.Show(
$"You are about to unassign {mitigations.Length} mitigations from the assigned iterations." +
$"\nDo you confirm?", "Bulk unassignment from Iterations", MessageBoxButtons.YesNo,
MessageBoxIcon.Information, MessageBoxDefaultButton.Button2) == DialogResult.Yes)
{
foreach (var mitigation in mitigations)
{
schemaManager.SetFirstSeenOn(mitigation, null);
}
result = true;
ShowMessage?.Invoke("Unassignment from Iterations succeeded.");
}
}
else
{
ShowMessage?.Invoke(
"Nothing to do, because no Mitigation has already been assigned to an Iteration.");
}
}
return(result);
}
public KanbanItem([NotNull] IMitigation mitigation, int originalContainer) :
this(mitigation.Name, ThreatModelManager.StandardColor, originalContainer)
{
Item = mitigation;
var model = mitigation.Model;
if (model != null)
{
var schemaManager = new RoadmapPropertySchemaManager(model);
SetInfo("Roadmap", schemaManager.GetStatus(mitigation).GetEnumLabel());
_connector = DevOpsManager.GetConnector(model);
if (_connector != null)
{
var devOpsSchemaManager = new DevOpsPropertySchemaManager(model);
var info = devOpsSchemaManager.GetDevOpsInfo(mitigation, _connector);
if ((info?.Id ?? -1) >= 0)
{
DevOpsId = info.Id;
}
}
}
}
private static async Task <int> UpdateMitigationsAsync([NotNull] IThreatModel model, [NotNull] IDevOpsConnector connector)
{
int result = 0;
var schemaManager = new DevOpsPropertySchemaManager(model);
var mitigations = model.GetUniqueMitigations()?
.ToDictionary(x => x, x => schemaManager.GetDevOpsInfo(x, connector))
.ToArray();
if (mitigations?.Any() ?? false)
{
var infos = await connector
.GetWorkItemsInfoAsync(mitigations
.Select(x => x.Value?.Id ?? -1)
.Where(x => x >= 0)
);
if (infos != null)
{
foreach (var info in infos)
{
var pairs = mitigations
.Where(x => x.Value != null && x.Value.Id == info.Id)
.ToArray();
if (pairs.Any())
{
var pair = pairs.FirstOrDefault();
if (pair.Value.Status != info.Status ||
string.CompareOrdinal(pair.Value.AssignedTo, info.AssignedTo) != 0)
{
schemaManager.SetDevOpsStatus(pair.Key, connector, info.Id, info.Url, info.AssignedTo, info.Status);
result++;
}
MitigationStatus status;
switch (info.Status)
{
case WorkItemStatus.Created:
status = MitigationStatus.Approved;
break;
case WorkItemStatus.Planned:
status = MitigationStatus.Planned;
break;
case WorkItemStatus.InProgress:
status = MitigationStatus.Planned;
break;
case WorkItemStatus.Done:
status = MitigationStatus.Implemented;
break;
default:
status = MitigationStatus.Proposed;
break;
}
var tems = model.GetThreatEventMitigations(pair.Key);
if (tems?.Any() ?? false)
{
foreach (var tem in tems)
{
if (tem.Status != status)
{
tem.Status = status;
}
}
}
}
}
}
var missing = mitigations.Where(x => x.Value != null && (infos?.All(y => y.Id != x.Value.Id) ?? true)).ToArray();
if (missing.Any())
{
foreach (var m in missing)
{
schemaManager.RemoveDevOpsInfos(m.Key);
}
}
}
return(result);
}
public async void ExecuteCustomAction([NotNull] IActionDefinition action)
{
string text = null;
bool warning = false;
try
{
switch (action.Name)
{
case "Sync":
if ((await DevOpsManager.UpdateAsync(_model)) > 0)
{
LoadModel();
}
break;
case "Auto":
var summaries = DevOpsManager.GetMitigationsSummary(_model);
var schemaManager = new RoadmapPropertySchemaManager(_model);
var mitigations = _model?.GetUniqueMitigations()?
.Where(x => (schemaManager.GetStatus(x) != RoadmapStatus.NoActionRequired) &&
!(summaries?.ContainsKey(x) ?? false))
.OrderBy(x => x.Name).ToArray();
if (mitigations?.Any() ?? false)
{
var connector = DevOpsManager.GetConnector(_model);
var devOpsSchemaManager = new DevOpsPropertySchemaManager(_model);
_countdown = new CountdownEvent(mitigations.Length);
foreach (var mitigation in mitigations)
{
AutoLoad(mitigation, connector, devOpsSchemaManager);
}
ShowMessage?.Invoke("Automatic Load in progress...");
AutomaticLoadCompletion();
}
else
{
ShowWarning?.Invoke("Automatic Load has not identified any action to do.");
}
break;
case "ShortTerm":
_filter = RoadmapStatus.ShortTerm;
LoadModel();
break;
case "MidTerm":
_filter = RoadmapStatus.MidTerm;
LoadModel();
break;
case "LongTerm":
_filter = RoadmapStatus.LongTerm;
LoadModel();
break;
case "All":
_filter = RoadmapStatus.NoActionRequired;
LoadModel();
break;
case "Refresh":
LoadModel();
break;
}
//if (warning)
// ShowWarning?.Invoke(text);
//else if (text != null)
// ShowMessage?.Invoke($"{text} has been executed successfully.");
}
catch
{
//ShowWarning?.Invoke($"An error occurred during the execution of the action.");
throw;
}
}
