public bool Execute(IThreatTypeMitigation mitigation) { var result = false; var model = mitigation.Model; if (model != null) { var rule = mitigation.GetRule(model); var parent = mitigation.ThreatType; if (parent != null) { var parentRule = parent.GetRule(model); if (string.CompareOrdinal(rule?.ToString(), parentRule?.ToString()) != 0) { Ask?.Invoke(this, new Context() { Container = mitigation, Rule = parentRule }, "Inherit Auto Gen Rule from Threat Type", $"Are you sure you want to replace the existing rule for '{mitigation.Mitigation.Name}' with the one assigned to Threat Type '{parent.Name}'?", true, RequestOptions.YesNo); } else { ShowMessage?.Invoke("Nothing to do, because the Auto Gen Rules are equivalent."); } result = true; } } return(result); }
private GridRow GetRow([NotNull] IThreatTypeMitigation mitigation) { GridRow result = null; var rows = _grid.PrimaryGrid.Rows.OfType <GridRow>().ToArray(); foreach (var row in rows) { var panel = row.Rows.OfType <GridPanel>() .FirstOrDefault(x => string.CompareOrdinal("Mitigations", x.Name) == 0); if (panel != null) { result = panel.Rows.OfType <GridRow>().FirstOrDefault(x => (x.Tag is IThreatTypeMitigation threatTypeMitigation) && (threatTypeMitigation.MitigationId == mitigation.MitigationId) && (threatTypeMitigation.ThreatTypeId == mitigation.ThreatTypeId)); if (result != null) { break; } } } return(result); }
public bool Initialize([NotNull] IThreatTypeMitigation threatTypeMitigation) { bool result = false; _model = threatTypeMitigation.Model; _threatType.Text = threatTypeMitigation.ThreatType.Name; _mitigation.Text = threatTypeMitigation.Mitigation.Name; _strengthOverride.SelectedIndex = 0; var strengths = _model.Strengths?.ToArray(); if (strengths?.Any() ?? false) _strengthOverride.Items.AddRange(strengths); _statusOverride.SelectedIndex = 0; _statusOverride.Items.AddRange(EnumExtensions.GetEnumLabels<MitigationStatus>().ToArray()); _severityOverride.SelectedIndex = 0; var severities = _model.Severities?.Where(x => x.Visible).ToArray(); if (severities?.Any() ?? false) _severityOverride.Items.AddRange(severities); _threatTypeRule = threatTypeMitigation.ThreatType.GetRule(); if (_threatTypeRule != null) { result = true; _ruleEditor.Initialize(_model); } return result; }
public static bool HasTop(this IThreatTypeMitigation mitigation, AutoGenRulesPropertySchemaManager schemaManager = null) { if (schemaManager == null) { schemaManager = new AutoGenRulesPropertySchemaManager(mitigation.Model); } return(schemaManager.IsTop(mitigation)); }
public bool Execute(IThreatTypeMitigation mitigation) { bool result = false; if (mitigation is IPropertiesContainer container) { result = Execute(container); } return(result); }
public bool Execute(IThreatTypeMitigation mitigation) { var result = false; if (Clipboard.GetDataObject() is DataObject dataObject && dataObject.GetDataPresent("AutoGenRule") && dataObject.GetData("AutoGenRule") is string autoGenRule) { result = ApplyGenRule(mitigation, autoGenRule); } return(result); }
private void AddGridRow([NotNull] IThreatTypeMitigation mitigation, [NotNull] GridPanel panel) { bool rule = HasSelectionRule(mitigation); GridRow row = new GridRow( mitigation.Mitigation.Name, rule ? "Edit Rule" : "Create Rule") { Tag = mitigation }; panel.Rows.Add(row); ((INotifyPropertyChanged)mitigation).PropertyChanged += OnMitigationPropertyChanged; ((INotifyPropertyChanged)mitigation.Mitigation).PropertyChanged += OnMitigationPropertyChanged; mitigation.PropertyValueChanged += OnMitigationPropertyValueChanged; }
public bool Execute(IThreatTypeMitigation ttMitigation) { bool result = false; if (ttMitigation != null) { using (var dialog = new ItemEditorDialog()) { dialog.SetExecutionMode(_executionMode); dialog.Item = ttMitigation.Mitigation; dialog.ShowDialog(Form.ActiveForm); } result = true; } return(result); }
public IThreatTypeMitigation AddMitigation([NotNull] IMitigation mitigation, IStrength strength) { IThreatTypeMitigation result = null; if (GetMitigation(mitigation.Id) == null) { result = new ThreatTypeMitigation(Model, this, mitigation, strength); if (_mitigations == null) { _mitigations = new List <IThreatTypeMitigation>(); } _mitigations.Add(result); SetDirty(); _threatTypeMitigationAdded?.Invoke(this, result); } return(result); }
public bool Execute(IThreatTypeMitigation mitigation) { bool result = false; using (var dialog = new MitigationRuleEditDialog()) { if (dialog.Initialize(mitigation)) { result = mitigation.SetRule(dialog); } else { ShowWarning?.Invoke("Threat Event Generation Rule for the related Threat Type has not been set."); } } return(result); }
private void AddGridRow([NotNull] IThreatTypeMitigation mitigation, [NotNull] GridPanel panel) { GridRow row = new GridRow( mitigation.Mitigation.Name, mitigation.Mitigation.ControlType.ToString(), mitigation.Strength.ToString()) { Tag = mitigation }; row.Cells[0].CellStyles.Default.Image = mitigation.Mitigation.GetImage(ImageSize.Small); for (int i = 0; i < row.Cells.Count; i++) { row.Cells[i].PropertyChanged += OnMitigationCellChanged; } panel.Rows.Add(row); ((INotifyPropertyChanged)mitigation).PropertyChanged += OnMitigationPropertyChanged; ((INotifyPropertyChanged)mitigation.Mitigation).PropertyChanged += OnMitigationPropertyChanged; }
private void AddGridRow([NotNull] IThreatTypeMitigation ttm, [NotNull] GridPanel panel) { GridRow row = new GridRow( ttm.ThreatType.Name, ttm.ThreatType.Severity, ttm.Strength) { Tag = ttm }; UpdateMitigationLevel(ttm.ThreatType, row); for (int i = 0; i < row.Cells.Count; i++) { row.Cells[i].PropertyChanged += OnThreatTypeCellChanged; } panel.Rows.Add(row); ((INotifyPropertyChanged)ttm).PropertyChanged += OnThreatTypeMitigationPropertyChanged; ((INotifyPropertyChanged)ttm.ThreatType).PropertyChanged += OnThreatTypePropertyChanged; }
private GridRow GetRow([NotNull] IThreatTypeMitigation threatTypeMitigation) { GridRow result = null; var rows = _grid.PrimaryGrid.Rows.OfType <GridRow>().ToArray(); foreach (var row in rows) { var panel = row.Rows.OfType <GridPanel>() .FirstOrDefault(x => string.CompareOrdinal("ThreatTypes", x.Name) == 0); var current = panel?.Rows.OfType <GridRow>().FirstOrDefault(x => (x.Tag is IThreatTypeMitigation ttm) && (ttm == threatTypeMitigation)); if (current != null) { result = current; break; } } return(result); }
private void _ok_Click(object sender, EventArgs e) { if (_associateExisting.Checked) { if (_existingMitigation.SelectedItem is IMitigation mitigation && _strengthExisting.SelectedItem != null) { _mitigation = _threatType.AddMitigation(mitigation, _strengthExisting.SelectedItem as IStrength); } } else if (_createNew.Checked) { if (Enum.TryParse <SecurityControlType>((string)_controlType.SelectedItem, out var controlType) && _strength.SelectedItem != null) { var newMitigation = _threatType.Model.AddMitigation(_name.Text); newMitigation.Description = _description.Text; newMitigation.ControlType = controlType; _mitigation = _threatType.AddMitigation(newMitigation, _strength.SelectedItem as IStrength); } } }
public bool Execute(IThreatTypeMitigation mitigation) { bool result = false; if (MessageBox.Show(Form.ActiveForm, $"You are about to disassociate Mitigation '{mitigation.Mitigation.Name}'. Are you sure?", "Remove Mitigation association", MessageBoxButtons.YesNo, MessageBoxIcon.Warning, MessageBoxDefaultButton.Button2) == DialogResult.Yes) { if (mitigation.ThreatType.RemoveMitigation(mitigation.MitigationId)) { result = true; ShowMessage?.Invoke("Mitigation disassociated successfully."); } else { ShowWarning?.Invoke("The Mitigation association cannot be removed."); } } return(result); }
private void ThreatTypeMitigationRemoved([NotNull] IThreatTypeMitigationsContainer container, [NotNull] IThreatTypeMitigation threatTypeMitigation) { var row = GetRow(threatTypeMitigation); if (row != null) { RemoveEventSubscriptions(row); row.GridPanel.Rows.Remove(row); } }
private void Update(IThreatTypeMitigationsContainer arg1, IThreatTypeMitigation arg2) { UpdateInfo?.Invoke(this.GetExtensionId(), CurrentStatus); }
public static MitigationSelectionRule GetRule([NotNull] IThreatTypeMitigation threatTypeMitigation) { return(threatTypeMitigation.GetRule(threatTypeMitigation.Model) as MitigationSelectionRule); }
public bool Execute(IThreatTypeMitigation mitigation) { return(mitigation != null && Execute(mitigation as IPropertiesContainer)); }
private void OnThreatTypeMitigationRemoved(IThreatTypeMitigationsContainer container, IThreatTypeMitigation mitigation) { if (container is IThreatType threatType) { var row = GetRow(threatType); var panel = row?.Rows.OfType <GridPanel>().FirstOrDefault(x => string.CompareOrdinal(x.Name, "Mitigations") == 0); var scenarioRow = panel?.Rows.OfType <GridRow>() .FirstOrDefault(x => (x.Tag is IThreatTypeMitigation typeMitigation) && typeMitigation == mitigation); if (scenarioRow != null) { panel.Rows.Remove(scenarioRow); if (panel.Rows.Count == 0) { row.Rows.Remove(panel); } UpdateMitigationLevel(threatType, row); } } }
private void OnThreatTypeMitigationAdded(IThreatTypeMitigationsContainer container, IThreatTypeMitigation mitigation) { if (container is IThreatType threatType) { var filterSpecial = EnumExtensions.GetEnumValue <ThreatTypeListFilter>((string)_specialFilter.SelectedItem); if (IsSelected(threatType, _filter.Text, filterSpecial)) { var row = GetRow(threatType); if (row == null) { row = AddGridRow(threatType, _grid.PrimaryGrid); } var scenarioPanel = row.Rows.OfType <GridPanel>() .FirstOrDefault(x => string.CompareOrdinal(x.Name, "Mitigations") == 0); if (scenarioPanel != null) { AddGridRow(mitigation, scenarioPanel); } else { scenarioPanel = CreateMitigationsPanel(threatType); if (scenarioPanel != null) { row.Rows.Add(scenarioPanel); } } UpdateMitigationLevel(threatType, row); } } }
private void ThreatTypeMitigationAdded([NotNull] IThreatTypeMitigationsContainer container, [NotNull] IThreatTypeMitigation threatTypeMitigation) { var row = GetRow(threatTypeMitigation); if (row == null) { var mitigationRow = GetRow(threatTypeMitigation.Mitigation); if (mitigationRow != null) { var panel = mitigationRow.Rows.OfType <GridPanel>() .FirstOrDefault(x => string.CompareOrdinal("ThreatTypes", x.Name) == 0); AddGridRow(threatTypeMitigation, panel); } } }
public bool Execute(IThreatTypeMitigation identity) { throw new NotImplementedException(); }