Nexmo

MainWindowViewModel_18_10

Oct 18th, 2021
674
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. using Microsoft.Data.Sqlite;
  2. using System;
  3. using System.Collections.Generic;
  4. using System.Collections.ObjectModel;
  5. using System.ComponentModel;
  6. using System.Linq;
  7. using System.Text;
  8. using System.Threading.Tasks;
  9. using System.Windows.Data;
  10. using MVVM_Adressdatenbank.Entities;
  11.  
  12. namespace MVVM_Adressdatenbank
  13. {
  14.     class MainWindowViewModel : NotifyableBaseObject
  15.     {
  16.  
  17.         public MainWindowViewModel()
  18.         {
  19.             this.Abfrage = new DelegateCommand(
  20.                 (o) => string.IsNullOrWhiteSpace(PersData.Vorname),
  21.                 (o) => { NeuerDatensatz = false; Personendatenliste.Clear(); Datenabfrage(); });
  22.             this.Speichern = new DelegateCommand(
  23.                 (o) => { Datenspeichern(); });
  24.             this.NeueAdresse = new DelegateCommand(
  25.                 (o) => { NeuerDatensatz = true; LoadnewData(); });
  26.  
  27.             Searchable = Personendatenliste;
  28.             Listable = new CollectionViewSource();
  29.             Listable.Source = this.Searchable;
  30.             Listable.Filter += ApplyFilter;
  31.  
  32.         }
  33.  
  34.  
  35.         public bool NeuerDatensatz;
  36.  
  37.         public bool ChangePersonData;
  38.  
  39.         public bool ChangeAdressData;
  40.  
  41.  
  42.         public bool Anzeigeändern => NeuerDatensatz != true;
  43.         public bool Anzeigeändern1 => NeuerDatensatz;
  44.  
  45.         #region Collection für Filter und Filter
  46.         public ObservableCollection<PersonenDaten> Searchable { get; set; }
  47.         internal CollectionViewSource Listable { get; set; }
  48.         public ICollectionView GetListable { get => Listable.View; }
  49.  
  50.         private void ApplyFilter(object sender, FilterEventArgs e)
  51.         {
  52.             PersonenDaten search = (PersonenDaten)e.Item;
  53.             if (string.IsNullOrEmpty(this.Filter) || this.Filter.Length == 0)
  54.             { e.Accepted = true; }
  55.             else
  56.             {
  57.                 e.Accepted = search.Fullname.Contains(Filter);
  58.                 RaisePropertyChanged();
  59.             }
  60.  
  61.  
  62.         }
  63.  
  64.         private string filter;
  65.         public string Filter
  66.         {
  67.             get => this.filter;
  68.             set
  69.             {
  70.                 if (value != filter)
  71.                 {
  72.                     this.filter = value;
  73.                     //RaisePropertyChanged();
  74.                     Listable.View.Refresh();
  75.                     RaisePropertyChanged(nameof(Filter));
  76.                 }
  77.             }
  78.         }
  79.         #endregion
  80.  
  81.         #region Colections für Binding und Zugehörige Listen
  82.         private ObservableCollection<PersonenDaten> personendatenliste = new ObservableCollection<PersonenDaten>();
  83.         public ObservableCollection<PersonenDaten> Personendatenliste
  84.         {
  85.             get => personendatenliste;
  86.             set
  87.             {
  88.                 if (value != personendatenliste)
  89.                 {
  90.                     personendatenliste = value;
  91.                     RaisePropertyChanged();
  92.  
  93.                 }
  94.             }
  95.         }
  96.         private ObservableCollection<Adressdaten> adressDatenliste = new ObservableCollection<Adressdaten>();
  97.         public ObservableCollection<Adressdaten> Adressdatenliste
  98.         {
  99.             get => adressDatenliste;
  100.             set
  101.             {
  102.                 if (value != adressDatenliste)
  103.                 {
  104.                     adressDatenliste = value;
  105.                     RaisePropertyChanged();
  106.                 }
  107.             }
  108.         }
  109.  
  110.         private ObservableCollection<MailDaten> maildataliste = new ObservableCollection<MailDaten>();
  111.         public ObservableCollection<MailDaten> Maildataliste
  112.         {
  113.             get => maildataliste;
  114.             set
  115.             {
  116.                 if (value != maildataliste)
  117.                 {
  118.                     maildataliste = value;
  119.                     RaisePropertyChanged();
  120.                 }
  121.             }
  122.         }
  123.  
  124.         private ObservableCollection<TelefonDaten> kontaktdatenliste = new ObservableCollection<TelefonDaten>();
  125.         public ObservableCollection<TelefonDaten> Kontaktdatenliste
  126.         {
  127.             get => kontaktdatenliste;
  128.             set
  129.             {
  130.                 if (value != kontaktdatenliste)
  131.                 {
  132.                     kontaktdatenliste = value;
  133.                     RaisePropertyChanged();
  134.  
  135.                 }
  136.             }
  137.         }
  138.  
  139.         private ObservableCollection<Adresstypen> adresstypenliste = new();
  140.         public ObservableCollection<Adresstypen> Adresstypenliste
  141.         {
  142.             get => adresstypenliste;
  143.             set
  144.             {
  145.                 if (value != adresstypenliste)
  146.                 {
  147.                     adresstypenliste = value;
  148.                     RaisePropertyChanged();
  149.                 }
  150.             }
  151.         }
  152.  
  153.         private ObservableCollection<Mailtypen> mailtypliste = new();
  154.         public ObservableCollection<Mailtypen> Mailtypliste
  155.         {
  156.             get => mailtypliste;
  157.             set
  158.             {
  159.                 if (value != mailtypliste)
  160.                 {
  161.                     mailtypliste = value;
  162.                     RaisePropertyChanged();
  163.                 }
  164.             }
  165.         }
  166.  
  167.         private ObservableCollection<Telefontypen> teltypliste = new();
  168.         public ObservableCollection<Telefontypen> Teltypliste
  169.         {
  170.             get => teltypliste;
  171.             set
  172.             {
  173.                 if (value != teltypliste)
  174.                 {
  175.                     teltypliste = value;
  176.                     RaisePropertyChanged();
  177.                 }
  178.             }
  179.         }
  180.  
  181.         TelefonDaten kontData = new TelefonDaten();
  182.         public TelefonDaten KontData
  183.         {
  184.             get => kontData;
  185.             set
  186.             {
  187.                 if (value != kontData)
  188.                 {
  189.                     kontData = value;
  190.                     RaisePropertyChanged();
  191.                 }
  192.             }
  193.         }
  194.  
  195.         /// <summary>
  196.         /// Select a single Name and get more information about it.
  197.         /// Clear the ObservableCollections for Adress, Telefon and Mail
  198.         /// </summary>
  199.         private PersonenDaten persData = new PersonenDaten();
  200.         public PersonenDaten PersData
  201.         {
  202.             get => persData;
  203.             set
  204.             {
  205.  
  206.                 if (value != persData && !NeuerDatensatz)
  207.                 {
  208.                     persData = value;
  209.                     RaisePropertyChanged();
  210.                     ChangePersonData = true;
  211.                     Adressdatenliste.Clear();
  212.                     Adresstypenliste.Clear();
  213.                     Mailtypliste.Clear();
  214.                     Teltypliste.Clear();
  215.                     Adresstypenabfrage();
  216.                     Telefontypabfrage();
  217.                     Mailtypabfrage();
  218.                     Adressabfrage(PersData.ID);
  219.                     Kontaktdatenliste.Clear();
  220.                     KontaktDatenabfrage(PersData.ID);
  221.                     Maildataliste.Clear();
  222.                     MailAdressDatenabfrage(PersData.ID);
  223.                     this.Abfrage.RaiseCanExecuteChanged();
  224.                 }
  225.                
  226.             }
  227.  
  228.         }
  229.         PersonenDaten neuePerson;
  230.         public PersonenDaten NeuePerson
  231.         {
  232.             get => neuePerson;
  233.             set
  234.             {
  235.                 neuePerson = value;
  236.                 RaisePropertyChanged();
  237.                
  238.             }
  239.         }
  240.  
  241.         private Adressdaten addData = new Adressdaten();
  242.         public Adressdaten AddData
  243.         {
  244.             get => addData;
  245.             set
  246.             {
  247.                 if (value != addData)
  248.                 {
  249.                     addData = value;
  250.                     RaisePropertyChanged();
  251.                     ChangeAdressData = true;
  252.  
  253.                 }
  254.             }
  255.         }
  256.         public Adressdaten NeueAdresseDaten
  257.         {
  258.             get=> addData;
  259.             set
  260.             {
  261.                 addData =value;
  262.                 RaisePropertyChanged();
  263.                
  264.             }
  265.         }
  266.  
  267.         private Adresstypen addtyp = new Adresstypen();
  268.         public Adresstypen AddTyp
  269.         {
  270.             get => addtyp;
  271.             set
  272.             {
  273.                 if (value != addtyp)
  274.                 {
  275.                     addtyp = value;
  276.                     RaisePropertyChanged();
  277.                 }
  278.             }
  279.         }
  280.  
  281.         private Telefontypen teltyp = new();
  282.         public Telefontypen Teltyp
  283.         {
  284.             get => teltyp;
  285.             set
  286.             {
  287.                 if (value != teltyp)
  288.                 {
  289.                     teltyp = value;
  290.                     RaisePropertyChanged();
  291.                 }
  292.             }
  293.         }
  294.  
  295.         private  Mailtypen mailtyp = new();
  296.         public Mailtypen Mailtyp
  297.         {
  298.             get => mailtyp;
  299.             set
  300.             {
  301.                 if (value != mailtyp)
  302.                 {
  303.                     mailtyp = value;
  304.                     RaisePropertyChanged();
  305.                 }
  306.             }
  307.         }
  308.  
  309.         private MailDaten maildata = new();
  310.         public MailDaten Maildata
  311.         {
  312.             get => maildata;
  313.             set
  314.             {
  315.                 if (value != maildata)
  316.                 {
  317.                     maildata = value;
  318.                     RaisePropertyChanged();
  319.                 }
  320.             }
  321.         }
  322.         public MailDaten NeueMail
  323.         {
  324.             get => maildata;
  325.             set
  326.             {
  327.                 maildata = value;
  328.                 RaisePropertyChanged();
  329.             }
  330.         }
  331.  
  332.         private TelefonDaten teldata = new();
  333.         public TelefonDaten TelData
  334.         {
  335.             get => teldata;
  336.             set
  337.             {
  338.                 if (value != teldata)
  339.                 {
  340.                     teldata = value;
  341.                     RaisePropertyChanged();
  342.  
  343.                 }
  344.             }
  345.         }
  346.         public TelefonDaten NeueNummer
  347.         {
  348.             get => teldata;
  349.             set
  350.             {
  351.                 teldata = value;
  352.                 RaisePropertyChanged();
  353.             }
  354.         }
  355.         #endregion
  356.  
  357.  
  358.        
  359.  
  360.  
  361.         #region DelegateCommands
  362.         public DelegateCommand Abfrage { get; set; }
  363.  
  364.         public DelegateCommand Speichern { get; set; }
  365.  
  366.         public DelegateCommand NeueAdresse { get; set; }
  367.         #endregion
  368.         public event EventHandler Safesucces;
  369.         public event EventHandler NoSafe;
  370.  
  371.         private Datenbankzugriff zugriff = Datenbankzugriff.GetDBZugriff();
  372.  
  373.  
  374.         private void LoadnewData()
  375.         {
  376.             RaisePropertyChanged(nameof(Anzeigeändern));
  377.             RaisePropertyChanged(nameof(Anzeigeändern1));
  378.  
  379.             Personendatenliste.Clear();
  380.             Adressdatenliste.Clear();
  381.             Kontaktdatenliste.Clear();
  382.             Maildataliste.Clear();
  383.  
  384.             Adresstypenabfrage();
  385.             Telefontypabfrage();
  386.             Mailtypabfrage();
  387.  
  388.            
  389.         }
  390.         /// <summary>
  391.         /// Abfrage der Daten und zuordnung zu den ObservableCollections Personendatenliste und Kontakdatenliste
  392.         /// </summary>
  393.  
  394.         #region Abfragemethoden
  395.         private void Datenabfrage()
  396.         {
  397.             RaisePropertyChanged(nameof(Anzeigeändern));
  398.             RaisePropertyChanged(nameof(Anzeigeändern1));
  399.             this.NeueAdresse.RaiseCanExecuteChanged();
  400.  
  401.             SqliteConnection connect = zugriff.connect();
  402.             //string datenabfrage = "Select ID_Person, Vorname, Nachname, Geburtsdatum, Geburtsname FROM Person";
  403.             string datenabfrage = "Select p.ID_Person, Vorname, Nachname, Geburtsname, Geburtsdatum From Person p ";
  404.             SqliteCommand com = new(datenabfrage, connect);
  405.  
  406.             connect.Open();
  407.             SqliteDataReader reader = com.ExecuteReader();
  408.             if (reader.HasRows)
  409.                 while (reader.Read())
  410.                 {
  411.                     Personendatenliste.Add(new PersonenDaten
  412.                     {
  413.                         ID = reader.GetString(reader.GetOrdinal("ID_Person")),
  414.                         Vorname = reader.GetString(reader.GetOrdinal("Vorname")),
  415.                         Nachname = reader.GetString(reader.GetOrdinal("Nachname")),
  416.                         Geburtsdatum = reader.GetString(reader.GetOrdinal("Geburtsdatum")),
  417.                         Geburtsname = reader.GetString(reader.GetOrdinal("Geburtsname")),
  418.  
  419.                     });
  420.                 }
  421.  
  422.  
  423.             connect.Close();
  424.         }
  425.  
  426.         private void Adressabfrage(string identify)
  427.         {
  428.  
  429.             string abfrage = "Select a.ID_Adresse, Straße, Hausnummer, Postleitzahl, Ort, Land, at.Typ_Name 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";
  430.             SqliteConnection connect = zugriff.connect();
  431.             SqliteCommand com = new(abfrage, connect);
  432.  
  433.             SqliteParameter p1 = new();
  434.             p1.ParameterName = "@ID_Person";
  435.             p1.Value = identify;
  436.             com.Parameters.Add(p1);
  437.  
  438.             connect.Open();
  439.             SqliteDataReader reader = com.ExecuteReader();
  440.             if (reader.HasRows)
  441.             {
  442.                 while (reader.Read())
  443.                 {
  444.                     Adressdatenliste.Add(new Adressdaten
  445.                     {
  446.                         ID_Adresse = reader.GetString(reader.GetOrdinal("ID_Adresse")),
  447.                         Straße = reader.GetString(reader.GetOrdinal("Straße")),
  448.                         Hausnummer = reader.GetString(reader.GetOrdinal("Hausnummer")),
  449.                         Plz = reader.GetString(reader.GetOrdinal("Postleitzahl")),
  450.                         Ort = reader.GetString(reader.GetOrdinal("Ort")),
  451.                         Land = reader.GetString(reader.GetOrdinal("Land")),
  452.                         AdressTyp = reader.GetString(reader.GetOrdinal("Typ_Name"))
  453.                         //Etage = reader.GetString(reader.GetOrdinal("Etage")),
  454.                         //Abteilung = reader.GetString(reader.GetOrdinal("Abteilung")),
  455.                         //Gebäude = reader.GetString(reader.GetOrdinal("Gebäude")),
  456.                     });
  457.                 }
  458.             }
  459.         }
  460.  
  461.         private void MailAdressDatenabfrage(string identify)
  462.         {
  463.             SqliteConnection connect = zugriff.connect();
  464.             string abfrage = "Select e.Mailadresse, mt.Typ_Art_Mail From  EMail e " +
  465.                 "JOIN EMail_Typ mt ON e.ID_Email_Typ = mt.ID_Email_Typ " +
  466.                 "Where e.ID_Person = @Person";
  467.             SqliteCommand com = new(abfrage, connect);
  468.  
  469.             SqliteParameter p1 = new();
  470.             p1.ParameterName = "@Person";
  471.             p1.Value = identify;
  472.             com.Parameters.Add(p1);
  473.  
  474.  
  475.  
  476.             connect.Open();
  477.  
  478.             SqliteDataReader reader = com.ExecuteReader();
  479.             if (reader.HasRows)
  480.             {
  481.                 while (reader.Read())
  482.                 {
  483.                     Maildataliste.Add(new MailDaten
  484.                     {
  485.                         Mailadresse = reader.GetString(reader.GetOrdinal("Mailadresse")),
  486.                         Mailtyp = reader.GetString(reader.GetOrdinal("Typ_Art_Mail"))
  487.                     });
  488.                 }
  489.             }
  490.         }
  491.  
  492.         private void KontaktDatenabfrage(string identify)
  493.         {
  494.             SqliteConnection connect = zugriff.connect();
  495.             string abfrage = "Select t.Nummer,  Typ_Art From Telefon t " +
  496.                 "JOIN Telefon_Typ tt ON t.ID_Telefon_Typ = tt.ID_Telefon_Typ " +
  497.                 "Where t.ID_Person = @Person";
  498.             SqliteCommand com = new(abfrage, connect);
  499.  
  500.             SqliteParameter p1 = new();
  501.             p1.ParameterName = "@Person";
  502.             p1.Value = identify;
  503.             com.Parameters.Add(p1);
  504.  
  505.  
  506.  
  507.             connect.Open();
  508.  
  509.             SqliteDataReader reader = com.ExecuteReader();
  510.             if (reader.HasRows)
  511.             {
  512.                 while (reader.Read())
  513.                 {
  514.                     Kontaktdatenliste.Add(new TelefonDaten
  515.                     {
  516.                         Telefonnummer = reader.GetString(reader.GetOrdinal("Nummer")),
  517.                         Nummertyp = reader.GetString(reader.GetOrdinal("Typ_Art")),
  518.  
  519.                     });
  520.                 }
  521.             }
  522.         }
  523.  
  524.         private void Adresstypenabfrage()
  525.         {
  526.             string abfrage = "Select * From Adress_Typ";
  527.             SqliteConnection connect = zugriff.connect();
  528.             SqliteCommand com = new(abfrage, connect);
  529.  
  530.             connect.Open();
  531.             SqliteDataReader reader = com.ExecuteReader();
  532.  
  533.             if (reader.HasRows)
  534.             {
  535.                 while (reader.Read())
  536.                 {
  537.                     Adresstypenliste.Add(
  538.                         new Adresstypen
  539.                         {
  540.                             Adresstyp = reader.GetString(reader.GetOrdinal("Typ_Name")),
  541.                             ID_Adresstyp = reader.GetString(reader.GetOrdinal("ID_Adress_Typ"))
  542.                         });
  543.                 }
  544.             }
  545.         }
  546.         private void Telefontypabfrage()
  547.         {
  548.             string abfrage = "Select * From Telefon_Typ";
  549.             SqliteConnection connect = zugriff.connect();
  550.             SqliteCommand com = new(abfrage, connect);
  551.  
  552.             connect.Open();
  553.             SqliteDataReader reader = com.ExecuteReader();
  554.  
  555.             if (reader.HasRows)
  556.             {
  557.                 while (reader.Read())
  558.                 {
  559.                     Teltypliste.Add(
  560.                         new Telefontypen
  561.                         {
  562.                             Telefontyp = reader.GetString(reader.GetOrdinal("Typ_Art")),
  563.                             ID_Telefontyp = reader.GetString(reader.GetOrdinal("ID_Telefon_Typ"))
  564.                         });
  565.                 }
  566.             }
  567.         }
  568.  
  569.         private void Mailtypabfrage()
  570.         {
  571.             string abfrage = "Select * From EMail_Typ";
  572.             SqliteConnection connect = zugriff.connect();
  573.             SqliteCommand com = new(abfrage, connect);
  574.  
  575.             connect.Open();
  576.             SqliteDataReader reader = com.ExecuteReader();
  577.  
  578.             if (reader.HasRows)
  579.             {
  580.                 while (reader.Read())
  581.                 {
  582.                     Mailtypliste.Add(
  583.                         new Mailtypen
  584.                         {
  585.                             Mailtyp = reader.GetString(reader.GetOrdinal("Typ_Art_Mail")),
  586.                             ID_Mailtyp = reader.GetString(reader.GetOrdinal("ID_Email_Typ"))
  587.                         });
  588.                 }
  589.             }
  590.  
  591.         }
  592.         /// <summary>
  593.         /// Speichern von Änderungen an Pesonendaten und Adressen
  594.         /// </summary>
  595.         private void Datenänderungspeichern()
  596.         {
  597.  
  598.             string Update = "Update Person Set Vorname = @Vorname, Nachname = @Nachname, Geburtsdatum = @Geburtsdatum WHERE ID_Person = @ID_Person ";
  599.             SqliteConnection connect = zugriff.connect();
  600.             SqliteCommand com = new(Update, connect);
  601.  
  602.             SqliteParameter vn = new();
  603.             vn.ParameterName = "@Vorname";
  604.             vn.Value = PersData.Vorname;
  605.             com.Parameters.Add(vn);
  606.  
  607.             SqliteParameter nn = new();
  608.             nn.ParameterName = "@Nachname";
  609.             nn.Value = PersData.Nachname;
  610.             com.Parameters.Add(nn);
  611.  
  612.             SqliteParameter gd = new();
  613.             gd.ParameterName = "@Geburtsdatum";
  614.             gd.Value = PersData.Geburtsdatum;
  615.             com.Parameters.Add(gd);
  616.  
  617.             SqliteParameter id = new();
  618.             id.ParameterName = "@ID_Person";
  619.             id.Value = PersData.ID;
  620.             com.Parameters.Add(id);
  621.  
  622.             connect.Open();
  623.             com.ExecuteNonQuery();
  624.             connect.Close();
  625.  
  626.  
  627.  
  628.         }
  629.  
  630.         public void Adressänderungspeichern()
  631.         {
  632.             string Update = "Update Adresse Set Straße = @Str, Hausnummer = @HNr, Postleitzahl = @PLZ, Ort = @Ort, Land = @Land WHERE ID_Adresse = @ID_Adresse";
  633.             SqliteConnection con = zugriff.connect();
  634.             SqliteCommand com = new(Update, con);
  635.  
  636.             SqliteParameter st = new();
  637.             st.ParameterName = "@Str";
  638.             st.Value = AddData.Straße;
  639.             com.Parameters.Add(st);
  640.  
  641.             SqliteParameter hn = new();
  642.             hn.ParameterName = "@HNr";
  643.             hn.Value = AddData.Hausnummer;
  644.             com.Parameters.Add(hn);
  645.  
  646.             SqliteParameter pl = new();
  647.             pl.ParameterName = "@PLZ";
  648.             pl.Value = AddData.Plz;
  649.             com.Parameters.Add(pl);
  650.  
  651.             SqliteParameter or = new();
  652.             or.ParameterName = "@Ort";
  653.             or.Value = AddData.Ort;
  654.             com.Parameters.Add(or);
  655.  
  656.             SqliteParameter la = new();
  657.             la.ParameterName = "@Land";
  658.             la.Value = AddData.Land;
  659.             com.Parameters.Add(la);
  660.  
  661.             SqliteParameter id = new();
  662.             id.ParameterName = "@ID_Adresse";
  663.             id.Value = AddData.ID_Adresse;
  664.             com.Parameters.Add(id);
  665.  
  666.             con.Open();
  667.             com.ExecuteNonQuery();
  668.             con.Close();
  669.  
  670.  
  671.         }
  672.  
  673.         public void NeuePersonSpeichern()
  674.         {
  675.             if (NeuePerson.Geburtsname == null)
  676.             {
  677.                 string insert = "Insert Into Person(Vorname, Nachname, Geburtsdatum) Values(@Vorname, @Nachname, @Geburtsdatum)";
  678.                 SqliteConnection connect = zugriff.connect();
  679.                 SqliteCommand com = new(insert, connect);
  680.  
  681.                 SqliteParameter vn = new();
  682.                 vn.ParameterName = "@Vorname";
  683.                 vn.Value = NeuePerson.Vorname;
  684.                 com.Parameters.Add(vn);
  685.  
  686.                 SqliteParameter nn = new();
  687.                 nn.ParameterName = "@Nachname";
  688.                 nn.Value = NeuePerson.Nachname;
  689.                 com.Parameters.Add(nn);
  690.  
  691.                 SqliteParameter gd = new();
  692.                 gd.ParameterName = "@Geburtsdatum";
  693.                 gd.Value = NeuePerson.Geburtsdatum;
  694.                 com.Parameters.Add(gd);
  695.  
  696.                 connect.Open();
  697.                 com.ExecuteNonQuery();
  698.                 connect.Close();
  699.             }
  700.             else
  701.             {
  702.                 string insert = "Insert INTO Person(Vorname, Nachname, Geburtsdatum, Geburtsname) Values(@Vorname, @Nachname, @Geburtsdatum, @Geburtsname)";
  703.                 SqliteConnection connect = zugriff.connect();
  704.                 SqliteCommand com = new(insert, connect);
  705.  
  706.                 SqliteParameter vn = new();
  707.                 vn.ParameterName = "@Vorname";
  708.                 vn.Value = NeuePerson.Vorname;
  709.                 com.Parameters.Add(vn);
  710.  
  711.                 SqliteParameter nn = new();
  712.                 nn.ParameterName = "@Nachname";
  713.                 nn.Value = NeuePerson.Nachname;
  714.                 com.Parameters.Add(nn);
  715.  
  716.                 SqliteParameter gd = new();
  717.                 gd.ParameterName = "@Geburtsdatum";
  718.                 gd.Value = NeuePerson.Geburtsdatum;
  719.                 com.Parameters.Add(gd);
  720.  
  721.                 SqliteParameter gn = new();
  722.                 gn.ParameterName = "@Geburtsname";
  723.                 gn.Value = NeuePerson.Geburtsname;
  724.                 com.Parameters.Add(gn);
  725.  
  726.                 connect.Open();
  727.                 com.ExecuteNonQuery();
  728.                 connect.Close();
  729.             }
  730.         }
  731.  
  732.         public void NeueAdresseSpeichern()
  733.         {
  734.             string insert = "Insert Into Adresse(Straße, Hausnummer, Postleitzahl, Ort, Land) Values(@str, @hnr, @plz, @ort, @land)";
  735.             SqliteConnection connect = zugriff.connect();
  736.             SqliteCommand com = new(insert, connect);
  737.  
  738.             SqliteParameter param = new();
  739.             param.ParameterName = "@str";
  740.             param.Value = NeueAdresseDaten.Straße;
  741.             com.Parameters.Add(param);
  742.  
  743.             SqliteParameter param2 = new();
  744.             param2.ParameterName = "@hnr";
  745.             param2.Value = NeueAdresseDaten.Hausnummer;
  746.             com.Parameters.Add(param2);
  747.  
  748.             SqliteParameter param3 = new();
  749.             param3.ParameterName = "@plz";
  750.             param3.Value = NeueAdresseDaten.Plz;
  751.             com.Parameters.Add(param3);
  752.  
  753.             SqliteParameter param4 = new();
  754.             param4.ParameterName = "@ort";
  755.             param4.Value = NeueAdresseDaten.Ort;
  756.             com.Parameters.Add(param4);
  757.  
  758.             SqliteParameter param5 = new();
  759.             param5.ParameterName = "@land";
  760.             param5.Value = NeueAdresseDaten.Land;
  761.             com.Parameters.Add(param5);
  762.  
  763.  
  764.             connect.Open();
  765.             com.ExecuteNonQuery();
  766.             connect.Close();
  767.  
  768.         }
  769.         public string ID_Person;
  770.         public void GetIDPerson()
  771.         {
  772.             SqliteConnection connect = zugriff.connect();
  773.             string abfrage = "Select ID_Person FROM Person Where ID_Person = (Select max(ID_Person) FROM Person)";
  774.  
  775.             SqliteCommand com2 = new(abfrage, connect);
  776.             connect.Open();
  777.             SqliteDataReader reader = com2.ExecuteReader();
  778.             if (reader.HasRows)
  779.             {
  780.                 while (reader.Read())
  781.                 { ID_Person = reader.GetString(reader.GetOrdinal("ID_Person")); }
  782.             }
  783.             connect.Close();
  784.         }
  785.  
  786.         public string ID_Adresse { get; set; }
  787.  
  788.         public void GetIDAdress()
  789.         {
  790.             SqliteConnection connect = zugriff.connect();
  791.             string abfrage = "Select ID_Adresse FROM Adresse Where ID_Adresse = (Select max(ID_Adresse) FROM Adresse)";
  792.  
  793.             SqliteCommand com2 = new(abfrage, connect);
  794.             connect.Open();
  795.             SqliteDataReader reader = com2.ExecuteReader();
  796.             if (reader.HasRows)
  797.             {
  798.                 while (reader.Read())
  799.                 { ID_Adresse = reader.GetString(reader.GetOrdinal("ID_Adresse")); }
  800.             }
  801.             connect.Close();
  802.  
  803.         }
  804.  
  805.         public void SchreibePersonAdresse()
  806.         {
  807.             SqliteConnection connect = zugriff.connect();
  808.             string schreibedaten = "Insert into Person_Adresse(ID_Adresse, ID_Adress_Typ, ID_Person) Values(@idaddr, @id_ad_typ, @idpers)";
  809.             SqliteCommand com3 = new(schreibedaten, connect);
  810.             SqliteParameter p1 = new();
  811.             p1.ParameterName = "@idpers";
  812.             p1.Value = ID_Person;
  813.             com3.Parameters.Add(p1);
  814.  
  815.             SqliteParameter p2 = new();
  816.             p2.ParameterName = "@idaddr";
  817.             p2.Value = ID_Adresse;
  818.             com3.Parameters.Add(p2);
  819.  
  820.             SqliteParameter p3 = new();
  821.             p3.ParameterName = "@id_ad_typ";
  822.             p3.Value = AddTyp.ID_Adresstyp;
  823.             com3.Parameters.Add(p3);
  824.  
  825.  
  826.             connect.Open();
  827.             com3.ExecuteNonQuery();
  828.             connect.Close();
  829.         }
  830.  
  831.         public void KontaktdatenSpeichern()
  832.         {
  833.             string InsertTel = "Insert Into Telefon(Nummer, ID_Telefon_Typ, ID_Person) Values(@Num, @id_tt, @id_p)";
  834.             string InsertMail = "Insert INTO EMail(Mailadresse, ID_Email_Typ, ID_Person) Values(@mail, @id_et, @id_pers)";
  835.             SqliteConnection connect = zugriff.connect();
  836.             SqliteCommand com = new(InsertTel, connect);
  837.             SqliteCommand com1 = new(InsertMail, connect);
  838.  
  839.             SqliteParameter num = new();
  840.             num.ParameterName = "@Num";
  841.             num.Value = NeueNummer.Telefonnummer;
  842.             com.Parameters.Add(num);
  843.  
  844.             SqliteParameter id_tt = new();
  845.             id_tt.ParameterName = "@id_tt";
  846.             id_tt.Value = Teltyp.ID_Telefontyp;
  847.             com.Parameters.Add(id_tt);
  848.  
  849.             SqliteParameter id_p = new();
  850.             id_p.ParameterName = "@id_p";
  851.             id_p.Value = ID_Person;
  852.             com.Parameters.Add(id_p);
  853.  
  854.             SqliteParameter id_pers = new();
  855.             id_pers.ParameterName = "@id_pers";
  856.             id_pers.Value = ID_Person;
  857.             com1.Parameters.Add(id_pers);
  858.  
  859.             SqliteParameter id_et = new();
  860.             id_et.ParameterName = "@id_et";
  861.             id_et.Value = Mailtyp.ID_Mailtyp;
  862.             com1.Parameters.Add(id_et);
  863.  
  864.             SqliteParameter mail = new();
  865.             mail.ParameterName = "@mail";
  866.             mail.Value = NeueMail.Mailadresse;
  867.             com1.Parameters.Add(mail);
  868.             connect.Open();
  869.             com.ExecuteNonQuery();
  870.             com1.ExecuteNonQuery();
  871.             connect.Close();
  872.  
  873.  
  874.         }
  875.  
  876.         public void Datenspeichern()
  877.         {
  878.             if (NeuerDatensatz)
  879.             {
  880.                 NeuePersonSpeichern();
  881.                 GetIDPerson();
  882.                 NeueAdresseSpeichern();
  883.                 GetIDAdress();
  884.                 SchreibePersonAdresse();
  885.                 KontaktdatenSpeichern();
  886.                 Safesucces?.Invoke(this, EventArgs.Empty);
  887.             }
  888.             else
  889.             {
  890.                 if (ChangePersonData == true)
  891.                 {
  892.                     if (ChangeAdressData == true)
  893.                     {
  894.                         Datenänderungspeichern();
  895.                         Adressänderungspeichern();
  896.                         Safesucces?.Invoke(this, EventArgs.Empty);
  897.  
  898.                     }
  899.                     else
  900.                     {
  901.                         Datenänderungspeichern();
  902.                         Safesucces?.Invoke(this, EventArgs.Empty);
  903.  
  904.                     }
  905.                 }
  906.                 else
  907.                 {
  908.                     NoSafe?.Invoke(this, EventArgs.Empty);
  909.                 }
  910.  
  911.             }
  912.         }
  913.  
  914.         #endregion
  915.     }
  916. }
  917.  
RAW Paste Data