MainWindowViewModel_22_10

using Microsoft.Data.Sqlite;
using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.ComponentModel;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Data;
using MVVM_Adressdatenbank.Entities;

namespace MVVM_Adressdatenbank
{
    class MainWindowViewModel : NotifyableBaseObject
    {

        public MainWindowViewModel()
        {
            this.Abfrage = new DelegateCommand(
                (o) => string.IsNullOrWhiteSpace(PersData.Vorname),
                (o) => { NeuerDatensatz = false; Personendatenliste.Clear(); Datenabfrage(); });
            this.Speichern = new DelegateCommand(
                (o) => { Datenspeichern(); });
            this.NeueAdresse = new DelegateCommand(
                (o) => { NeuerDatensatz = true; LoadnewData(); });

            Searchable = Personendatenliste;
            Listable = new CollectionViewSource();
            Listable.Source = this.Searchable;
            Listable.Filter += ApplyFilter;

        }


        public bool NeuerDatensatz;

        public bool ChangePersonData;

        public bool ChangeAdressData;


        public bool Anzeigeändern => NeuerDatensatz != true;
        public bool Anzeigeändern1 => NeuerDatensatz;

        #region Collection für Filter und Filter
        public ObservableCollection<PersonenDaten> Searchable { get; set; }
        internal CollectionViewSource Listable { get; set; }
        public ICollectionView GetListable { get => Listable.View; }

        private void ApplyFilter(object sender, FilterEventArgs e)
        {
            PersonenDaten search = (PersonenDaten)e.Item;
            if (string.IsNullOrEmpty(this.Filter) || this.Filter.Length == 0)
            { e.Accepted = true; }
            else
            {
                e.Accepted = search.Fullname.Contains(Filter);
                RaisePropertyChanged();
            }


        }

        private string filter;
        public string Filter
        {
            get => this.filter;
            set
            {
                if (value != filter)
                {
                    this.filter = value;
                    //RaisePropertyChanged();
                    Listable.View.Refresh();
                    RaisePropertyChanged(nameof(Filter));
                }
            }
        }
        #endregion

        #region Colections für Binding und Zugehörige Listen
        private ObservableCollection<PersonenDaten> personendatenliste = new ObservableCollection<PersonenDaten>();
        public ObservableCollection<PersonenDaten> Personendatenliste
        {
            get => personendatenliste;
            set
            {
                if (value != personendatenliste)
                {
                    personendatenliste = value;
                    RaisePropertyChanged();

                }
            }
        }
        private ObservableCollection<Adressdaten> adressDatenliste = new ObservableCollection<Adressdaten>();
        public ObservableCollection<Adressdaten> Adressdatenliste
        {
            get => adressDatenliste;
            set
            {
                if (value != adressDatenliste)
                {
                    adressDatenliste = value;
                    RaisePropertyChanged();
                }
            }
        }

        private ObservableCollection<MailDaten> maildataliste = new ObservableCollection<MailDaten>();
        public ObservableCollection<MailDaten> Maildataliste
        {
            get => maildataliste;
            set
            {
                if (value != maildataliste)
                {
                    maildataliste = value;
                    RaisePropertyChanged();
                }
            }
        }

        private ObservableCollection<TelefonDaten> kontaktdatenliste = new ObservableCollection<TelefonDaten>();
        public ObservableCollection<TelefonDaten> Kontaktdatenliste
        {
            get => kontaktdatenliste;
            set
            {
                if (value != kontaktdatenliste)
                {
                    kontaktdatenliste = value;
                    RaisePropertyChanged();

                }
            }
        }

        private ObservableCollection<Adresstypen> adresstypenliste = new();
        public ObservableCollection<Adresstypen> Adresstypenliste
        {
            get => adresstypenliste;
            set
            {
                if (value != adresstypenliste)
                {
                    adresstypenliste = value;
                    RaisePropertyChanged();
                }
            }
        }

        private ObservableCollection<Mailtypen> mailtypliste = new();
        public ObservableCollection<Mailtypen> Mailtypliste
        {
            get => mailtypliste;
            set
            {
                if (value != mailtypliste)
                {
                    mailtypliste = value;
                    RaisePropertyChanged();
                }
            }
        }

        private ObservableCollection<Telefontypen> teltypliste = new();
        public ObservableCollection<Telefontypen> Teltypliste
        {
            get => teltypliste;
            set
            {
                if (value != teltypliste)
                {
                    teltypliste = value;
                    RaisePropertyChanged();
                }
            }
        }

        TelefonDaten kontData = new TelefonDaten();
        public TelefonDaten KontData
        {
            get => kontData;
            set
            {
                if (value != kontData)
                {
                    kontData = value;
                    RaisePropertyChanged();
                }
            }
        }

        /// <summary>
        /// Select a single Name and get more information about it.
        /// Clear the ObservableCollections for Adress, Telefon and Mail
        /// </summary>
        private PersonenDaten persData = new PersonenDaten();
        public PersonenDaten PersData
        {
            get => persData;
            set
            {

                if (value != persData && !NeuerDatensatz)
                {
                    persData = value;
                    RaisePropertyChanged();
                    ChangePersonData = true;
                    Adressdatenliste.Clear();
                    Adresstypenliste.Clear();
                    Mailtypliste.Clear();
                    Teltypliste.Clear();
                    Adresstypenabfrage();
                    Telefontypabfrage();
                    Mailtypabfrage();
                    Adressabfrage(PersData.ID);
                    Kontaktdatenliste.Clear();
                    KontaktDatenabfrage(PersData.ID);
                    Maildataliste.Clear();
                    MailAdressDatenabfrage(PersData.ID);
                    this.Abfrage.RaiseCanExecuteChanged();
                }

            }

        }
        PersonenDaten neuePerson;
        public PersonenDaten NeuePerson
        {
            get => neuePerson;
            set
            {
                neuePerson = value;
                RaisePropertyChanged();

            }
        }

        private Adressdaten addData = new Adressdaten();
        public Adressdaten AddData
        {
            get => addData;
            set
            {
                if (value != addData)
                {
                    addData = value;
                    AddTyp.Adresstyp = AddData.AdressTyp;
                    RaisePropertyChanged();
                    //RaisePropertyChanged(nameof(AddTyp));
                    ChangeAdressData = true;



                }
            }
        }
        public Adressdaten NeueAdresseDaten
        {
            get => addData;
            set
            {
                addData = value;
                RaisePropertyChanged();

            }
        }

        private Adresstypen addtyp = new Adresstypen();
        public Adresstypen AddTyp
        {
            get => addtyp;
            set
            {
                if (value != addtyp)
                {
                    addtyp = value;
                    AddData.AdressTyp = addtyp.Adresstyp;
                    RaisePropertyChanged();
                    RaisePropertyChanged(nameof(AddData));

                }
            }
        }

        private Telefontypen teltyp = new();
        public Telefontypen Teltyp
        {
            get => teltyp;
            set
            {
                if (value != teltyp)
                {
                    teltyp = value;
                    RaisePropertyChanged();
                }
            }
        }

        private Mailtypen mailtyp = new();
        public Mailtypen Mailtyp
        {
            get => mailtyp;
            set
            {
                if (value != mailtyp)
                {
                    mailtyp = value;
                    RaisePropertyChanged();
                }
            }
        }

        private MailDaten maildata = new();
        public MailDaten Maildata
        {
            get => maildata;
            set
            {
                if (value != maildata)
                {
                    maildata = value;
                    RaisePropertyChanged();
                }
            }
        }
        public MailDaten NeueMail
        {
            get => maildata;
            set
            {
                maildata = value;
                RaisePropertyChanged();
            }
        }

        private TelefonDaten teldata = new();
        public TelefonDaten TelData
        {
            get => teldata;
            set
            {
                if (value != teldata)
                {
                    teldata = value;
                    RaisePropertyChanged();

                }
            }
        }
        public TelefonDaten NeueNummer
        {
            get => teldata;
            set
            {
                teldata = value;
                RaisePropertyChanged();
            }
        }
        #endregion





        #region DelegateCommands
        public DelegateCommand Abfrage { get; set; }

        public DelegateCommand Speichern { get; set; }

        public DelegateCommand NeueAdresse { get; set; }
        #endregion
        public event EventHandler Safesucces;
        public event EventHandler NoSafe;

        private Datenbankzugriff zugriff = Datenbankzugriff.GetDBZugriff();


        private void LoadnewData()
        {
            RaisePropertyChanged(nameof(Anzeigeändern));
            RaisePropertyChanged(nameof(Anzeigeändern1));

            Personendatenliste.Clear();
            Adressdatenliste.Clear();
            Kontaktdatenliste.Clear();
            Maildataliste.Clear();

            Adresstypenabfrage();
            Telefontypabfrage();
            Mailtypabfrage();


        }
        /// <summary>
        /// Abfrage der Daten und zuordnung zu den ObservableCollections Personendatenliste und Kontakdatenliste
        /// </summary>

        #region Abfragemethoden
        private void Datenabfrage()
        {
            RaisePropertyChanged(nameof(Anzeigeändern));
            RaisePropertyChanged(nameof(Anzeigeändern1));
            this.NeueAdresse.RaiseCanExecuteChanged();

            SqliteConnection connect = zugriff.connect();
            //string datenabfrage = "Select ID_Person, Vorname, Nachname, Geburtsdatum, Geburtsname FROM Person";
            string datenabfrage = "Select p.ID_Person, Vorname, Nachname, Geburtsname, Geburtsdatum From Person p ";
            SqliteCommand com = new(datenabfrage, connect);

            connect.Open();
            SqliteDataReader reader = com.ExecuteReader();
            if (reader.HasRows)
                while (reader.Read())
                {
                    Personendatenliste.Add(new PersonenDaten
                    {
                        ID = reader.GetString(reader.GetOrdinal("ID_Person")),
                        Vorname = reader.GetString(reader.GetOrdinal("Vorname")),
                        Nachname = reader.GetString(reader.GetOrdinal("Nachname")),
                        Geburtsdatum = reader.GetString(reader.GetOrdinal("Geburtsdatum")),
                        Geburtsname = reader.GetString(reader.GetOrdinal("Geburtsname")),

                    });
                }


            connect.Close();
        }

        private void Adressabfrage(string identify)
        {

            string abfrage = "Select a.ID_Adresse, Straße, Hausnummer, Postleitzahl, Ort, Land, at.Typ_Name, at.ID_Adress_Typ FROM Adresse a JOIN Person_Adresse pa ON pa.ID_Adresse = a.ID_Adresse JOIN Adress_Typ at ON pa.ID_Adress_Typ = at.ID_Adress_Typ  WHERE ID_Person = @ID_Person";
            SqliteConnection connect = zugriff.connect();
            SqliteCommand com = new(abfrage, connect);

            SqliteParameter p1 = new();
            p1.ParameterName = "@ID_Person";
            p1.Value = identify;
            com.Parameters.Add(p1);

            connect.Open();
            SqliteDataReader reader = com.ExecuteReader();
            if (reader.HasRows)
            {
                while (reader.Read())
                {
                    Adressdatenliste.Add(new Adressdaten
                    {
                        ID_Adresse = reader.GetString(reader.GetOrdinal("ID_Adresse")),
                        Straße = reader.GetString(reader.GetOrdinal("Straße")),
                        Hausnummer = reader.GetString(reader.GetOrdinal("Hausnummer")),
                        Plz = reader.GetString(reader.GetOrdinal("Postleitzahl")),
                        Ort = reader.GetString(reader.GetOrdinal("Ort")),
                        Land = reader.GetString(reader.GetOrdinal("Land")),
                        AdressTyp = reader.GetString(reader.GetOrdinal("Typ_Name")),
                        ID_AdressTyp = reader.GetString(reader.GetOrdinal("ID_Adress_Typ"))
                        //Etage = reader.GetString(reader.GetOrdinal("Etage")),
                        //Abteilung = reader.GetString(reader.GetOrdinal("Abteilung")),
                        //Gebäude = reader.GetString(reader.GetOrdinal("Gebäude")),
                    });
                }
            }
        }

        private void MailAdressDatenabfrage(string identify)
        {
            SqliteConnection connect = zugriff.connect();
            string abfrage = "Select e.Mailadresse, mt.Typ_Art_Mail From  EMail e " +
                "JOIN EMail_Typ mt ON e.ID_Email_Typ = mt.ID_Email_Typ " +
                "Where e.ID_Person = @Person";
            SqliteCommand com = new(abfrage, connect);

            SqliteParameter p1 = new();
            p1.ParameterName = "@Person";
            p1.Value = identify;
            com.Parameters.Add(p1);



            connect.Open();

            SqliteDataReader reader = com.ExecuteReader();
            if (reader.HasRows)
            {
                while (reader.Read())
                {
                    Maildataliste.Add(new MailDaten
                    {
                        Mailadresse = reader.GetString(reader.GetOrdinal("Mailadresse")),
                        Mailtyp = reader.GetString(reader.GetOrdinal("Typ_Art_Mail"))
                    });
                }
            }
        }

        private void KontaktDatenabfrage(string identify)
        {
            SqliteConnection connect = zugriff.connect();
            string abfrage = "Select t.Nummer,  Typ_Art From Telefon t " +
                "JOIN Telefon_Typ tt ON t.ID_Telefon_Typ = tt.ID_Telefon_Typ " +
                "Where t.ID_Person = @Person";
            SqliteCommand com = new(abfrage, connect);

            SqliteParameter p1 = new();
            p1.ParameterName = "@Person";
            p1.Value = identify;
            com.Parameters.Add(p1);



            connect.Open();

            SqliteDataReader reader = com.ExecuteReader();
            if (reader.HasRows)
            {
                while (reader.Read())
                {
                    Kontaktdatenliste.Add(new TelefonDaten
                    {
                        Telefonnummer = reader.GetString(reader.GetOrdinal("Nummer")),
                        Nummertyp = reader.GetString(reader.GetOrdinal("Typ_Art")),

                    });
                }
            }
        }

        private void Adresstypenabfrage()
        {
            string abfrage = "Select * From Adress_Typ";
            SqliteConnection connect = zugriff.connect();
            SqliteCommand com = new(abfrage, connect);

            connect.Open();
            SqliteDataReader reader = com.ExecuteReader();

            if (reader.HasRows)
            {
                while (reader.Read())
                {
                    Adresstypenliste.Add(
                        new Adresstypen
                        {
                            Adresstyp = reader.GetString(reader.GetOrdinal("Typ_Name")),
                            ID_Adresstyp = reader.GetString(reader.GetOrdinal("ID_Adress_Typ"))
                        });
                }
            }
        }
        private void Telefontypabfrage()
        {
            string abfrage = "Select * From Telefon_Typ";
            SqliteConnection connect = zugriff.connect();
            SqliteCommand com = new(abfrage, connect);

            connect.Open();
            SqliteDataReader reader = com.ExecuteReader();

            if (reader.HasRows)
            {
                while (reader.Read())
                {
                    Teltypliste.Add(
                        new Telefontypen
                        {
                            Telefontyp = reader.GetString(reader.GetOrdinal("Typ_Art")),
                            ID_Telefontyp = reader.GetString(reader.GetOrdinal("ID_Telefon_Typ"))
                        });
                }
            }
        }

        private void Mailtypabfrage()
        {
            string abfrage = "Select * From EMail_Typ";
            SqliteConnection connect = zugriff.connect();
            SqliteCommand com = new(abfrage, connect);

            connect.Open();
            SqliteDataReader reader = com.ExecuteReader();

            if (reader.HasRows)
            {
                while (reader.Read())
                {
                    Mailtypliste.Add(
                        new Mailtypen
                        {
                            Mailtyp = reader.GetString(reader.GetOrdinal("Typ_Art_Mail")),
                            ID_Mailtyp = reader.GetString(reader.GetOrdinal("ID_Email_Typ"))
                        });
                }
            }

        }
        /// <summary>
        /// Speichern von Änderungen an Pesonendaten und Adressen
        /// </summary>
        private void Datenänderungspeichern()
        {

            string Update = "Update Person Set Vorname = @Vorname, Nachname = @Nachname, Geburtsdatum = @Geburtsdatum WHERE ID_Person = @ID_Person ";
            SqliteConnection connect = zugriff.connect();
            SqliteCommand com = new(Update, connect);

            SqliteParameter vn = new();
            vn.ParameterName = "@Vorname";
            vn.Value = PersData.Vorname;
            com.Parameters.Add(vn);

            SqliteParameter nn = new();
            nn.ParameterName = "@Nachname";
            nn.Value = PersData.Nachname;
            com.Parameters.Add(nn);

            SqliteParameter gd = new();
            gd.ParameterName = "@Geburtsdatum";
            gd.Value = PersData.Geburtsdatum;
            com.Parameters.Add(gd);

            SqliteParameter id = new();
            id.ParameterName = "@ID_Person";
            id.Value = PersData.ID;
            com.Parameters.Add(id);

            connect.Open();
            com.ExecuteNonQuery();
            connect.Close();



        }

        public void Adressänderungspeichern()
        {
            string Update = "Update Adresse Set Straße = @Str, Hausnummer = @HNr, Postleitzahl = @PLZ, Ort = @Ort, Land = @Land WHERE ID_Adresse = @ID_Adresse";
            SqliteConnection con = zugriff.connect();
            SqliteCommand com = new(Update, con);

            SqliteParameter st = new();
            st.ParameterName = "@Str";
            st.Value = AddData.Straße;
            com.Parameters.Add(st);

            SqliteParameter hn = new();
            hn.ParameterName = "@HNr";
            hn.Value = AddData.Hausnummer;
            com.Parameters.Add(hn);

            SqliteParameter pl = new();
            pl.ParameterName = "@PLZ";
            pl.Value = AddData.Plz;
            com.Parameters.Add(pl);

            SqliteParameter or = new();
            or.ParameterName = "@Ort";
            or.Value = AddData.Ort;
            com.Parameters.Add(or);

            SqliteParameter la = new();
            la.ParameterName = "@Land";
            la.Value = AddData.Land;
            com.Parameters.Add(la);

            SqliteParameter id = new();
            id.ParameterName = "@ID_Adresse";
            id.Value = AddData.ID_Adresse;
            com.Parameters.Add(id);

            con.Open();
            com.ExecuteNonQuery();
            con.Close();


        }

        public void NeuePersonSpeichern()
        {
            if (NeuePerson.Geburtsname == null)
            {
                string insert = "Insert Into Person(Vorname, Nachname, Geburtsdatum) Values(@Vorname, @Nachname, @Geburtsdatum)";
                SqliteConnection connect = zugriff.connect();
                SqliteCommand com = new(insert, connect);

                SqliteParameter vn = new();
                vn.ParameterName = "@Vorname";
                vn.Value = NeuePerson.Vorname;
                com.Parameters.Add(vn);

                SqliteParameter nn = new();
                nn.ParameterName = "@Nachname";
                nn.Value = NeuePerson.Nachname;
                com.Parameters.Add(nn);

                SqliteParameter gd = new();
                gd.ParameterName = "@Geburtsdatum";
                gd.Value = NeuePerson.Geburtsdatum;
                com.Parameters.Add(gd);

                connect.Open();
                com.ExecuteNonQuery();
                connect.Close();
            }
            else
            {
                string insert = "Insert INTO Person(Vorname, Nachname, Geburtsdatum, Geburtsname) Values(@Vorname, @Nachname, @Geburtsdatum, @Geburtsname)";
                SqliteConnection connect = zugriff.connect();
                SqliteCommand com = new(insert, connect);

                SqliteParameter vn = new();
                vn.ParameterName = "@Vorname";
                vn.Value = NeuePerson.Vorname;
                com.Parameters.Add(vn);

                SqliteParameter nn = new();
                nn.ParameterName = "@Nachname";
                nn.Value = NeuePerson.Nachname;
                com.Parameters.Add(nn);

                SqliteParameter gd = new();
                gd.ParameterName = "@Geburtsdatum";
                gd.Value = NeuePerson.Geburtsdatum;
                com.Parameters.Add(gd);

                SqliteParameter gn = new();
                gn.ParameterName = "@Geburtsname";
                gn.Value = NeuePerson.Geburtsname;
                com.Parameters.Add(gn);

                connect.Open();
                com.ExecuteNonQuery();
                connect.Close();
            }
        }

        public void NeueAdresseSpeichern()
        {
            string insert = "Insert Into Adresse(Straße, Hausnummer, Postleitzahl, Ort, Land) Values(@str, @hnr, @plz, @ort, @land)";
            SqliteConnection connect = zugriff.connect();
            SqliteCommand com = new(insert, connect);

            SqliteParameter param = new();
            param.ParameterName = "@str";
            param.Value = NeueAdresseDaten.Straße;
            com.Parameters.Add(param);

            SqliteParameter param2 = new();
            param2.ParameterName = "@hnr";
            param2.Value = NeueAdresseDaten.Hausnummer;
            com.Parameters.Add(param2);

            SqliteParameter param3 = new();
            param3.ParameterName = "@plz";
            param3.Value = NeueAdresseDaten.Plz;
            com.Parameters.Add(param3);

            SqliteParameter param4 = new();
            param4.ParameterName = "@ort";
            param4.Value = NeueAdresseDaten.Ort;
            com.Parameters.Add(param4);

            SqliteParameter param5 = new();
            param5.ParameterName = "@land";
            param5.Value = NeueAdresseDaten.Land;
            com.Parameters.Add(param5);


            connect.Open();
            com.ExecuteNonQuery();
            connect.Close();

        }
        public string ID_Person;
        public void GetIDPerson()
        {
            SqliteConnection connect = zugriff.connect();
            string abfrage = "Select ID_Person FROM Person Where ID_Person = (Select max(ID_Person) FROM Person)";

            SqliteCommand com2 = new(abfrage, connect);
            connect.Open();
            SqliteDataReader reader = com2.ExecuteReader();
            if (reader.HasRows)
            {
                while (reader.Read())
                { ID_Person = reader.GetString(reader.GetOrdinal("ID_Person")); }
            }
            connect.Close();
        }

        public string ID_Adresse { get; set; }

        public void GetIDAdress()
        {
            SqliteConnection connect = zugriff.connect();
            string abfrage = "Select ID_Adresse FROM Adresse Where ID_Adresse = (Select max(ID_Adresse) FROM Adresse)";

            SqliteCommand com2 = new(abfrage, connect);
            connect.Open();
            SqliteDataReader reader = com2.ExecuteReader();
            if (reader.HasRows)
            {
                while (reader.Read())
                { ID_Adresse = reader.GetString(reader.GetOrdinal("ID_Adresse")); }
            }
            connect.Close();

        }

        public void SchreibePersonAdresse()
        {
            SqliteConnection connect = zugriff.connect();
            string schreibedaten = "Insert into Person_Adresse(ID_Adresse, ID_Adress_Typ, ID_Person) Values(@idaddr, @id_ad_typ, @idpers)";
            SqliteCommand com3 = new(schreibedaten, connect);
            SqliteParameter p1 = new();
            p1.ParameterName = "@idpers";
            p1.Value = ID_Person;
            com3.Parameters.Add(p1);

            SqliteParameter p2 = new();
            p2.ParameterName = "@idaddr";
            p2.Value = ID_Adresse;
            com3.Parameters.Add(p2);

            SqliteParameter p3 = new();
            p3.ParameterName = "@id_ad_typ";
            p3.Value = AddTyp.ID_Adresstyp;
            com3.Parameters.Add(p3);


            connect.Open();
            com3.ExecuteNonQuery();
            connect.Close();
        }

        public void KontaktdatenSpeichern()
        {
            string InsertTel = "Insert Into Telefon(Nummer, ID_Telefon_Typ, ID_Person) Values(@Num, @id_tt, @id_p)";
            string InsertMail = "Insert INTO EMail(Mailadresse, ID_Email_Typ, ID_Person) Values(@mail, @id_et, @id_pers)";
            SqliteConnection connect = zugriff.connect();
            SqliteCommand com = new(InsertTel, connect);
            SqliteCommand com1 = new(InsertMail, connect);

            SqliteParameter num = new();
            num.ParameterName = "@Num";
            num.Value = NeueNummer.Telefonnummer;
            com.Parameters.Add(num);

            SqliteParameter id_tt = new();
            id_tt.ParameterName = "@id_tt";
            id_tt.Value = Teltyp.ID_Telefontyp;
            com.Parameters.Add(id_tt);

            SqliteParameter id_p = new();
            id_p.ParameterName = "@id_p";
            id_p.Value = ID_Person;
            com.Parameters.Add(id_p);

            SqliteParameter id_pers = new();
            id_pers.ParameterName = "@id_pers";
            id_pers.Value = ID_Person;
            com1.Parameters.Add(id_pers);

            SqliteParameter id_et = new();
            id_et.ParameterName = "@id_et";
            id_et.Value = Mailtyp.ID_Mailtyp;
            com1.Parameters.Add(id_et);

            SqliteParameter mail = new();
            mail.ParameterName = "@mail";
            mail.Value = NeueMail.Mailadresse;
            com1.Parameters.Add(mail);
            connect.Open();
            com.ExecuteNonQuery();
            com1.ExecuteNonQuery();
            connect.Close();


        }

        public void Datenspeichern()
        {
            if (NeuerDatensatz)
            {
                NeuePersonSpeichern();
                GetIDPerson();
                NeueAdresseSpeichern();
                GetIDAdress();
                SchreibePersonAdresse();
                KontaktdatenSpeichern();
                Safesucces?.Invoke(this, EventArgs.Empty);
            }
            else
            {
                if (ChangePersonData == true)
                {
                    if (ChangeAdressData == true)
                    {
                        Datenänderungspeichern();
                        Adressänderungspeichern();
                        Safesucces?.Invoke(this, EventArgs.Empty);

                    }
                    else
                    {
                        Datenänderungspeichern();
                        Safesucces?.Invoke(this, EventArgs.Empty);

                    }
                }
                else
                {
                    NoSafe?.Invoke(this, EventArgs.Empty);
                }

            }
        }

        #endregion
    }
}