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);
}
