protected override bool OnImport() { NotifyProgress(Resources.CalculationConfigurationImporter_ProgressText_Reading_configuration, 1, 3); ReadResult <IConfigurationItem> readResult = ReadConfiguration(); if (readResult.CriticalErrorOccurred || Canceled) { return(false); } NotifyProgress(Resources.CalculationConfigurationImporter_ProgressText_Validating_imported_data, 2, 3); var parsedCalculationItems = new List <ICalculationBase>(); foreach (IConfigurationItem readItem in readResult.Items) { if (Canceled) { return(false); } ICalculationBase parsedItem = ParseReadConfigurationItem(readItem); if (parsedItem != null) { parsedCalculationItems.Add(parsedItem); } } NotifyProgress(Resources.Importer_ProgressText_Adding_imported_data_to_FailureMechanism, 3, 3); AddItemsToModel(parsedCalculationItems); return(true); }
public void Write_ValidCalculation_ValidFile(string expectedFileName, ICalculationBase calculation) { // Setup string expectedXmlFilePath = TestHelper.GetTestDataPath( TestDataPath.Riskeer.MacroStabilityInwards.IO, Path.Combine(nameof(MacroStabilityInwardsCalculationConfigurationExporter), $"{expectedFileName}.xml")); // Call & Assert WriteAndValidate(new[] { calculation }, expectedXmlFilePath); }
protected void PerformTest(string expectedFileName, ICalculationBase calculation) { // Setup string expectedXmlFilePath = TestHelper.GetTestDataPath( TestDataPath.Riskeer.Piping.IO, Path.Combine(nameof(PipingCalculationConfigurationExporter), $"{expectedFileName}.xml")); // Call & Assert WriteAndValidate(new[] { calculation }, expectedXmlFilePath); }
public override void Execute(object draggedData, ICalculationBase calculationBase, int newPosition, TreeViewControl treeViewControl) { MoveCalculationItemToNewOwner(calculationBase, newPosition); NotifyObservers(); // Try to start a name edit action when an item with the same name was already present if (TargetCalculationGroup.Children.Except(new[] { calculationBase }).Any(c => c.Name.Equals(calculationBase.Name))) { treeViewControl.TryRenameNodeForData(draggedData); } }
private static void CalculationGroupOnDrop(object droppedData, object newParentData, object oldParentData, int position, TreeViewControl treeViewControl) { ICalculationBase calculationItem = ((ICalculationContext <ICalculationBase, ICalculatableFailureMechanism>)droppedData).WrappedData; if (calculationItem != null && oldParentData is ICalculationContext <CalculationGroup, ICalculatableFailureMechanism> originalOwnerContext && newParentData is ICalculationContext <CalculationGroup, ICalculatableFailureMechanism> targetContext) { CalculationGroup sourceCalculationGroup = originalOwnerContext.WrappedData; CalculationGroup targetCalculationGroup = targetContext.WrappedData; bool isMoveWithinSameContainer = ReferenceEquals(sourceCalculationGroup, targetCalculationGroup); DroppingCalculationInContainerStrategy dropHandler = GetDragDropStrategy(isMoveWithinSameContainer, sourceCalculationGroup, targetCalculationGroup); dropHandler.Execute(droppedData, calculationItem, position, treeViewControl); } }
/// <summary> /// Parses the read calculation group and it's children. /// </summary> /// <param name="readCalculationGroup">The calculation group to parse.</param> /// <returns>A parsed calculation group.</returns> /// <exception cref="InvalidOperationException">Thrown when the one of the children /// to parse is not valid.</exception> private CalculationGroup ParseReadCalculationGroup(CalculationGroupConfiguration readCalculationGroup) { var calculationGroup = new CalculationGroup { Name = readCalculationGroup.Name }; foreach (IConfigurationItem item in readCalculationGroup.Items) { ICalculationBase parsedItem = ParseReadConfigurationItem(item); if (parsedItem != null) { calculationGroup.Children.Add(parsedItem); } } return(calculationGroup); }
/// <summary> /// Moves the <see cref="ICalculationBase"/> instance to its new location. /// </summary> /// <param name="calculationBase">The instance to be relocated.</param> /// <param name="position">The index in the new <see cref="CalculationGroup"/> /// owner within its <see cref="CalculationGroup.Children"/>.</param> protected void MoveCalculationItemToNewOwner(ICalculationBase calculationBase, int position) { sourceCalculationGroup.Children.Remove(calculationBase); TargetCalculationGroup.Children.Insert(position, calculationBase); }
/// <summary> /// Performs the drag and drop operation. /// </summary> /// <param name="draggedData">The dragged data.</param> /// <param name="calculationBase">The calculation item wrapped by <see cref="draggedData"/>.</param> /// <param name="newPosition">The index of the new position within the new owner's collection.</param> /// <param name="treeViewControl">The tree view control in which the drag and drop operation is performed.</param> public virtual void Execute(object draggedData, ICalculationBase calculationBase, int newPosition, TreeViewControl treeViewControl) { MoveCalculationItemToNewOwner(calculationBase, newPosition); NotifyObservers(); }
private static void CreateChildElements(CalculationGroup parentGroup, CalculationGroupEntity entity, PersistenceRegistry registry) { for (var i = 0; i < parentGroup.Children.Count; i++) { ICalculationBase calculationBase = parentGroup.Children[i]; if (calculationBase is CalculationGroup childGroup) { entity.CalculationGroupEntity1.Add(childGroup.Create(registry, i)); } if (calculationBase is SemiProbabilisticPipingCalculationScenario childSemiProbabilisticPipingCalculation) { entity.SemiProbabilisticPipingCalculationEntities.Add(childSemiProbabilisticPipingCalculation.Create(registry, i)); } if (calculationBase is ProbabilisticPipingCalculationScenario childProbabilisticPipingCalculation) { entity.ProbabilisticPipingCalculationEntities.Add(childProbabilisticPipingCalculation.Create(registry, i)); } if (calculationBase is MacroStabilityInwardsCalculationScenario childMacroStabilityInwardsCalculation) { entity.MacroStabilityInwardsCalculationEntities.Add(childMacroStabilityInwardsCalculation.Create(registry, i)); } if (calculationBase is GrassCoverErosionInwardsCalculationScenario childGrassCoverErosionInwardsCalculation) { entity.GrassCoverErosionInwardsCalculationEntities.Add(childGrassCoverErosionInwardsCalculation.Create(registry, i)); } if (calculationBase is GrassCoverErosionOutwardsWaveConditionsCalculation childGrassCoverErosionOutwardsCalculation) { entity.GrassCoverErosionOutwardsWaveConditionsCalculationEntities.Add(childGrassCoverErosionOutwardsCalculation.Create(registry, i)); } if (calculationBase is StructuresCalculationScenario <HeightStructuresInput> childHeightStructuresCalculation) { entity.HeightStructuresCalculationEntities.Add(childHeightStructuresCalculation.CreateForHeightStructures(registry, i)); } if (calculationBase is StructuresCalculationScenario <ClosingStructuresInput> childClosingStructuresCalculation) { entity.ClosingStructuresCalculationEntities.Add(childClosingStructuresCalculation.CreateForClosingStructures(registry, i)); } if (calculationBase is StructuresCalculationScenario <StabilityPointStructuresInput> childStabilityPointStructuresCalculation) { entity.StabilityPointStructuresCalculationEntities.Add(childStabilityPointStructuresCalculation.CreateForStabilityPointStructures(registry, i)); } if (calculationBase is StabilityStoneCoverWaveConditionsCalculation stabilityStoneCoverWaveConditionsCalculation) { entity.StabilityStoneCoverWaveConditionsCalculationEntities.Add(stabilityStoneCoverWaveConditionsCalculation.Create(registry, i)); } if (calculationBase is WaveImpactAsphaltCoverWaveConditionsCalculation waveImpactAsphaltCoverWaveConditionsCalculation) { entity.WaveImpactAsphaltCoverWaveConditionsCalculationEntities.Add(waveImpactAsphaltCoverWaveConditionsCalculation.Create(registry, i)); } } }
/// <summary> /// Method that asserts whether <paramref name="original"/> and <paramref name="clone"/> /// are clones. /// </summary> /// <param name="original">The original object.</param> /// <param name="clone">The cloned object.</param> /// <exception cref="AssertionException">Thrown when <paramref name="original"/> and /// <paramref name="clone"/> are not clones.</exception> private static void AreClones(ICalculationBase original, ICalculationBase clone) { Assert.AreEqual(original.Name, clone.Name); }
public void GetAllChildrenRecursive_GroupWithNestedGroupsWithCalculations_ReturnAllNestedGroupsAndCalculations() { // Setup var mocks = new MockRepository(); var calculation1 = mocks.Stub <ICalculation>(); var calculation2 = mocks.Stub <ICalculation>(); var calculation3 = mocks.Stub <ICalculation>(); var calculation4 = mocks.Stub <ICalculation>(); mocks.ReplayAll(); var nestedChildGroup = new CalculationGroup { Children = { calculation3 } }; var childGroup1 = new CalculationGroup { Children = { calculation2 } }; var childGroup2 = new CalculationGroup { Children = { nestedChildGroup, calculation4 } }; var rootGroup = new CalculationGroup { Children = { calculation1, childGroup1, childGroup2 } }; var expectedChildren = new ICalculationBase[] { calculation1, calculation2, calculation3, calculation4, childGroup1, childGroup2, nestedChildGroup }; // Call IEnumerable <ICalculationBase> children = rootGroup.GetAllChildrenRecursive(); // Assert CollectionAssert.AreEquivalent(expectedChildren, children); mocks.VerifyAll(); }
public void Write_ValidCalculation_ValidFile(string expectedFileName, ICalculationBase calculation) { PerformTest(expectedFileName, calculation); }