private void CalculateAllInCalculationGroup(ClosingStructuresCalculationGroupContext context)
{
ActivityProgressDialogRunner.Run(Gui.MainWindow,
ClosingStructuresCalculationActivityFactory.CreateCalculationActivities(context.WrappedData,
context.FailureMechanism,
context.AssessmentSection));
}
public void IsEnabled_CalculationGroupWithChildren_ReturnTrue(bool hasNestedGroup, bool hasCalculation)
{
// Setup
var assessmentSection = mocks.Stub <IAssessmentSection>();
mocks.ReplayAll();
var calculationGroup = new CalculationGroup();
if (hasNestedGroup)
{
calculationGroup.Children.Add(new CalculationGroup());
}
if (hasCalculation)
{
calculationGroup.Children.Add(new TestClosingStructuresCalculationScenario());
}
var context = new ClosingStructuresCalculationGroupContext(calculationGroup,
null,
new ClosingStructuresFailureMechanism(),
assessmentSection);
// Call
bool isEnabled = info.IsEnabled(context);
// Assert
Assert.IsTrue(isEnabled);
}
public void ParameteredConstructor_ExpectedValues(bool hasParent)
{
// Setup
var mockRepository = new MockRepository();
var assessmentSection = mockRepository.Stub <IAssessmentSection>();
mockRepository.ReplayAll();
var calculationGroup = new CalculationGroup();
var failureMechanism = new ClosingStructuresFailureMechanism();
CalculationGroup parent = hasParent ? new CalculationGroup() : null;
// Call
var groupContext = new ClosingStructuresCalculationGroupContext(calculationGroup, parent, failureMechanism, assessmentSection);
// Assert
Assert.IsInstanceOf <FailureMechanismItemContextBase <CalculationGroup, ClosingStructuresFailureMechanism> >(groupContext);
Assert.IsInstanceOf <ICalculationContext <CalculationGroup, ClosingStructuresFailureMechanism> >(groupContext);
Assert.AreSame(calculationGroup, groupContext.WrappedData);
Assert.AreSame(parent, groupContext.Parent);
Assert.AreSame(failureMechanism, groupContext.FailureMechanism);
Assert.AreSame(assessmentSection, groupContext.AssessmentSection);
Assert.AreSame(failureMechanism.ForeshoreProfiles, groupContext.AvailableForeshoreProfiles);
Assert.AreSame(failureMechanism.ClosingStructures, groupContext.AvailableStructures);
mockRepository.VerifyAll();
}
private static object[] CalculationGroupContextChildNodeObjects(ClosingStructuresCalculationGroupContext context)
{
var childNodeObjects = new List <object>();
foreach (ICalculationBase calculationItem in context.WrappedData.Children)
{
if (calculationItem is StructuresCalculationScenario <ClosingStructuresInput> calculation)
{
childNodeObjects.Add(new ClosingStructuresCalculationScenarioContext(calculation,
context.WrappedData,
context.FailureMechanism,
context.AssessmentSection));
}
else if (calculationItem is CalculationGroup group)
{
childNodeObjects.Add(new ClosingStructuresCalculationGroupContext(group,
context.WrappedData,
context.FailureMechanism,
context.AssessmentSection));
}
else
{
childNodeObjects.Add(calculationItem);
}
}
return(childNodeObjects.ToArray());
}
private static void CalculationGroupContextOnNodeRemoved(ClosingStructuresCalculationGroupContext context, object parentNodeData)
{
var parentGroupContext = (ClosingStructuresCalculationGroupContext)parentNodeData;
parentGroupContext.WrappedData.Children.Remove(context.WrappedData);
parentGroupContext.NotifyObservers();
}
public void CreateFileImporter_Always_ReturnFileImporter()
{
// Setup
var mocks = new MockRepository();
IAssessmentSection assessmentSection = AssessmentSectionTestHelper.CreateAssessmentSectionStub(mocks);
mocks.ReplayAll();
var context = new ClosingStructuresCalculationGroupContext(new CalculationGroup(),
null,
new ClosingStructuresFailureMechanism(),
assessmentSection);
using (var plugin = new ClosingStructuresPlugin())
{
ImportInfo info = GetImportInfo(plugin);
// Call
IFileImporter fileImporter = info.CreateFileImporter(context, "test");
// Assert
Assert.IsInstanceOf <ClosingStructuresCalculationConfigurationImporter>(fileImporter);
}
mocks.VerifyAll();
}
private static void AddCalculation(ClosingStructuresCalculationGroupContext context)
{
var calculation = new StructuresCalculationScenario <ClosingStructuresInput>
{
Name = NamingHelper.GetUniqueName(context.WrappedData.Children, RiskeerCommonDataResources.Calculation_DefaultName, c => c.Name)
};
context.WrappedData.Children.Add(calculation);
context.WrappedData.NotifyObservers();
}
private void ShowClosingStructuresSelectionDialog(ClosingStructuresCalculationGroupContext nodeData)
{
using (var dialog = new StructureSelectionDialog(Gui.MainWindow, nodeData.FailureMechanism.ClosingStructures))
{
dialog.ShowDialog();
if (dialog.SelectedItems.Any())
{
StructureCalculationConfigurationHelper.GenerateCalculations <ClosingStructure, ClosingStructuresInput>(nodeData.WrappedData, dialog.SelectedItems.Cast <ClosingStructure>());
nodeData.NotifyObservers();
}
}
}
public void AdditionalDataCheck_CalculationGroupContextWithFailureMechanismParent_ReturnsTrue()
{
// Setup
var assessmentSection = new AssessmentSectionStub();
var failureMechanism = new ClosingStructuresFailureMechanism();
var calculationGroupContext = new ClosingStructuresCalculationGroupContext(failureMechanism.CalculationsGroup,
null,
failureMechanism,
assessmentSection);
// Call
bool additionalDataCheck = info.AdditionalDataCheck(calculationGroupContext);
// Assert
Assert.IsTrue(additionalDataCheck);
}
public void GetViewData_ContextNotNull_ReturnsWrappedCalculationGroup()
{
// Setup
var assessmentSection = new AssessmentSectionStub();
var failureMechanism = new ClosingStructuresFailureMechanism();
var calculationGroup = new CalculationGroup();
var calculationGroupContext = new ClosingStructuresCalculationGroupContext(calculationGroup,
null,
failureMechanism,
assessmentSection);
// Call
object viewData = info.GetViewData(calculationGroupContext);
// Assert
Assert.AreSame(calculationGroup, viewData);
}
public void CreateFileExporter_Always_ReturnFileExporter()
{
// Setup
var assessmentSection = mocks.Stub <IAssessmentSection>();
mocks.ReplayAll();
var context = new ClosingStructuresCalculationGroupContext(new CalculationGroup(),
null,
new ClosingStructuresFailureMechanism(),
assessmentSection);
// Call
IFileExporter fileExporter = info.CreateFileExporter(context, "test");
// Assert
Assert.IsInstanceOf <ClosingStructuresCalculationConfigurationExporter>(fileExporter);
}
public void IsEnabled_CalculationGroupNoChildren_ReturnFalse()
{
// Setup
var assessmentSection = mocks.Stub <IAssessmentSection>();
mocks.ReplayAll();
var context = new ClosingStructuresCalculationGroupContext(new CalculationGroup(),
null,
new ClosingStructuresFailureMechanism(),
assessmentSection);
// Call
bool isEnabled = info.IsEnabled(context);
// Assert
Assert.IsFalse(isEnabled);
}
public void GetViewName_WithCalculationGroupContext_ReturnsCalculationGroupName()
{
// Setup
var assessmentSection = new AssessmentSectionStub();
const string calculationGroupName = "Test";
var calculationGroup = new CalculationGroup
{
Name = calculationGroupName
};
var calculationGroupContext = new ClosingStructuresCalculationGroupContext(calculationGroup,
null,
new ClosingStructuresFailureMechanism(),
assessmentSection);
// Call
string name = info.GetViewName(null, calculationGroupContext);
// Assert
Assert.AreEqual(calculationGroupName, name);
}
private StrictContextMenuItem CreateGenerateClosingStructuresCalculationsItem(ClosingStructuresCalculationGroupContext nodeData)
{
bool structuresAvailable = nodeData.FailureMechanism.ClosingStructures.Any();
string closingStructuresCalculationGroupContextToolTip = structuresAvailable
? RiskeerCommonFormsResources.Generate_Calculations_for_selected_Structures
: RiskeerCommonFormsResources.No_Structures_to_generate_Calculations_for;
return(new StrictContextMenuItem(RiskeerCommonFormsResources.CalculationGroup_Generate_calculations,
closingStructuresCalculationGroupContextToolTip,
RiskeerCommonFormsResources.GenerateScenariosIcon,
(sender, args) => ShowClosingStructuresSelectionDialog(nodeData))
{
Enabled = structuresAvailable
});
}
private static void ValidateAllInCalculationGroup(ClosingStructuresCalculationGroupContext context)
{
ValidateAll(context.WrappedData.GetCalculations().OfType <StructuresCalculation <ClosingStructuresInput> >(), context.AssessmentSection);
}
private ContextMenuStrip CalculationGroupContextContextMenuStrip(ClosingStructuresCalculationGroupContext context,
object parentData,
TreeViewControl treeViewControl)
{
CalculationGroup group = context.WrappedData;
IInquiryHelper inquiryHelper = GetInquiryHelper();
var builder = new RiskeerContextMenuBuilder(Gui.Get(context, treeViewControl));
bool isNestedGroup = parentData is ClosingStructuresCalculationGroupContext;
StructuresCalculation <ClosingStructuresInput>[] calculations = group
.GetCalculations()
.Cast <StructuresCalculation <ClosingStructuresInput> >().ToArray();
if (!isNestedGroup)
{
builder.AddOpenItem()
.AddSeparator();
}
builder.AddImportItem()
.AddExportItem()
.AddSeparator();
if (isNestedGroup)
{
builder.AddDuplicateCalculationItem(group, context)
.AddSeparator();
}
else
{
builder.AddCustomItem(CreateGenerateClosingStructuresCalculationsItem(context))
.AddSeparator();
}
builder.AddCreateCalculationGroupItem(group)
.AddCreateCalculationItem(context, AddCalculation, CalculationType.Probabilistic)
.AddSeparator();
if (isNestedGroup)
{
builder.AddRenameItem();
}
builder.AddUpdateForeshoreProfileOfCalculationsItem(calculations, inquiryHelper,
SynchronizeCalculationWithForeshoreProfileHelper.UpdateForeshoreProfileDerivedCalculationInput)
.AddCustomItem(CreateUpdateAllStructuresItem(calculations))
.AddSeparator()
.AddValidateAllCalculationsInGroupItem(
context,
ValidateAllInCalculationGroup,
EnableValidateAndCalculateMenuItemForCalculationGroup)
.AddPerformAllCalculationsInGroupItem(
context,
CalculateAllInCalculationGroup,
EnableValidateAndCalculateMenuItemForCalculationGroup)
.AddSeparator()
.AddClearAllCalculationOutputInGroupItem(group)
.AddClearIllustrationPointsOfCalculationsInGroupItem(() => IllustrationPointsHelper.HasIllustrationPoints(calculations),
CreateChangeHandler(inquiryHelper, calculations));
if (isNestedGroup)
{
builder.AddDeleteItem();
}
else
{
builder.AddRemoveAllChildrenItem();
}
return(builder.AddSeparator()
.AddCollapseAllItem()
.AddExpandAllItem()
.AddSeparator()
.AddPropertiesItem()
.Build());
}
private static string EnableValidateAndCalculateMenuItemForCalculationGroup(ClosingStructuresCalculationGroupContext context)
{
return(EnableValidateAndCalculateMenuItem(context.AssessmentSection));
}
