SewerGenerator/SewerStammGen/ViewModel/Haltung/HaltungEditViewModel.cs

using SewerStammGen.Shared.Contracts;
using SewerStammGen.WPF.ViewModel.State;
using Shared.Contracts;
using Shared.Domain;
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;

        private ObservableCollection<Schacht> _verfuegbareSchaechte;

        public ObservableCollection<Schacht> VerfuegbareSchaechte
        {
            get => _verfuegbareSchaechte;
        }
       

        public Schacht ObereSchacht
        {
            get => _model.StartSchacht;
            set
            {
                if(_model.StartSchacht != value)
                {
                    _model.StartSchacht = value;
                    OnPropertyChanged();
                }
            }
        }

        public Schacht UntereSchacht
        {
            get => _model.EndSchacht;
            set
            {
                if(_model.EndSchacht != value)
                {
                    _model.EndSchacht = 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(IHaltungDataService kanalDataService, 
            ISchachtDataService schachtDataService,
            IActualState actualState)
        {
            _actualState = actualState;
            _kanalDataService = kanalDataService;
            _verfuegbareSchaechte = new ObservableCollection<Schacht>();
            _model = new Kanal();
            Speichern = new RelayCommand((x) => SaveKanal());

            LoadModel();
            LoadSchaechte(schachtDataService);
        }

        private async void LoadSchaechte(ISchachtDataService schachtDataService)
        {
            var s = await schachtDataService.GetAll(_actualState.ProjektID);
            InitCollection(_verfuegbareSchaechte, s);
            
        }

        private void InitCollection(ObservableCollection<Schacht> dst, IEnumerable<Schacht> src)
        {
            dst.Clear();
            foreach (var srcItem in src) { 
                dst.Add(srcItem);
            }
            OnPropertyChanged(nameof(VerfuegbareSchaechte));
        }

        private void SaveKanal()
        {
            _kanalDataService.Update(_model.Id, _model);
        }
    
        private async void LoadModel()
        {
            _model = await _kanalDataService.Get(_actualState.HaltungID);
            OnPropertyChanged(nameof(ObereSchacht));
            OnPropertyChanged(nameof(UntereSchacht));
            OnPropertyChanged(nameof(Haltungslaenge));
            OnPropertyChanged(nameof(Haltungsbezeichnung));
            OnPropertyChanged(nameof(Material));
            OnPropertyChanged(nameof(Durchmesser));
        }
    }
}