Nexmo

MainWindowViewModel_22_10

Oct 22nd, 2021
877
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.                     AddTyp.Adresstyp = AddData.AdressTyp;
  251.                     RaisePropertyChanged();
  252.                     //RaisePropertyChanged(nameof(AddTyp));
  253.                     ChangeAdressData = true;
  254.  
  255.  
  256.  
  257.                 }
  258.             }
  259.         }
  260.         public Adressdaten NeueAdresseDaten
  261.         {
  262.             get => addData;
  263.             set
  264.             {
  265.                 addData = value;
  266.                 RaisePropertyChanged();
  267.  
  268.             }
  269.         }
  270.  
  271.         private Adresstypen addtyp = new Adresstypen();
  272.         public Adresstypen AddTyp
  273.         {
  274.             get => addtyp;
  275.             set
  276.             {
  277.                 if (value != addtyp)
  278.                 {
  279.                     addtyp = value;
  280.                     AddData.AdressTyp = addtyp.Adresstyp;
  281.                     RaisePropertyChanged();
  282.                     RaisePropertyChanged(nameof(AddData));
  283.                    
  284.                 }
  285.             }
  286.         }
  287.  
  288.         private Telefontypen teltyp = new();
  289.         public Telefontypen Teltyp
  290.         {
  291.             get => teltyp;
  292.             set
  293.             {
  294.                 if (value != teltyp)
  295.                 {
  296.                     teltyp = value;
  297.                     RaisePropertyChanged();
  298.                 }
  299.             }
  300.         }
  301.  
  302.         private Mailtypen mailtyp = new();
  303.         public Mailtypen Mailtyp
  304.         {
  305.             get => mailtyp;
  306.             set
  307.             {
  308.                 if (value != mailtyp)
  309.                 {
  310.                     mailtyp = value;
  311.                     RaisePropertyChanged();
  312.                 }
  313.             }
  314.         }
  315.  
  316.         private MailDaten maildata = new();
  317.         public MailDaten Maildata
  318.         {
  319.             get => maildata;
  320.             set
  321.             {
  322.                 if (value != maildata)
  323.                 {
  324.                     maildata = value;
  325.                     RaisePropertyChanged();
  326.                 }
  327.             }
  328.         }
  329.         public MailDaten NeueMail
  330.         {
  331.             get => maildata;
  332.             set
  333.             {
  334.                 maildata = value;
  335.                 RaisePropertyChanged();
  336.             }
  337.         }
  338.  
  339.         private TelefonDaten teldata = new();
  340.         public TelefonDaten TelData
  341.         {
  342.             get => teldata;
  343.             set
  344.             {
  345.                 if (value != teldata)
  346.                 {
  347.                     teldata = value;
  348.                     RaisePropertyChanged();
  349.  
  350.                 }
  351.             }
  352.         }
  353.         public TelefonDaten NeueNummer
  354.         {
  355.             get => teldata;
  356.             set
  357.             {
  358.                 teldata = value;
  359.                 RaisePropertyChanged();
  360.             }
  361.         }
  362.         #endregion
  363.  
  364.  
  365.  
  366.  
  367.  
  368.         #region DelegateCommands
  369.         public DelegateCommand Abfrage { get; set; }
  370.  
  371.         public DelegateCommand Speichern { get; set; }
  372.  
  373.         public DelegateCommand NeueAdresse { get; set; }
  374.         #endregion
  375.         public event EventHandler Safesucces;
  376.         public event EventHandler NoSafe;
  377.  
  378.         private Datenbankzugriff zugriff = Datenbankzugriff.GetDBZugriff();
  379.  
  380.  
  381.         private void LoadnewData()
  382.         {
  383.             RaisePropertyChanged(nameof(Anzeigeändern));
  384.             RaisePropertyChanged(nameof(Anzeigeändern1));
  385.  
  386.             Personendatenliste.Clear();
  387.             Adressdatenliste.Clear();
  388.             Kontaktdatenliste.Clear();
  389.             Maildataliste.Clear();
  390.  
  391.             Adresstypenabfrage();
  392.             Telefontypabfrage();
  393.             Mailtypabfrage();
  394.  
  395.  
  396.         }
  397.         /// <summary>
  398.         /// Abfrage der Daten und zuordnung zu den ObservableCollections Personendatenliste und Kontakdatenliste
  399.         /// </summary>
  400.  
  401.         #region Abfragemethoden
  402.         private void Datenabfrage()
  403.         {
  404.             RaisePropertyChanged(nameof(Anzeigeändern));
  405.             RaisePropertyChanged(nameof(Anzeigeändern1));
  406.             this.NeueAdresse.RaiseCanExecuteChanged();
  407.  
  408.             SqliteConnection connect = zugriff.connect();
  409.             //string datenabfrage = "Select ID_Person, Vorname, Nachname, Geburtsdatum, Geburtsname FROM Person";
  410.             string datenabfrage = "Select p.ID_Person, Vorname, Nachname, Geburtsname, Geburtsdatum From Person p ";
  411.             SqliteCommand com = new(datenabfrage, connect);
  412.  
  413.             connect.Open();
  414.             SqliteDataReader reader = com.ExecuteReader();
  415.             if (reader.HasRows)
  416.                 while (reader.Read())
  417.                 {
  418.                     Personendatenliste.Add(new PersonenDaten
  419.                     {
  420.                         ID = reader.GetString(reader.GetOrdinal("ID_Person")),
  421.                         Vorname = reader.GetString(reader.GetOrdinal("Vorname")),
  422.                         Nachname = reader.GetString(reader.GetOrdinal("Nachname")),
  423.                         Geburtsdatum = reader.GetString(reader.GetOrdinal("Geburtsdatum")),
  424.                         Geburtsname = reader.GetString(reader.GetOrdinal("Geburtsname")),
  425.  
  426.                     });
  427.                 }
  428.  
  429.  
  430.             connect.Close();
  431.         }
  432.  
  433.         private void Adressabfrage(string identify)
  434.         {
  435.  
  436.             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";
  437.             SqliteConnection connect = zugriff.connect();
  438.             SqliteCommand com = new(abfrage, connect);
  439.  
  440.             SqliteParameter p1 = new();
  441.             p1.ParameterName = "@ID_Person";
  442.             p1.Value = identify;
  443.             com.Parameters.Add(p1);
  444.  
  445.             connect.Open();
  446.             SqliteDataReader reader = com.ExecuteReader();
  447.             if (reader.HasRows)
  448.             {
  449.                 while (reader.Read())
  450.                 {
  451.                     Adressdatenliste.Add(new Adressdaten
  452.                     {
  453.                         ID_Adresse = reader.GetString(reader.GetOrdinal("ID_Adresse")),
  454.                         Straße = reader.GetString(reader.GetOrdinal("Straße")),
  455.                         Hausnummer = reader.GetString(reader.GetOrdinal("Hausnummer")),
  456.                         Plz = reader.GetString(reader.GetOrdinal("Postleitzahl")),
  457.                         Ort = reader.GetString(reader.GetOrdinal("Ort")),
  458.                         Land = reader.GetString(reader.GetOrdinal("Land")),
  459.                         AdressTyp = reader.GetString(reader.GetOrdinal("Typ_Name")),
  460.                         ID_AdressTyp = reader.GetString(reader.GetOrdinal("ID_Adress_Typ"))
  461.                         //Etage = reader.GetString(reader.GetOrdinal("Etage")),
  462.                         //Abteilung = reader.GetString(reader.GetOrdinal("Abteilung")),
  463.                         //Gebäude = reader.GetString(reader.GetOrdinal("Gebäude")),
  464.                     });
  465.                 }
  466.             }
  467.         }
  468.  
  469.         private void MailAdressDatenabfrage(string identify)
  470.         {
  471.             SqliteConnection connect = zugriff.connect();
  472.             string abfrage = "Select e.Mailadresse, mt.Typ_Art_Mail From  EMail e " +
  473.                 "JOIN EMail_Typ mt ON e.ID_Email_Typ = mt.ID_Email_Typ " +
  474.                 "Where e.ID_Person = @Person";
  475.             SqliteCommand com = new(abfrage, connect);
  476.  
  477.             SqliteParameter p1 = new();
  478.             p1.ParameterName = "@Person";
  479.             p1.Value = identify;
  480.             com.Parameters.Add(p1);
  481.  
  482.  
  483.  
  484.             connect.Open();
  485.  
  486.             SqliteDataReader reader = com.ExecuteReader();
  487.             if (reader.HasRows)
  488.             {
  489.                 while (reader.Read())
  490.                 {
  491.                     Maildataliste.Add(new MailDaten
  492.                     {
  493.                         Mailadresse = reader.GetString(reader.GetOrdinal("Mailadresse")),
  494.                         Mailtyp = reader.GetString(reader.GetOrdinal("Typ_Art_Mail"))
  495.                     });
  496.                 }
  497.             }
  498.         }
  499.  
  500.         private void KontaktDatenabfrage(string identify)
  501.         {
  502.             SqliteConnection connect = zugriff.connect();
  503.             string abfrage = "Select t.Nummer,  Typ_Art From Telefon t " +
  504.                 "JOIN Telefon_Typ tt ON t.ID_Telefon_Typ = tt.ID_Telefon_Typ " +
  505.                 "Where t.ID_Person = @Person";
  506.             SqliteCommand com = new(abfrage, connect);
  507.  
  508.             SqliteParameter p1 = new();
  509.             p1.ParameterName = "@Person";
  510.             p1.Value = identify;
  511.             com.Parameters.Add(p1);
  512.  
  513.  
  514.  
  515.             connect.Open();
  516.  
  517.             SqliteDataReader reader = com.ExecuteReader();
  518.             if (reader.HasRows)
  519.             {
  520.                 while (reader.Read())
  521.                 {
  522.                     Kontaktdatenliste.Add(new TelefonDaten
  523.                     {
  524.                         Telefonnummer = reader.GetString(reader.GetOrdinal("Nummer")),
  525.                         Nummertyp = reader.GetString(reader.GetOrdinal("Typ_Art")),
  526.  
  527.                     });
  528.                 }
  529.             }
  530.         }
  531.  
  532.         private void Adresstypenabfrage()
  533.         {
  534.             string abfrage = "Select * From Adress_Typ";
  535.             SqliteConnection connect = zugriff.connect();
  536.             SqliteCommand com = new(abfrage, connect);
  537.  
  538.             connect.Open();
  539.             SqliteDataReader reader = com.ExecuteReader();
  540.  
  541.             if (reader.HasRows)
  542.             {
  543.                 while (reader.Read())
  544.                 {
  545.                     Adresstypenliste.Add(
  546.                         new Adresstypen
  547.                         {
  548.                             Adresstyp = reader.GetString(reader.GetOrdinal("Typ_Name")),
  549.                             ID_Adresstyp = reader.GetString(reader.GetOrdinal("ID_Adress_Typ"))
  550.                         });
  551.                 }
  552.             }
  553.         }
  554.         private void Telefontypabfrage()
  555.         {
  556.             string abfrage = "Select * From Telefon_Typ";
  557.             SqliteConnection connect = zugriff.connect();
  558.             SqliteCommand com = new(abfrage, connect);
  559.  
  560.             connect.Open();
  561.             SqliteDataReader reader = com.ExecuteReader();
  562.  
  563.             if (reader.HasRows)
  564.             {
  565.                 while (reader.Read())
  566.                 {
  567.                     Teltypliste.Add(
  568.                         new Telefontypen
  569.                         {
  570.                             Telefontyp = reader.GetString(reader.GetOrdinal("Typ_Art")),
  571.                             ID_Telefontyp = reader.GetString(reader.GetOrdinal("ID_Telefon_Typ"))
  572.                         });
  573.                 }
  574.             }
  575.         }
  576.  
  577.         private void Mailtypabfrage()
  578.         {
  579.             string abfrage = "Select * From EMail_Typ";
  580.             SqliteConnection connect = zugriff.connect();
  581.             SqliteCommand com = new(abfrage, connect);
  582.  
  583.             connect.Open();
  584.             SqliteDataReader reader = com.ExecuteReader();
  585.  
  586.             if (reader.HasRows)
  587.             {
  588.                 while (reader.Read())
  589.                 {
  590.                     Mailtypliste.Add(
  591.                         new Mailtypen
  592.                         {
  593.                             Mailtyp = reader.GetString(reader.GetOrdinal("Typ_Art_Mail")),
  594.                             ID_Mailtyp = reader.GetString(reader.GetOrdinal("ID_Email_Typ"))
  595.                         });
  596.                 }
  597.             }
  598.  
  599.         }
  600.         /// <summary>
  601.         /// Speichern von Änderungen an Pesonendaten und Adressen
  602.         /// </summary>
  603.         private void Datenänderungspeichern()
  604.         {
  605.  
  606.             string Update = "Update Person Set Vorname = @Vorname, Nachname = @Nachname, Geburtsdatum = @Geburtsdatum WHERE ID_Person = @ID_Person ";
  607.             SqliteConnection connect = zugriff.connect();
  608.             SqliteCommand com = new(Update, connect);
  609.  
  610.             SqliteParameter vn = new();
  611.             vn.ParameterName = "@Vorname";
  612.             vn.Value = PersData.Vorname;
  613.             com.Parameters.Add(vn);
  614.  
  615.             SqliteParameter nn = new();
  616.             nn.ParameterName = "@Nachname";
  617.             nn.Value = PersData.Nachname;
  618.             com.Parameters.Add(nn);
  619.  
  620.             SqliteParameter gd = new();
  621.             gd.ParameterName = "@Geburtsdatum";
  622.             gd.Value = PersData.Geburtsdatum;
  623.             com.Parameters.Add(gd);
  624.  
  625.             SqliteParameter id = new();
  626.             id.ParameterName = "@ID_Person";
  627.             id.Value = PersData.ID;
  628.             com.Parameters.Add(id);
  629.  
  630.             connect.Open();
  631.             com.ExecuteNonQuery();
  632.             connect.Close();
  633.  
  634.  
  635.  
  636.         }
  637.  
  638.         public void Adressänderungspeichern()
  639.         {
  640.             string Update = "Update Adresse Set Straße = @Str, Hausnummer = @HNr, Postleitzahl = @PLZ, Ort = @Ort, Land = @Land WHERE ID_Adresse = @ID_Adresse";
  641.             SqliteConnection con = zugriff.connect();
  642.             SqliteCommand com = new(Update, con);
  643.  
  644.             SqliteParameter st = new();
  645.             st.ParameterName = "@Str";
  646.             st.Value = AddData.Straße;
  647.             com.Parameters.Add(st);
  648.  
  649.             SqliteParameter hn = new();
  650.             hn.ParameterName = "@HNr";
  651.             hn.Value = AddData.Hausnummer;
  652.             com.Parameters.Add(hn);
  653.  
  654.             SqliteParameter pl = new();
  655.             pl.ParameterName = "@PLZ";
  656.             pl.Value = AddData.Plz;
  657.             com.Parameters.Add(pl);
  658.  
  659.             SqliteParameter or = new();
  660.             or.ParameterName = "@Ort";
  661.             or.Value = AddData.Ort;
  662.             com.Parameters.Add(or);
  663.  
  664.             SqliteParameter la = new();
  665.             la.ParameterName = "@Land";
  666.             la.Value = AddData.Land;
  667.             com.Parameters.Add(la);
  668.  
  669.             SqliteParameter id = new();
  670.             id.ParameterName = "@ID_Adresse";
  671.             id.Value = AddData.ID_Adresse;
  672.             com.Parameters.Add(id);
  673.  
  674.             con.Open();
  675.             com.ExecuteNonQuery();
  676.             con.Close();
  677.  
  678.  
  679.         }
  680.  
  681.         public void NeuePersonSpeichern()
  682.         {
  683.             if (NeuePerson.Geburtsname == null)
  684.             {
  685.                 string insert = "Insert Into Person(Vorname, Nachname, Geburtsdatum) Values(@Vorname, @Nachname, @Geburtsdatum)";
  686.                 SqliteConnection connect = zugriff.connect();
  687.                 SqliteCommand com = new(insert, connect);
  688.  
  689.                 SqliteParameter vn = new();
  690.                 vn.ParameterName = "@Vorname";
  691.                 vn.Value = NeuePerson.Vorname;
  692.                 com.Parameters.Add(vn);
  693.  
  694.                 SqliteParameter nn = new();
  695.                 nn.ParameterName = "@Nachname";
  696.                 nn.Value = NeuePerson.Nachname;
  697.                 com.Parameters.Add(nn);
  698.  
  699.                 SqliteParameter gd = new();
  700.                 gd.ParameterName = "@Geburtsdatum";
  701.                 gd.Value = NeuePerson.Geburtsdatum;
  702.                 com.Parameters.Add(gd);
  703.  
  704.                 connect.Open();
  705.                 com.ExecuteNonQuery();
  706.                 connect.Close();
  707.             }
  708.             else
  709.             {
  710.                 string insert = "Insert INTO Person(Vorname, Nachname, Geburtsdatum, Geburtsname) Values(@Vorname, @Nachname, @Geburtsdatum, @Geburtsname)";
  711.                 SqliteConnection connect = zugriff.connect();
  712.                 SqliteCommand com = new(insert, connect);
  713.  
  714.                 SqliteParameter vn = new();
  715.                 vn.ParameterName = "@Vorname";
  716.                 vn.Value = NeuePerson.Vorname;
  717.                 com.Parameters.Add(vn);
  718.  
  719.                 SqliteParameter nn = new();
  720.                 nn.ParameterName = "@Nachname";
  721.                 nn.Value = NeuePerson.Nachname;
  722.                 com.Parameters.Add(nn);
  723.  
  724.                 SqliteParameter gd = new();
  725.                 gd.ParameterName = "@Geburtsdatum";
  726.                 gd.Value = NeuePerson.Geburtsdatum;
  727.                 com.Parameters.Add(gd);
  728.  
  729.                 SqliteParameter gn = new();
  730.                 gn.ParameterName = "@Geburtsname";
  731.                 gn.Value = NeuePerson.Geburtsname;
  732.                 com.Parameters.Add(gn);
  733.  
  734.                 connect.Open();
  735.                 com.ExecuteNonQuery();
  736.                 connect.Close();
  737.             }
  738.         }
  739.  
  740.         public void NeueAdresseSpeichern()
  741.         {
  742.             string insert = "Insert Into Adresse(Straße, Hausnummer, Postleitzahl, Ort, Land) Values(@str, @hnr, @plz, @ort, @land)";
  743.             SqliteConnection connect = zugriff.connect();
  744.             SqliteCommand com = new(insert, connect);
  745.  
  746.             SqliteParameter param = new();
  747.             param.ParameterName = "@str";
  748.             param.Value = NeueAdresseDaten.Straße;
  749.             com.Parameters.Add(param);
  750.  
  751.             SqliteParameter param2 = new();
  752.             param2.ParameterName = "@hnr";
  753.             param2.Value = NeueAdresseDaten.Hausnummer;
  754.             com.Parameters.Add(param2);
  755.  
  756.             SqliteParameter param3 = new();
  757.             param3.ParameterName = "@plz";
  758.             param3.Value = NeueAdresseDaten.Plz;
  759.             com.Parameters.Add(param3);
  760.  
  761.             SqliteParameter param4 = new();
  762.             param4.ParameterName = "@ort";
  763.             param4.Value = NeueAdresseDaten.Ort;
  764.             com.Parameters.Add(param4);
  765.  
  766.             SqliteParameter param5 = new();
  767.             param5.ParameterName = "@land";
  768.             param5.Value = NeueAdresseDaten.Land;
  769.             com.Parameters.Add(param5);
  770.  
  771.  
  772.             connect.Open();
  773.             com.ExecuteNonQuery();
  774.             connect.Close();
  775.  
  776.         }
  777.         public string ID_Person;
  778.         public void GetIDPerson()
  779.         {
  780.             SqliteConnection connect = zugriff.connect();
  781.             string abfrage = "Select ID_Person FROM Person Where ID_Person = (Select max(ID_Person) FROM Person)";
  782.  
  783.             SqliteCommand com2 = new(abfrage, connect);
  784.             connect.Open();
  785.             SqliteDataReader reader = com2.ExecuteReader();
  786.             if (reader.HasRows)
  787.             {
  788.                 while (reader.Read())
  789.                 { ID_Person = reader.GetString(reader.GetOrdinal("ID_Person")); }
  790.             }
  791.             connect.Close();
  792.         }
  793.  
  794.         public string ID_Adresse { get; set; }
  795.  
  796.         public void GetIDAdress()
  797.         {
  798.             SqliteConnection connect = zugriff.connect();
  799.             string abfrage = "Select ID_Adresse FROM Adresse Where ID_Adresse = (Select max(ID_Adresse) FROM Adresse)";
  800.  
  801.             SqliteCommand com2 = new(abfrage, connect);
  802.             connect.Open();
  803.             SqliteDataReader reader = com2.ExecuteReader();
  804.             if (reader.HasRows)
  805.             {
  806.                 while (reader.Read())
  807.                 { ID_Adresse = reader.GetString(reader.GetOrdinal("ID_Adresse")); }
  808.             }
  809.             connect.Close();
  810.  
  811.         }
  812.  
  813.         public void SchreibePersonAdresse()
  814.         {
  815.             SqliteConnection connect = zugriff.connect();
  816.             string schreibedaten = "Insert into Person_Adresse(ID_Adresse, ID_Adress_Typ, ID_Person) Values(@idaddr, @id_ad_typ, @idpers)";
  817.             SqliteCommand com3 = new(schreibedaten, connect);
  818.             SqliteParameter p1 = new();
  819.             p1.ParameterName = "@idpers";
  820.             p1.Value = ID_Person;
  821.             com3.Parameters.Add(p1);
  822.  
  823.             SqliteParameter p2 = new();
  824.             p2.ParameterName = "@idaddr";
  825.             p2.Value = ID_Adresse;
  826.             com3.Parameters.Add(p2);
  827.  
  828.             SqliteParameter p3 = new();
  829.             p3.ParameterName = "@id_ad_typ";
  830.             p3.Value = AddTyp.ID_Adresstyp;
  831.             com3.Parameters.Add(p3);
  832.  
  833.  
  834.             connect.Open();
  835.             com3.ExecuteNonQuery();
  836.             connect.Close();
  837.         }
  838.  
  839.         public void KontaktdatenSpeichern()
  840.         {
  841.             string InsertTel = "Insert Into Telefon(Nummer, ID_Telefon_Typ, ID_Person) Values(@Num, @id_tt, @id_p)";
  842.             string InsertMail = "Insert INTO EMail(Mailadresse, ID_Email_Typ, ID_Person) Values(@mail, @id_et, @id_pers)";
  843.             SqliteConnection connect = zugriff.connect();
  844.             SqliteCommand com = new(InsertTel, connect);
  845.             SqliteCommand com1 = new(InsertMail, connect);
  846.  
  847.             SqliteParameter num = new();
  848.             num.ParameterName = "@Num";
  849.             num.Value = NeueNummer.Telefonnummer;
  850.             com.Parameters.Add(num);
  851.  
  852.             SqliteParameter id_tt = new();
  853.             id_tt.ParameterName = "@id_tt";
  854.             id_tt.Value = Teltyp.ID_Telefontyp;
  855.             com.Parameters.Add(id_tt);
  856.  
  857.             SqliteParameter id_p = new();
  858.             id_p.ParameterName = "@id_p";
  859.             id_p.Value = ID_Person;
  860.             com.Parameters.Add(id_p);
  861.  
  862.             SqliteParameter id_pers = new();
  863.             id_pers.ParameterName = "@id_pers";
  864.             id_pers.Value = ID_Person;
  865.             com1.Parameters.Add(id_pers);
  866.  
  867.             SqliteParameter id_et = new();
  868.             id_et.ParameterName = "@id_et";
  869.             id_et.Value = Mailtyp.ID_Mailtyp;
  870.             com1.Parameters.Add(id_et);
  871.  
  872.             SqliteParameter mail = new();
  873.             mail.ParameterName = "@mail";
  874.             mail.Value = NeueMail.Mailadresse;
  875.             com1.Parameters.Add(mail);
  876.             connect.Open();
  877.             com.ExecuteNonQuery();
  878.             com1.ExecuteNonQuery();
  879.             connect.Close();
  880.  
  881.  
  882.         }
  883.  
  884.         public void Datenspeichern()
  885.         {
  886.             if (NeuerDatensatz)
  887.             {
  888.                 NeuePersonSpeichern();
  889.                 GetIDPerson();
  890.                 NeueAdresseSpeichern();
  891.                 GetIDAdress();
  892.                 SchreibePersonAdresse();
  893.                 KontaktdatenSpeichern();
  894.                 Safesucces?.Invoke(this, EventArgs.Empty);
  895.             }
  896.             else
  897.             {
  898.                 if (ChangePersonData == true)
  899.                 {
  900.                     if (ChangeAdressData == true)
  901.                     {
  902.                         Datenänderungspeichern();
  903.                         Adressänderungspeichern();
  904.                         Safesucces?.Invoke(this, EventArgs.Empty);
  905.  
  906.                     }
  907.                     else
  908.                     {
  909.                         Datenänderungspeichern();
  910.                         Safesucces?.Invoke(this, EventArgs.Empty);
  911.  
  912.                     }
  913.                 }
  914.                 else
  915.                 {
  916.                     NoSafe?.Invoke(this, EventArgs.Empty);
  917.                 }
  918.  
  919.             }
  920.         }
  921.  
  922.         #endregion
  923.     }
  924. }
  925.  
RAW Paste Data