Verzeichnisse umgeräumt

SewerStammGen.WPF/ViewModel/BaseViewModel.cs

@@ -0,0 +1,14 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace SewerStammGen.WPF.ViewModel
+{
+    public delegate TViewModel CreateViewModel<TViewModel>() where TViewModel : BaseViewModel;
+    public class BaseViewModel : ObservableObject
+    {
+        public virtual void Dispose() { }
+    }
+}

SewerStammGen.WPF/ViewModel/Factories/MainWindowViewModelFactory.cs

@@ -0,0 +1,56 @@
+using SewerStammGen.Enum;
+using SewerStammGen.WPF.Interface;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace SewerStammGen.WPF.ViewModel.Factories
+{
+    public class MainWindowViewModelFactory : IViewModelAbstractFactory
+    {
+        private CreateViewModel<HomeViewModel> _createHomeViewModel;
+        private CreateViewModel<ManholeEditViewModel> _createManholeEditViewModel;
+        private CreateViewModel<ManholeListViewModel> _createManholeListViewModel;
+        private CreateViewModel<HaltungListViewModel> _createHaltungListViewModel;
+        //private CreateViewModel<SewerConnectorViewModel> _createSewerConnectorViewModel;
+        private CreateViewModel<ProjektListViewModel> _createProjektListViewModel;
+
+        public MainWindowViewModelFactory(
+            CreateViewModel<HomeViewModel> createHomeViewModel,
+            CreateViewModel<ManholeEditViewModel> createManholeEditViewModel,
+            CreateViewModel<ManholeListViewModel> createManholeListViewModel,
+            CreateViewModel<HaltungListViewModel> createHaltungListViewModel,
+            
+            CreateViewModel<ProjektListViewModel> createProjektListViewModel
+            )
+        {
+            _createHomeViewModel = createHomeViewModel;
+            _createManholeEditViewModel = createManholeEditViewModel;
+            //_createSewerConnectorViewModel = createSewerConnectorViewModel;
+            _createProjektListViewModel = createProjektListViewModel;
+            _createManholeListViewModel = createManholeListViewModel;
+            _createHaltungListViewModel = createHaltungListViewModel;
+        }
+
+        public BaseViewModel CreateViewModel(EMainWindowViewType viewType)
+        {
+            switch(viewType)
+            {
+                case EMainWindowViewType.Home: return _createHomeViewModel();
+
+                case EMainWindowViewType.SchachtList: return _createManholeListViewModel();
+                case EMainWindowViewType.SchachtEdit: return _createManholeEditViewModel();
+
+                case EMainWindowViewType.HaltungList: return _createHaltungListViewModel();
+                //case EMainWindowViewType.SewerConnectionEdit: return _createSewerConnectorViewModel();
+
+                case EMainWindowViewType.ProjectList: return _createProjektListViewModel();
+
+                default:
+                    throw new NotImplementedException();
+            }
+        }
+    }
+}

SewerStammGen.WPF/ViewModel/Haltung/HaltungEditViewModel.cs

@@ -0,0 +1,144 @@
+using SewerStammGen.Shared.Contracts;
+using SewerStammGen.Shared.Domain;
+using SewerStammGen.WPF.Commands;
+using SewerStammGen.WPF.ViewModel.State;
+using Shared.Contracts;
+using System;
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using System.Windows.Controls;
+using System.Windows.Input;
+
+namespace SewerStammGen.WPF.ViewModel
+{
+    internal class HaltungEditViewModel : BaseViewModel
+    {
+        private readonly IActualState _actualState;
+        //private readonly IHaltungDataService _kanalDataService;
+        
+        private Kanal _model;
+
+        public Kanal Model
+        {
+            get => _model;
+            set
+            {
+                _model = value;
+            }
+        }
+    
+        public string _oberePunkt { get; set; }
+        public string _unterePunkt { get; set; }
+
+        public string ObereSchacht
+        {
+            get => _oberePunkt;
+                    
+            set
+            {
+                if (_oberePunkt != value)
+                {
+                    _oberePunkt = value;
+                    OnPropertyChanged();
+                }
+            }
+        }
+        public string UntereSchacht
+        {
+            get => _unterePunkt;
+            set
+            {
+                if (_unterePunkt != value)
+                {
+                    _unterePunkt = value;
+                    OnPropertyChanged();
+                }
+
+            }
+        }
+        
+
+        public string Haltungsbezeichnung
+        {
+            get => _model.Objektbezeichnung;
+            set
+            {
+                if(_model.Objektbezeichnung != value)
+                {
+                    _model.Objektbezeichnung = value;
+                    OnPropertyChanged();
+                }
+            }
+        }
+        public string Material
+        {
+            get => _model.Material;
+            set
+            {
+                if( _model.Material != value)
+                {
+                    _model.Material = value;
+                    OnPropertyChanged();
+                }
+            }
+        }
+        public string Durchmesser
+        {
+            get => _model.DN.ToString();
+            set
+            {
+                if(_model.DN.ToString() != value)
+                {
+                    _model.DN = int.Parse(value);
+                    OnPropertyChanged();
+                }
+            }
+        }
+        public string Haltungslaenge
+        {
+            get => _model.Haltungslaenge.ToString();
+            set
+            {
+                if(_model.Haltungslaenge.ToString() != value)
+                {
+                    _model.Haltungslaenge = decimal.Parse(value);
+                    OnPropertyChanged();
+                }
+            }
+        }
+
+        public ICommand Speichern { get; set; }
+
+        public HaltungEditViewModel(
+            
+            IActualState actualState)
+        {
+            _actualState = actualState;
+            //_kanalDataService = kanalDataService;
+            
+            _model = new Kanal();
+            Speichern = new HaltungEditSaveCommand(this);
+
+            LoadModel();
+        
+        }
+
+    
+        private async void LoadModel()
+        {
+            /*_model = await _kanalDataService.Get(_actualState.HaltungID);
+            UntereSchacht = _model.EndSchacht.Objektbezeichnung;
+            ObereSchacht = _model.StartSchacht.Objektbezeichnung;
+            OnPropertyChanged(nameof(ObereSchacht));
+            OnPropertyChanged(nameof(UntereSchacht));
+            OnPropertyChanged(nameof(Haltungslaenge));
+            OnPropertyChanged(nameof(Haltungsbezeichnung));
+            OnPropertyChanged(nameof(Material));
+            OnPropertyChanged(nameof(Durchmesser));
+            */
+        }
+    }
+}

SewerStammGen.WPF/ViewModel/Haltung/HaltungListViewModel.cs

@@ -0,0 +1,57 @@
+using SewerStammGen.Shared.Contracts;
+using SewerStammGen.Shared.Domain;
+using SewerStammGen.WPF.Commands;
+using SewerStammGen.WPF.Interface.Navigator;
+using SewerStammGen.WPF.ViewModel.State;
+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 SewerStammGen.WPF.ViewModel
+{
+    public class HaltungListViewModel : BaseViewModel
+    {
+        private readonly ObservableCollection<Kanal> _haltungen;
+        private readonly IActualState _actualState;
+        //private readonly IHaltungDataService _haltungDataService;
+        
+        public Kanal? SelectedHaltung { get; set; }
+        public ObservableCollection<Kanal> Haltungen { get => _haltungen; }
+
+        public ICommand EditCommand { get; set; }
+        public ICommand AddCommand { get; set; }
+
+        public HaltungListViewModel( IActualState actualState, IRenavigator renavigator )
+        {
+            _haltungen = new ObservableCollection<Kanal>();
+
+            _actualState = actualState;
+            
+
+            EditCommand = new HaltungEditCommand(actualState, renavigator, this);
+            AddCommand = new HaltungAddCommand();
+
+            LoadHaltungen();
+        }
+
+        private async void LoadHaltungen()
+        {
+           /* var haltungen = await _haltungDataService.GetAll(_actualState.ProjektID);
+            InitCollection(_haltungen, haltungen);
+           */
+        }
+
+        private void InitCollection(ObservableCollection<Kanal> dest, IEnumerable<Kanal> source)
+        {
+            dest.Clear();
+            foreach (var sourceItem in source)
+            {
+                dest.Add(sourceItem);
+            }
+        }
+    }
+}

SewerStammGen.WPF/ViewModel/Haltung/TextBoxFilterAction.cs

@@ -0,0 +1,18 @@
+using Microsoft.Xaml.Behaviors;
+using Syncfusion.UI.Xaml.Grid;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace SewerStammGen.WPF.Views
+{
+    public class TextBoxFilterAction : TargetedTriggerAction<SfMultiColumnDropDownControl>
+    {
+        protected override void Invoke(object parameter)
+        {
+            throw new NotImplementedException();
+        }
+    }
+}

SewerStammGen.WPF/ViewModel/HomeViewModel.cs

@@ -0,0 +1,12 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace SewerStammGen.WPF.ViewModel
+{
+    public class HomeViewModel : BaseViewModel
+    {
+    }
+}

SewerStammGen.WPF/ViewModel/MainWindowViewModel.cs

@@ -0,0 +1,67 @@
+using SewerStammGen.WPF.Commands;
+using SewerStammGen.Enum;
+using SewerStammGen.WPF.Interface;
+using SewerStammGen.WPF.Interface.Navigator;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Runtime.CompilerServices;
+using System.Text;
+using System.Threading.Tasks;
+using System.Windows.Input;
+using SewerStammGen.WPF.ViewModel.State;
+
+namespace SewerStammGen.WPF.ViewModel
+{
+    public class MainWindowViewModel : BaseViewModel
+    {
+        public IMainWindowNavigator Navigator { get; set; }
+        public string? Projektnummer { get; set; }
+        private readonly IActualState _actualState;
+        public BaseViewModel CurrentViewModel => Navigator.CurrentViewModel;
+
+        public ICommand UpdateCurrentViewModelCommand { get; }
+
+        public static string ApplicationTitle
+        {
+            get => "Stammdatengenerator Version 0.1";
+        }
+
+        public MainWindowViewModel(
+            IMainWindowNavigator navigator,
+            IViewModelAbstractFactory viewModelFactory,
+            IActualState actualState
+            
+            )
+        {
+            Navigator = navigator;
+
+            UpdateCurrentViewModelCommand = new UpdateCurrentViewModelCommand(navigator, viewModelFactory);
+            UpdateCurrentViewModelCommand.Execute(EMainWindowViewType.Home);
+
+            _actualState = actualState;
+
+            _actualState.ProjektChanged += ActualState_ProjektChanged;
+
+
+            Navigator.StateChanged += Navigator_StateChanged;
+
+
+
+#if DEBUG
+            _actualState.ProjektID = 5;
+#endif
+        }
+
+        private void ActualState_ProjektChanged(object? sender, EventArgs e)
+        {
+            Projektnummer = _actualState.ProjektID.ToString();
+            OnPropertyChanged(nameof(Projektnummer));
+        }
+
+        private void Navigator_StateChanged()
+        {
+            OnPropertyChanged(nameof(CurrentViewModel));
+        }
+    }
+}

SewerStammGen.WPF/ViewModel/ObservableObject.cs

@@ -0,0 +1,14 @@
+using System.ComponentModel;
+using System.Runtime.CompilerServices;
+
+namespace SewerStammGen.WPF.ViewModel
+{
+    public class ObservableObject : INotifyPropertyChanged
+    {
+        public event PropertyChangedEventHandler? PropertyChanged;
+        protected virtual void OnPropertyChanged([CallerMemberName] string? propertyName = null)
+        {
+            PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
+        }
+    }
+}

SewerStammGen.WPF/ViewModel/Projekt/ProjektEditViewModel.cs

@@ -0,0 +1,117 @@
+using SewerStammGen.Shared.Domain;
+using SewerStammGen.WPF.Interface.Navigator;
+using SewerStammGen.WPF.ViewModel.State;
+using Shared.Contracts;
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Linq;
+using System.Runtime.CompilerServices;
+using System.Security.RightsManagement;
+using System.Text;
+using System.Threading.Tasks;
+using System.Windows.Input;
+
+namespace SewerStammGen.WPF.ViewModel
+{
+    internal class ProjektEditViewModel : BaseViewModel
+    {
+        private Projekt _model;
+        private int ProjektID;
+        private readonly IDataService<Projekt> _dataService;
+        private readonly IRenavigator _renavigator;
+
+        public ICommand Speichern { get; set; }
+        public string ProjektName
+        {
+            get => _model.Projektname;
+            set
+            {
+                if(_model.Projektname != value)
+                {
+                    _model.Projektname = value;
+                    OnPropertyChanged();
+                }
+            }
+        }
+        public string Erstelldatum 
+        {
+            get => _model.Erstelldatum;
+            set
+            {
+                if (_model.Erstelldatum != value)
+                {
+                    _model.Erstelldatum = value;
+                    OnPropertyChanged();
+                }
+            }
+        }
+        public string Strasse
+        {
+            get => _model.Strasse;
+            set
+            {
+                if (_model.Strasse != value)
+                {
+                    _model.Strasse = value;
+                    OnPropertyChanged();
+                }
+            }
+        }
+        public string Ort
+        {
+            get => _model.Ort;
+            set
+            {
+                if (_model.Ort != value)
+                {
+                    _model.Ort = value;
+                    OnPropertyChanged();
+                }
+            }
+        }
+
+        public ProjektEditViewModel(IDataService<Projekt> dataService, IRenavigator renavigator, IActualState actualState)
+        {
+            _dataService = dataService;
+            _renavigator = renavigator;
+
+            ProjektID = actualState.ProjektID;
+
+            _model = new Projekt();
+            Speichern = new RelayCommand((x) => this.SaveProject());
+
+            LoadProjekt();
+        }
+
+        private async void LoadProjekt()
+        {
+
+            _model = await _dataService.Get(ProjektID);
+            if(_model == null)
+            {
+                _model = new Projekt()
+                {
+                    Auftraggeber = new Auftraggeber(),
+                };
+            }
+            OnPropertyChanged(nameof(ProjektName));
+            OnPropertyChanged(nameof(Erstelldatum));
+            OnPropertyChanged(nameof(Strasse));
+            OnPropertyChanged(nameof(Ort));
+        }
+
+        private void SaveProject()
+        {
+            if (_model.Id == 0) // Handelt sich um ein neuen Eintrag
+            {
+                _dataService.Create(_model);
+            }
+            else
+            {
+                _dataService.Update(_model);
+            }
+            _renavigator.Renavigate();
+        }
+    }
+}

SewerStammGen.WPF/ViewModel/Projekt/ProjektListViewModel.cs

@@ -0,0 +1,78 @@
+using SewerStammGen.Shared.Contracts;
+using SewerStammGen.Shared.Domain;
+using SewerStammGen.WPF.Commands;
+using SewerStammGen.WPF.Interface.Navigator;
+using SewerStammGen.WPF.ViewModel;
+using SewerStammGen.WPF.ViewModel.State;
+using Shared.Contracts;
+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 SewerStammGen.WPF.ViewModel
+{
+    public class ProjektListViewModel : BaseViewModel
+    {
+        private IProjektDataService genericDataService;
+        private readonly ObservableCollection<Projekt> _projekte;
+        private readonly IActualState _actualState;
+        public ObservableCollection<Projekt> Projekte {  get => _projekte; }
+        public bool CanSelectProjekt => _selectedProjekt != null;
+
+        public ICommand SelectCommand { get; set; }
+        public ICommand AddCommand { get; set; }
+        public ICommand EditCommand { get; set; }
+
+        private Projekt? _selectedProjekt;
+
+        
+
+        public Projekt? SelectedProjekt
+        {
+            get => _selectedProjekt;
+            set
+            {
+                if(_selectedProjekt != value)
+                {
+                    _selectedProjekt = value;
+                    OnPropertyChanged();
+                    OnPropertyChanged(nameof(CanSelectProjekt));
+                }
+            }
+        }
+
+        public ProjektListViewModel(IProjektDataService generic, IRenavigator renavigator,IActualState actualState)
+        {
+            _projekte = new ObservableCollection<Projekt>();
+            if (generic == null) throw new ArgumentNullException(nameof(generic));
+            this.genericDataService = generic;
+            _actualState = actualState;
+            AddCommand = new ProjektAddCommand(generic,actualState, renavigator);
+            SelectCommand = new ProjektSelectCommand(actualState,this);
+            EditCommand = new ProjektEditCommand(generic, actualState, renavigator, this);
+
+            LoadProjekte();
+        }
+
+        private async void LoadProjekte()
+        {
+            var projects = await genericDataService.GetAll();
+
+            InitCollection(_projekte, projects);
+            
+        }
+
+        private void InitCollection(ObservableCollection<Projekt> projekte, IEnumerable<Projekt> projects)
+        {
+            projekte.Clear();
+            foreach(var i in projects)
+            {
+                projekte.Add(i);
+            }
+        }
+    }
+}

SewerStammGen.WPF/ViewModel/RelayCommand.cs

@@ -0,0 +1,50 @@
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using System.Windows.Input;
+
+namespace SewerStammGen.WPF.ViewModel
+{
+    [Serializable]
+    class RelayCommand : ICommand
+    {
+        #region Fields
+        private readonly Action<object> execute;
+        private readonly Predicate<object> canExecute;
+        #endregion
+
+        #region Constructors
+        public RelayCommand(Action<object> execute) : this(execute, null) { }
+
+        public RelayCommand(Action<object> execute, Predicate<object> canExecute)
+        {
+            if (execute == null) throw new ArgumentNullException("execute");
+            this.execute = execute;
+            this.canExecute = canExecute;
+        }
+        #endregion
+
+        #region ICommand Members
+        [DebuggerStepThrough]
+        public bool CanExecute(object parameter)
+        {
+            if (canExecute == null) return true;
+            return canExecute(parameter);
+        }
+
+        public event EventHandler CanExecuteChanged
+        {
+            add { CommandManager.RequerySuggested += value; }
+            remove { CommandManager.RequerySuggested -= value; }
+        }
+
+        public void Execute(object parameter)
+        {
+            execute(parameter);
+        }
+        #endregion
+    }
+}

SewerStammGen.WPF/ViewModel/Schacht/ManholeEditViewModel.cs

@@ -0,0 +1,126 @@
+using SewerStammGen.Shared.Domain;
+using SewerStammGen.WPF.ViewModel.State;
+using Shared.Contracts;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using System.Windows.Input;
+
+namespace SewerStammGen.WPF.ViewModel
+{
+    public class ManholeEditViewModel : BaseViewModel
+    {
+        private readonly IActualState _actualState;
+        private readonly IDataService<Schacht> _schachtDataService;
+
+        private Schacht _model;
+
+        public ICommand Speichern { get; set; }
+
+        public string Objektbezeichnung
+        {
+            get
+            {
+                return _model.Objektbezeichnung;
+            }
+            set
+            {
+                if(_model.Objektbezeichnung != value)
+                {
+                    _model.Objektbezeichnung = value;
+                    OnPropertyChanged();
+                }
+            }
+        }
+        public decimal RechtsWert
+        {
+            get => _model.RechtsWert;
+            set
+            {
+                if(_model.RechtsWert  != value)
+                {
+                    _model.RechtsWert = value;
+                    OnPropertyChanged();
+                }
+            }
+        }
+        public decimal HochWert
+        {
+            get => _model.HochWert; set
+            {
+                if (_model.HochWert != value)
+                {
+                    _model.HochWert = value;
+                    OnPropertyChanged();
+                }
+            }
+        }
+        public decimal DeckelHoehe
+        {
+            get => _model.DeckelHoehe;
+            set
+            {
+                if (_model.DeckelHoehe != value)
+                {
+                    _model.DeckelHoehe = value;
+                    OnPropertyChanged();
+                }
+            }
+        }
+        public decimal SohlHoehe
+        {
+            get => _model.SohlHoehe;
+            set
+            {
+                if (_model.SohlHoehe != value)
+                {
+                    _model.SohlHoehe = value;
+                    OnPropertyChanged();
+                }
+            }
+        }
+        public EEntwaeserung Entwaeserung
+        {
+            get => _model.Entwaesserung;
+            set
+            {
+                if (_model.Entwaesserung != value)
+                {
+                    _model.Entwaesserung = value;
+                    OnPropertyChanged();
+                }
+            }
+        }
+
+        public ManholeEditViewModel(IDataService<Schacht> schachtDataService,IActualState actualState)
+        {
+            _actualState = actualState;
+            _schachtDataService = schachtDataService;
+            _model = new Schacht();
+
+            Speichern = new RelayCommand((x) => SaveSchacht());
+
+            LoadModel();
+
+            
+        }
+
+        private void SaveSchacht()
+        {
+            //_schachtDataService.Update(_model.Id, _model);
+        }
+
+        private async void LoadModel()
+        {
+            _model = await _schachtDataService.Get(_actualState.SchachtID);
+            OnPropertyChanged(nameof(Entwaeserung));
+            OnPropertyChanged(nameof(Objektbezeichnung));
+            OnPropertyChanged(nameof(HochWert));
+            OnPropertyChanged(nameof(RechtsWert));
+            OnPropertyChanged(nameof(DeckelHoehe));
+            OnPropertyChanged(nameof(SohlHoehe));
+        }
+    }
+}

SewerStammGen.WPF/ViewModel/Schacht/ManholeListViewModel.cs

@@ -0,0 +1,62 @@
+using SewerStammGen.Shared.Contracts;
+using SewerStammGen.Shared.Domain;
+using SewerStammGen.WPF.Commands;
+using SewerStammGen.WPF.Interface.Navigator;
+using SewerStammGen.WPF.ViewModel.State;
+using Shared.Contracts;
+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 SewerStammGen.WPF.ViewModel
+{
+    public class ManholeListViewModel : BaseViewModel
+    {
+        private ISchachtDataService _schachtDataService;
+        private readonly ObservableCollection<Schacht> _schaechte;
+        private readonly IActualState _actualState;
+        
+        public ObservableCollection<Schacht> Schaechte { get => _schaechte; }
+
+        public Schacht? SelectedSchacht { get; set; }
+
+        public ICommand AddSchachtCommand { get; set; }
+        public ICommand EditSchachtCommand { get; set; }
+        public ICommand DeleteSchachtCommand { get; set; }
+
+
+        public ManholeListViewModel(ISchachtDataService schachtDataService, IDataService<Projekt> projektService,IRenavigator renavigator ,IActualState actualState)
+        {
+            _schachtDataService = schachtDataService;
+            _actualState = actualState;
+
+            _schaechte = new ObservableCollection<Schacht>();
+            
+
+            AddSchachtCommand = new SchachtAddCommand(projektService, actualState,renavigator);
+            EditSchachtCommand = new SchachtEditCommand(schachtDataService, actualState, renavigator,this);
+            DeleteSchachtCommand = new SchachtDeleteCommand(schachtDataService, actualState, renavigator, this);
+
+            LoadSchaechte();
+        }
+
+        private async void LoadSchaechte()
+        {
+            //var schaechte = await _schachtDataService.GetAll(_actualState.ProjektID);
+            //InitCollection(_schaechte, schaechte);
+        }
+
+        private void InitCollection(ObservableCollection<Schacht> dest, IEnumerable<Schacht> source)
+        {
+            dest.Clear();
+            foreach(var i in  source)
+            {
+                dest.Add(i);
+            }
+        }
+    }
+}

SewerStammGen.WPF/ViewModel/State/ActualState.cs

@@ -0,0 +1,61 @@
+using SewerStammGen.Shared.Domain;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace SewerStammGen.WPF.ViewModel.State
+{
+    internal class ActualState : IActualState
+    {
+        // TODO: set auf private set setzen
+        public int ProjektID { get; set; }
+
+        public int SchachtID { get; private set; }
+        public int HaltungID { get; private set; }
+
+        public void SetProjekt(Projekt projekt, bool notification = true)
+        {
+            ProjektID = projekt.Id;
+            if(notification)
+            {
+                OnProjektChanged();
+            }
+        }
+        public void SetSchacht(Schacht schacht, bool notification = true)
+        {
+            SchachtID = schacht.Id;
+            if(notification)
+            {
+                OnSchachtChanged();
+            }
+        }
+        public void SetHaltung(Kanal haltung, bool notification = true)
+        {
+            HaltungID = haltung.Id;
+            if(notification)
+            {
+                OnHaltungChanged();
+            }
+        }
+
+
+        public event EventHandler? ProjektChanged;
+        public event EventHandler? SchachtChanged;
+        public event EventHandler? HaltungChanged;
+        private void OnProjektChanged()
+        {
+            ProjektChanged?.Invoke(this, new EventArgs());
+        }
+        private void OnSchachtChanged()
+        {
+            SchachtChanged?.Invoke(this, new EventArgs());
+        }
+        private void OnHaltungChanged()
+        {
+            HaltungChanged?.Invoke(this, new EventArgs());
+        }
+        
+    }
+}

SewerStammGen.WPF/ViewModel/State/IActualState.cs

@@ -0,0 +1,22 @@
+using SewerStammGen.Shared.Domain;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace SewerStammGen.WPF.ViewModel.State
+{
+    public interface IActualState
+    {
+        event EventHandler? ProjektChanged;
+        // TODO: ProjektID set entfernen!
+        int ProjektID { get; set; }
+        int SchachtID { get; }
+        int HaltungID { get; }
+
+        void SetProjekt(Projekt projekt, bool notification = true);
+        void SetSchacht(Schacht schacht, bool notification = true);
+        void SetHaltung(Kanal haltung, bool notification = true);
+    }
+}

SewerStammGen.WPF/ViewModel/State/Navigation/MainWindowNavigator.cs

@@ -0,0 +1,25 @@
+using SewerStammGen.WPF.Interface.Navigator;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace SewerStammGen.WPF.ViewModel.State.Navigation
+{
+    internal class MainWindowNavigator : ObservableObject, IMainWindowNavigator
+    {
+        private BaseViewModel _currentViewModel;
+        public BaseViewModel CurrentViewModel
+        {
+            get => _currentViewModel;
+            set
+            {
+                _currentViewModel?.Dispose();
+                _currentViewModel = value;
+                StateChanged?.Invoke();
+            }
+        }
+        public event Action StateChanged;
+    }
+}

SewerStammGen.WPF/ViewModel/State/Navigation/ViewModelDelegateRenavigator.cs

@@ -0,0 +1,25 @@
+using SewerStammGen.WPF.Interface.Navigator;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace SewerStammGen.WPF.ViewModel.State.Navigation
+{
+    internal class ViewModelDelegateRenavigator<TViewModel> : IRenavigator where TViewModel : BaseViewModel
+    {
+        private readonly IMainWindowNavigator _navigator;
+        private readonly CreateViewModel<TViewModel> _createViewModel;
+
+        public ViewModelDelegateRenavigator(IMainWindowNavigator navigator, CreateViewModel<TViewModel> createViewModel)
+        {
+            _navigator = navigator;
+            _createViewModel = createViewModel;
+        }
+        public void Renavigate()
+        {
+            _navigator.CurrentViewModel = _createViewModel();
+        }
+    }
+}