Gui neu angelegt

StammGenerator/ViewModel/BaseViewModel.cs

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

StammGenerator/ViewModel/Factories/MainWindowViewModelFactory.cs

@@ -0,0 +1,57 @@
+using StammGenerator;
+using StammGenerator.Enum;
+using StammGenerator.Interface;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace StammGenerator.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();
+            }
+        }
+    }
+}

StammGenerator/ViewModel/Haltung/HaltungEditViewModel.cs

@@ -0,0 +1,209 @@
+using SewerStammGen.Shared.Contracts;
+using SewerStammGen.Shared.Domain;
+using SewerStammGen.Shared.Enum;
+using StammGenerator.Commands;
+using StammGenerator.Interface;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Windows.Input;
+
+namespace StammGenerator.ViewModel
+{
+    internal class HaltungEditViewModel : BaseViewModel
+    {
+        private readonly IActualState _actualState;
+        private readonly IHaltungDataService _haltungDataService;
+        private readonly ISchachtDataService _schachtDataService;
+        private List<Schacht> avaibleSchaechte;
+        private int _selectedObenIndex;
+        private int _selectedUntenIndex;
+        private Kanal _model;
+
+        public List<Schacht> AvSchaechte
+        {
+            get
+            {
+                return avaibleSchaechte;
+            }
+        }
+
+        public EEntwaeserung Entwaeserung
+        {
+            get => _model.Entwaesserung;
+            set
+            {
+                if(_model.Entwaesserung  != value)
+                {
+                    _model.Entwaesserung = value;
+                    OnPropertyChanged();
+                }
+            }
+        }
+        
+
+        public int SelectedObenIndex
+        {
+            get => _selectedObenIndex;
+            set
+            {
+                if (_selectedObenIndex != value)
+                {
+                    _selectedObenIndex = value;
+                    _model.StartSchacht = avaibleSchaechte[value];
+                    RecalculateLength();
+                    OnPropertyChanged();
+                }
+            }
+        }
+        public int SelectedUntenIndex
+        {
+            get => _selectedUntenIndex;
+            set
+            {
+                if (_selectedUntenIndex != value)
+                {
+                    _selectedUntenIndex = value;
+                    _model.EndSchacht = avaibleSchaechte[value];
+                    RecalculateLength();
+                    OnPropertyChanged();
+                }
+            }
+        }
+
+        
+
+        public Kanal Model
+        {
+            get => _model;
+            set
+            {
+                _model = value;
+            }
+        }
+
+        
+        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 ICommand Abbrechen { get; set; }
+
+        public HaltungEditViewModel(
+            IHaltungDataService haltungDataService,
+            IActualState actualState,
+            IRenavigator renavigator,
+            ISchachtDataService schachtDataService)
+        {
+            _actualState = actualState;
+            _haltungDataService = haltungDataService;
+            _schachtDataService = schachtDataService;
+
+
+
+            _model = _actualState.SelectedHaltung;
+            
+            Speichern = new HaltungEditSaveCommand(_haltungDataService, renavigator, this);
+            Abbrechen = new RelayCommand((x) => Abbruch(renavigator));
+
+            ladeVerfuegbareSchaechte();
+
+
+
+        }
+
+        private void RecalculateLength()
+        {
+
+            double x1 = (double)Model.StartSchacht.DeckelRechtsWert;
+            double x2 = (double)Model.EndSchacht.DeckelRechtsWert;
+            double y1 = (double)Model.StartSchacht.DeckelHochWert;
+            double y2 = (double)Model.EndSchacht.DeckelHochWert;
+
+
+            double length = Math.Sqrt(((x1 - x2) * (x1 - x2)) + ((y1 - y2) * (y1 - y2)));
+            Haltungslaenge = length.ToString();
+            OnPropertyChanged(nameof(Haltungslaenge));
+        }
+
+        private void Abbruch(IRenavigator renavigator)
+        {
+            renavigator.Renavigate();
+        }
+
+        private async void ladeVerfuegbareSchaechte()
+        {
+            var s = await _schachtDataService.GetAllByProjekt(_actualState.ProjektID);
+            avaibleSchaechte = s.ToList();
+            int counter = 0;
+            foreach (var d in avaibleSchaechte)
+            {
+                if (d.Id == Model.StartSchacht.Id)
+                {
+                    SelectedObenIndex = counter;
+                    break;
+                }
+                counter++;
+            }
+            counter = 0;
+            foreach (var d in avaibleSchaechte)
+            {
+                if (d.Id == Model.EndSchacht.Id)
+                {
+                    SelectedUntenIndex = counter;
+                    break;
+                }
+                counter++;
+            }
+            OnPropertyChanged(nameof(AvSchaechte));
+            OnPropertyChanged(nameof(SelectedObenIndex));
+            OnPropertyChanged(nameof(SelectedUntenIndex));
+        }
+    }
+}

StammGenerator/ViewModel/Haltung/HaltungListViewModel.cs

@@ -0,0 +1,55 @@
+using SewerStammGen.Shared.Contracts;
+using SewerStammGen.Shared.Domain;
+using StammGenerator.Commands;
+using StammGenerator.Interface;
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
+using System.Windows.Input;
+
+namespace StammGenerator.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 ICommand ExportCommand { get; set; }
+
+        public HaltungListViewModel(IHaltungDataService haltungDataService, IActualState actualState, IRenavigator renavigator )
+        {
+            _haltungen = new ObservableCollection<Kanal>();
+            _haltungDataService = haltungDataService;
+
+            _actualState = actualState;
+            
+
+            EditCommand = new HaltungEditCommand(actualState, renavigator, this);
+            AddCommand = new HaltungAddCommand(actualState, renavigator);
+            ExportCommand = new ProjectExportCommand(actualState);
+
+            LoadHaltungen();
+        }
+
+        private async void LoadHaltungen()
+        {
+            var haltungen = await _haltungDataService.GetAllByProjekt(_actualState.ProjektID);
+            InitCollection(_haltungen, haltungen);
+           
+        }
+
+        private void InitCollection(ObservableCollection<Kanal> dest, IEnumerable<Kanal> source)
+        {
+            dest.Clear();
+            foreach (var sourceItem in source)
+            {
+                dest.Add(sourceItem);
+            }
+        }
+    }
+}

StammGenerator/ViewModel/Haltung/TextBoxFilterAction.cs

@@ -0,0 +1,20 @@
+//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 StammGenerator.Views
+{
+    /*
+    public class TextBoxFilterAction : TargetedTriggerAction<SfMultiColumnDropDownControl>
+    {
+        protected override void Invoke(object parameter)
+        {
+            throw new NotImplementedException();
+        }
+    }
+    */
+}

StammGenerator/ViewModel/HomeViewModel.cs

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

StammGenerator/ViewModel/MainWindowViewModel.cs

@@ -0,0 +1,70 @@
+
+using StammGenerator.Enum;
+
+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.Shared.Domain;
+using StammGenerator.Interface;
+using StammGenerator.Commands;
+
+namespace StammGenerator.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.SetProjekt(new Projekt() { Id = 5 });
+#endif
+        }
+
+        private void ActualState_ProjektChanged(object? sender, EventArgs e)
+        {
+            Projektnummer = _actualState.ProjektID.ToString();
+            OnPropertyChanged(nameof(Projektnummer));
+        }
+
+        private void Navigator_StateChanged()
+        {
+            OnPropertyChanged(nameof(CurrentViewModel));
+        }
+    }
+}

StammGenerator/ViewModel/ObservableObject.cs

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

StammGenerator/ViewModel/Projekt/ProjektEditViewModel.cs

@@ -0,0 +1,102 @@
+using SewerStammGen.Shared.Domain;
+using Shared.Contracts;
+using StammGenerator.Interface;
+using System.Windows.Input;
+
+namespace StammGenerator.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()
+        {
+            _dataService.Update(_model);
+
+            _renavigator.Renavigate();
+        }
+    }
+}

StammGenerator/ViewModel/Projekt/ProjektListViewModel.cs

@@ -0,0 +1,72 @@
+using SewerStammGen.Shared.Contracts;
+using SewerStammGen.Shared.Domain;
+using StammGenerator.Commands;
+using StammGenerator.Interface;
+using System;
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
+using System.Windows.Input;
+
+namespace StammGenerator.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);
+            }
+        }
+    }
+}

StammGenerator/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 StammGenerator.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
+    }
+}

StammGenerator/ViewModel/Schacht/ManholeEditViewModel.cs

@@ -0,0 +1,146 @@
+using SewerStammGen.Shared.Contracts;
+using SewerStammGen.Shared.Domain;
+using SewerStammGen.Shared.Enum;
+using StammGenerator.Interface;
+using System.Windows.Input;
+
+namespace StammGenerator.ViewModel
+{
+    public class ManholeEditViewModel : BaseViewModel
+    {
+        private readonly ISchachtDataService _schachtDataService;
+        private readonly IRenavigator _renavigator;
+
+        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 DeckelRechtsWert
+        {
+            get => _model.DeckelRechtsWert;
+            set
+            {
+                if(_model.DeckelRechtsWert  != value)
+                {
+                    _model.DeckelRechtsWert = value;
+                    OnPropertyChanged();
+                }
+            }
+        }
+        public decimal DeckelHochWert
+        {
+            get => _model.DeckelHochWert; set
+            {
+                if (_model.DeckelHochWert != value)
+                {
+                    _model.DeckelHochWert = value;
+                    OnPropertyChanged();
+                }
+            }
+        }
+        public decimal DeckelHoehe
+        {
+            get => _model.DeckelHoehe;
+            set
+            {
+                if (_model.DeckelHoehe != value)
+                {
+                    _model.DeckelHoehe = value;
+                    OnPropertyChanged();
+                }
+            }
+        }
+        public decimal SohlHochWert
+        {
+            get => _model.SohlHochWert;
+            set
+            {
+                if(_model.SohlHochWert != value)
+                {
+                    _model.SohlHochWert = value;
+                    OnPropertyChanged();
+                }
+            }
+        }
+        public decimal SohlRechtsWert
+        {
+            get => _model.SohlRechtsWert;
+            set
+            {
+                if(_model.SohlRechtsWert != value)
+                {
+                    _model.SohlRechtsWert = 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(ISchachtDataService schachtDataService,IActualState actualState, IRenavigator renavigator)
+        {
+            _schachtDataService = schachtDataService;
+            _model = actualState.SelectedSchacht;
+            _renavigator = renavigator;
+
+            Speichern = new RelayCommand((x) => SaveSchacht());
+
+        }
+
+        public ManholeEditViewModel()
+        {
+            
+        }
+
+        private async void SaveSchacht()
+        {
+            if (_model.Id == 0)
+            {
+                await _schachtDataService.Create(_model);
+            }
+            else
+            {
+               await _schachtDataService.Update(_model);
+            }
+            _renavigator.Renavigate();
+        }
+    }
+}

StammGenerator/ViewModel/Schacht/ManholeImportViewModel.cs

@@ -0,0 +1,62 @@
+using SewerStammGen.Shared.Contracts;
+using SewerStammGen.Shared.Domain;
+using SewerStammGen.Shared.Enum;
+using Shared.Contracts;
+using StammGenerator.Interface;
+using StammGenerator.Services;
+using System.Windows.Input;
+using WWTech_KanalSchnittstelle.Importer;
+
+namespace StammGenerator.ViewModel
+{
+    public class ManholeImportViewModel : BaseViewModel
+    {
+        private readonly ISchachtDataService schachtDataService;
+        private readonly IRenavigator renavigator;
+        private OpenFileDialogService fileDialogService;
+        
+        private string filename = string.Empty;
+        public string FileName
+        {
+            get => filename;
+            set
+            {
+                if (filename == value) return;
+                filename = value;
+                OnPropertyChanged();
+            }
+        }
+
+        public ICommand LoadFile { get; set; }
+        public ICommand OpenFileDialogCommand { get; set; }
+
+        private readonly IImport importer;
+
+        public ManholeImportViewModel(ISchachtDataService schachtDataService, IRenavigator renavigator, IActualState actualState)
+        {
+#if DEBUG
+            FileName = @"C:\Users\damia\source\repos\Stammdatengenerator\Beispieldaten\Koordinatendatei.csv";
+#endif
+            LoadFile = new RelayCommand((x) => importFile());
+            this.schachtDataService = schachtDataService;
+
+            importer = new CSVImporter(actualState.ProjektID);
+            this.renavigator = renavigator;
+            this.fileDialogService = new OpenFileDialogService();
+            this.OpenFileDialogCommand = new RelayCommand((x) =>
+            {
+                FileName = fileDialogService.OpenFileDialog();
+            });
+        }
+
+        private async void importFile()
+        {
+            var schaechte = importer.LoadSchaechte(FileName, EEntwaeserung.Mischwasser);
+            if (schaechte != null)
+            {
+               await schachtDataService.InsertSchachtBulk(schaechte);
+            }
+            renavigator.Renavigate();
+        }
+    }
+}

StammGenerator/ViewModel/Schacht/ManholeListViewModel.cs

@@ -0,0 +1,64 @@
+using SewerStammGen.Shared.Contracts;
+using SewerStammGen.Shared.Domain;
+using StammGenerator.Commands;
+using StammGenerator.Interface;
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
+using System.Windows.Input;
+
+namespace StammGenerator.ViewModel
+{
+    public class ManholeListViewModel : BaseViewModel
+    {
+        private readonly ISchachtDataService _schachtDataService;
+        private readonly ObservableCollection<Schacht> _schaechte;
+        private readonly IActualState _actualState;
+        private readonly IRenavigator renavigateToImport;
+
+        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 ICommand ImportSchachtCommand { get; set; }
+
+        
+
+        public ManholeListViewModel(ISchachtDataService schachtDataService, IRenavigator renavigator ,IActualState actualState, IRenavigator navigatetoImport)
+        {
+            _schachtDataService = schachtDataService;
+            _actualState = actualState;
+
+            _schaechte = new ObservableCollection<Schacht>();
+            renavigateToImport = navigatetoImport;
+
+            AddSchachtCommand = new SchachtAddCommand(actualState,renavigator);
+            EditSchachtCommand = new SchachtEditCommand(actualState, renavigator,this);
+            DeleteSchachtCommand = new SchachtDeleteCommand(schachtDataService, actualState, renavigator, this);
+            ImportSchachtCommand = new RelayCommand((x) =>
+            {
+                navigatetoImport.Renavigate();
+            });
+
+            
+            LoadSchaechte();
+        }
+
+        private async void LoadSchaechte()
+        {
+            var schaechte = await _schachtDataService.GetAllByProjekt(_actualState.ProjektID);
+            InitCollection(_schaechte, schaechte);
+        }
+
+        private void InitCollection(ObservableCollection<Schacht> dest, IEnumerable<Schacht> source)
+        {
+            dest.Clear();
+            foreach(var i in  source)
+            {
+                dest.Add(i);
+            }
+        }
+    }
+}

StammGenerator/ViewModel/Schacht/TestHole.cs

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

StammGenerator/ViewModel/State/ActualState.cs

@@ -0,0 +1,66 @@
+using SewerStammGen.Shared.Domain;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace StammGenerator.ViewModel
+{
+    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 Schacht SelectedSchacht { get; private set; }
+
+        public Kanal SelectedHaltung {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)
+        {
+            SelectedSchacht = schacht;
+            SchachtID = schacht.Id;
+            if(notification)
+            {
+                OnSchachtChanged();
+            }
+        }
+        public void SetHaltung(Kanal haltung, bool notification = true)
+        {
+            SelectedHaltung = haltung;
+            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());
+        }
+        
+    }
+}

StammGenerator/ViewModel/State/IActualState.cs

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

StammGenerator/ViewModel/State/Navigation/MainWindowNavigator.cs

@@ -0,0 +1,21 @@
+using StammGenerator.Interface;
+using System;
+
+namespace StammGenerator.ViewModel
+{
+    internal class MainWindowNavigator : ObservableObject, IMainWindowNavigator
+    {
+        private BaseViewModel _currentViewModel = new BaseViewModel();
+        public BaseViewModel CurrentViewModel
+        {
+            get => _currentViewModel;
+            set
+            {
+                _currentViewModel?.Dispose();
+                _currentViewModel = value;
+                StateChanged?.Invoke();
+            }
+        }
+        public event Action StateChanged;
+    }
+}

StammGenerator/ViewModel/State/Navigation/ViewModelDelegateRenavigator.cs

@@ -0,0 +1,20 @@
+using StammGenerator.Interface;
+
+namespace StammGenerator.ViewModel
+{
+    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();
+        }
+    }
+}