avpon/StructureHelper
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

All Test Was Repaired

Browse Source
This commit is contained in:
Evgeny Redikultsev
2022-12-10 17:44:06 +05:00
parent c766227b19
commit f562cf2bce
72 changed files with 1541 additions and 398 deletions
Download Patch File Download Diff File Expand all files Collapse all files

145
Windows/ViewModels/Calculations/Calculators/ForceCalculatorViewModel.cs Normal file
View File

@@ -0,0 +1,145 @@
using StructureHelper.Infrastructure;
using StructureHelper.Infrastructure.UI.DataContexts;
using StructureHelperCommon.Infrastructures.Exceptions;
using StructureHelperCommon.Infrastructures.Strings;
using StructureHelperCommon.Models.Forces;
using StructureHelperLogics.Models.Primitives;
using StructureHelperLogics.NdmCalculations.Analyses.ByForces;
using StructureHelperLogics.NdmCalculations.Primitives;
using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Input;
namespace StructureHelper.Windows.ViewModels.Calculations.Calculators
{
public class ForceCalculatorViewModel : ViewModelBase
{
IEnumerable<INdmPrimitive> allowedPrimitives;
IEnumerable<IForceCombinationList> allowedForceCombinations;
ForceCalculator forcesCalculator;
public PrimitiveBase SelectedAllowedPrimitive { get; set; }
public PrimitiveBase SelectedPrimitive { get; set; }
public ObservableCollection<PrimitiveBase> AllowedPrimitives
{
get
{
var sourceItems = forcesCalculator.NdmPrimitives;
var rejectedItems = allowedPrimitives.Where(x => sourceItems.Contains(x));
var filteredItems = allowedPrimitives.Except(rejectedItems);
return ConvertNdmPrimitivesToPrimitiveBase(filteredItems);
}
}
public ObservableCollection<PrimitiveBase> Primitives
{
get
{
var sourceItems = forcesCalculator.NdmPrimitives;
return ConvertNdmPrimitivesToPrimitiveBase(sourceItems);
}
}
private ICommand addAllPrimitivesCommand;
private ICommand clearAllPrimitivesCommand;
private RelayCommand addSelectedPrimitiveCommand;
private RelayCommand removeSelectedPrimitive;
public ICommand AddAllPrimitivesCommand
{
get
{
return addAllPrimitivesCommand ??
(
addAllPrimitivesCommand = new RelayCommand(o =>
{
AddAllPrimitives();
OnPropertyChanged(nameof(AllowedPrimitives));
OnPropertyChanged(nameof(Primitives));
},o => allowedPrimitives.Count() > 0
));
}
}
private void AddAllPrimitives()
{
forcesCalculator.NdmPrimitives.Clear();
forcesCalculator.NdmPrimitives.AddRange(allowedPrimitives);
}
public ICommand ClearAllPrimitivesCommand
{
get
{
return clearAllPrimitivesCommand ??
(
clearAllPrimitivesCommand = new RelayCommand(o =>
{
forcesCalculator.NdmPrimitives.Clear();
OnPropertyChanged(nameof(AllowedPrimitives));
OnPropertyChanged(nameof(Primitives));
}, o => forcesCalculator.NdmPrimitives.Count > 0 ));
}
}
public ICommand AddSelectedPrimitiveCommand
{
get
{
return addSelectedPrimitiveCommand ??
(
addSelectedPrimitiveCommand = new RelayCommand(o =>
{
forcesCalculator.NdmPrimitives.Add(SelectedAllowedPrimitive.GetNdmPrimitive());
OnPropertyChanged(nameof(AllowedPrimitives));
OnPropertyChanged(nameof(Primitives));
}, o => SelectedAllowedPrimitive != null));
}
}
public RelayCommand RemoveSelectedPrimitiveCommand
{
get
{
return removeSelectedPrimitive ??
(
removeSelectedPrimitive = new RelayCommand(o =>
{
forcesCalculator.NdmPrimitives.Remove(SelectedPrimitive.GetNdmPrimitive());
OnPropertyChanged(nameof(AllowedPrimitives));
OnPropertyChanged(nameof(Primitives));
}, o => SelectedPrimitive != null));
}
}
public ForceCalculatorViewModel(IEnumerable<INdmPrimitive> _allowedPrimitives, IEnumerable<IForceCombinationList> _allowedForceCombinations, ForceCalculator _forcesCalculator)
{
allowedPrimitives = _allowedPrimitives;
allowedForceCombinations = _allowedForceCombinations;
forcesCalculator = _forcesCalculator;
}
private ObservableCollection<PrimitiveBase> ConvertNdmPrimitivesToPrimitiveBase(IEnumerable<INdmPrimitive> primitives)
{
ObservableCollection<PrimitiveBase> viewItems = new ObservableCollection<PrimitiveBase>();
foreach (var item in primitives)
{
if (item is IPointPrimitive)
{
var point = item as IPointPrimitive;
viewItems.Add(new PointViewPrimitive(point));
}
else if (item is IRectanglePrimitive)
{
var rect = item as IRectanglePrimitive;
viewItems.Add(new RectangleViewPrimitive(rect));
}
else throw new StructureHelperException(ErrorStrings.ObjectTypeIsUnknown);
}
return viewItems;
}
}
}

31
Windows/ViewModels/Forces/ForceCombinationViewModel.cs Normal file
View File

@@ -0,0 +1,31 @@
using StructureHelper.Infrastructure;
using StructureHelperCommon.Models.Forces;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace StructureHelper.Windows.ViewModels.Forces
{
public class ForceCombinationViewModel : ViewModelBase
{
IForceCombinationList combinationList;
public IDesignForceTuple SelectedTuple { get; set; }
public string Name
{
get => combinationList.Name;
set
{
combinationList.Name = value;
}
}
public IEnumerable<IDesignForceTuple> ForceTuples { get => combinationList.DesignForces; }
public ForceCombinationViewModel(IForceCombinationList combinationList)
{
this.combinationList = combinationList;
}
}
}

97
Windows/ViewModels/Materials/HeadMaterialsViewModel.cs
View File

@@ -3,8 +3,11 @@ using StructureHelper.Models.Materials;
using StructureHelper.Services.Primitives;
using StructureHelper.Windows.MainWindow;
using StructureHelperCommon.Infrastructures.Enums;
using StructureHelperCommon.Infrastructures.Settings;
using StructureHelperCommon.Models.Materials.Libraries;
using StructureHelperCommon.Services.ColorServices;
using StructureHelperLogics.Models.Materials;
using StructureHelperLogics.NdmCalculations.Primitives;
using System;
using System.Collections;
using System.Collections.Generic;
@@ -20,13 +23,14 @@ namespace StructureHelper.Windows.ViewModels.Materials
{
public class HeadMaterialsViewModel : ViewModelBase
{
IHeadMaterialRepository materialRepository;
IEnumerable<IHeadMaterial> headMaterials;
IEnumerable<ILibMaterial> libMaterials;
IHasHeadMaterials parent;
List<IHeadMaterial> headMaterials;
IHeadMaterial selectedMaterial;
ILibMaterial selectedLibMaterial;
ILibMaterialEntity selectedLibMaterial;
public ICommand AddNewConcreteMaterialCommand { get;}
public ICommand AddNewReinforcementMaterialCommand { get; }
public ICommand AddNewMaterialCommand { get; set; }
public ICommand AddElasticMaterialCommand
{
get
@@ -40,10 +44,10 @@ namespace StructureHelper.Windows.ViewModels.Materials
private void AddElasticMaterial()
{
IHeadMaterial material = new HeadMaterial() { Name = "New elastic material" };
material.HelperMaterial = new ElasticMaterial() { Modulus = 2e11d, CompressiveStrength = 4e8d, TensileStrength = 4e8d };
var material = HeadMaterialFactory.GetHeadMaterial(HeadmaterialType.Elastic200, ProgramSetting.CodeType);
material.Name = "New Elastic Material";
HeadMaterials.Add(material);
materialRepository.HeadMaterials.Add(material);
headMaterials.Add(material);
SelectedMaterial = material;
}
@@ -63,7 +67,8 @@ namespace StructureHelper.Windows.ViewModels.Materials
OnPropertyChanged(value, ref selectedMaterial);
if (!(selectedMaterial is null))
{
selectedLibMaterial = selectedMaterial.HelperMaterial as ILibMaterial;
var libMaterial = selectedMaterial.HelperMaterial as ILibMaterial;
selectedLibMaterial = libMaterial.MaterialEntity;
OnPropertyChanged(nameof(selectedLibMaterial));
}
}
@@ -79,7 +84,7 @@ namespace StructureHelper.Windows.ViewModels.Materials
}
}
public ILibMaterial SelectedLibMaterial
public ILibMaterialEntity SelectedLibMaterial
{
get
{
@@ -88,33 +93,41 @@ namespace StructureHelper.Windows.ViewModels.Materials
}
set
{
selectedMaterial.HelperMaterial = value;
var libMaterial = selectedMaterial.HelperMaterial as ILibMaterial;
libMaterial.MaterialEntity = value;
}
}
public IEnumerable<ILibMaterial> LibMaterials
public IEnumerable<ILibMaterialEntity> LibConcreteMaterials
{
get
{
//if (SelectedMaterial is null)
//{
// return null;
//}
return libMaterials;//.Where(x => x.MaterialType == (SelectedMaterial.HelperMaterial as ILibMaterial).MaterialType);
return LibMaterialPepository.GetConcreteRepository(ProgramSetting.CodeType);
}
}
public HeadMaterialsViewModel(IHeadMaterialRepository headMaterialRepository)
public IEnumerable<ILibMaterialEntity> LibReinforcementMaterials
{
materialRepository = headMaterialRepository;
headMaterials = materialRepository.HeadMaterials;
get
{
return LibMaterialPepository.GetReinforcementRepository(ProgramSetting.CodeType);
}
}
public HeadMaterialsViewModel(IHasHeadMaterials parent) : this(parent.HeadMaterials)
{
}
public HeadMaterialsViewModel(List<IHeadMaterial> _headMaterials)
{
headMaterials = _headMaterials;
HeadMaterials = new ObservableCollection<IHeadMaterial>();
foreach (var material in headMaterials)
{
HeadMaterials.Add(material);
}
libMaterials = materialRepository.LibMaterials;
AddNewMaterialCommand = new RelayCommand(o => AddNewMaterial(MaterialTypes.Reinforcement));
AddNewConcreteMaterialCommand = new RelayCommand(o => AddConcreteMaterial());
AddNewReinforcementMaterialCommand = new RelayCommand(o => AddReinforcementMaterial());
CopyHeadMaterialCommand = new RelayCommand(o => CopyMaterial(), o => !(SelectedMaterial is null));
EditColorCommand = new RelayCommand(o => EditColor(), o=> ! (SelectedMaterial is null));
DeleteMaterialCommand = new RelayCommand(o => DeleteMaterial(), o => !(SelectedMaterial is null));
@@ -124,24 +137,30 @@ namespace StructureHelper.Windows.ViewModels.Materials
{
var material = SelectedMaterial.Clone() as IHeadMaterial;
HeadMaterials.Add(material);
materialRepository.HeadMaterials.Add(material);
headMaterials.Add(material);
SelectedMaterial = material;
}
private void DeleteMaterial()
{
var mainModel = materialRepository.Parent as MainModel;
var primitivesWithMaterial = mainModel.PrimitiveRepository.Primitives.Where(x => x.HeadMaterial == SelectedMaterial);
int primitivesCount = primitivesWithMaterial.Count();
if (primitivesCount > 0)
if (parent != null)
{
MessageBox.Show("Some primitives reference to this material", "Material can not be deleted", MessageBoxButtons.OK, MessageBoxIcon.Warning);
return;
if (parent is IHasPrimitives)
{
var primitives = (parent as IHasPrimitives).Primitives;
var primitivesWithMaterial = primitives.Where(x => x.HeadMaterial == SelectedMaterial);
int primitivesCount = primitivesWithMaterial.Count();
if (primitivesCount > 0)
{
MessageBox.Show("Some primitives reference to this material", "Material can not be deleted", MessageBoxButtons.OK, MessageBoxIcon.Warning);
return;
}
}
}
var dialogResult = MessageBox.Show("Delete material?", "Please, confirm deleting", MessageBoxButtons.YesNo, MessageBoxIcon.Warning);
if (dialogResult == DialogResult.Yes)
{
materialRepository.HeadMaterials.Remove(SelectedMaterial);
headMaterials.Remove(SelectedMaterial);
HeadMaterials.Remove(SelectedMaterial);
}
}
@@ -155,13 +174,21 @@ namespace StructureHelper.Windows.ViewModels.Materials
OnPropertyChanged(nameof(selectedMaterial));
}
private void AddNewMaterial(MaterialTypes materialType)
private void AddConcreteMaterial()
{
IHeadMaterial material = new HeadMaterial() { Name = "New material" };
material.HelperMaterial = LibMaterials.Where(x => (x.MaterialType == MaterialTypes.Concrete & x.Name.Contains("40"))).First();
var material = HeadMaterialFactory.GetHeadMaterial(HeadmaterialType.Concrete40, ProgramSetting.CodeType);
material.Name = "New Concrete";
HeadMaterials.Add(material);
//headMaterials.Append(material);
materialRepository.HeadMaterials.Add(material);
headMaterials.Add(material);
SelectedMaterial = material;
}
private void AddReinforcementMaterial()
{
var material = HeadMaterialFactory.GetHeadMaterial(HeadmaterialType.Reinforecement400, ProgramSetting.CodeType);
material.Name = "New Reinforcement";
HeadMaterials.Add(material);
headMaterials.Add(material);
SelectedMaterial = material;
}
}

12
Windows/ViewModels/PrimitiveProperties/PrimitivePropertiesViewModel.cs
View File

@@ -24,8 +24,7 @@ namespace StructureHelper.Windows.ViewModels.PrimitiveProperties
public class PrimitivePropertiesViewModel : ViewModelBase, IDataErrorInfo
{
private PrimitiveBase primitive;
private IHeadMaterialRepository headMaterialRepository;
private List<IHeadMaterial> headMaterials;
private IHasHeadMaterials hasHeadMaterials;
public ICommand EditColorCommand { get; private set; }
public ICommand EditMaterialCommand { get; private set; }
@@ -228,13 +227,12 @@ namespace StructureHelper.Windows.ViewModels.PrimitiveProperties
public string Error => throw new NotImplementedException();
public PrimitivePropertiesViewModel(PrimitiveBase primitive, IHeadMaterialRepository materialRepository)
public PrimitivePropertiesViewModel(PrimitiveBase primitive, IHasHeadMaterials hasHeadMaterials)
{
this.primitive = primitive;
headMaterialRepository = materialRepository;
headMaterials = materialRepository.HeadMaterials;
this.hasHeadMaterials = hasHeadMaterials;
HeadMaterials = new ObservableCollection<IHeadMaterial>();
foreach (var material in headMaterials)
foreach (var material in hasHeadMaterials.HeadMaterials)
{
HeadMaterials.Add(material);
}
@@ -245,7 +243,7 @@ namespace StructureHelper.Windows.ViewModels.PrimitiveProperties
private void EditMaterial()
{
var wnd = new HeadMaterialsView(headMaterialRepository);
var wnd = new HeadMaterialsView(hasHeadMaterials);
wnd.ShowDialog();
}