Nexmo

MainWindowViewModel

Oct 14th, 2021
715
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((o) => { Personendatenliste.Clear(); Datenabfrage(); });
  20.             this.Speichern = new DelegateCommand((o) => { Datenänderungspeichern(); });
  21.             this.NeueAdresse = new DelegateCommand((o) => { NeuerDatensatz = true; LoadnewData(); });
  22.  
  23.             Searchable = Personendatenliste;
  24.             Listable = new CollectionViewSource();
  25.             Listable.Source = this.Searchable;
  26.             Listable.Filter += ApplyFilter;
  27.  
  28.  
  29.  
  30.         }
  31.  
  32.  
  33.         public bool NeuerDatensatz;
  34.      
  35.  
  36.         public bool Anzeigeändern => NeuerDatensatz != true;
  37.         public bool Anzeigeändern1 => NeuerDatensatz;
  38.  
  39.         #region Collection für Filter und Filter
  40.         public ObservableCollection<PersonenDaten> Searchable { get; set; }
  41.         internal CollectionViewSource Listable { get; set; }
  42.         public ICollectionView GetListable { get => Listable.View; }
  43.  
  44.         private void ApplyFilter(object sender, FilterEventArgs e)
  45.         {
  46.             PersonenDaten search = (PersonenDaten)e.Item;
  47.             if (string.IsNullOrEmpty(this.Filter) || this.Filter.Length == 0)
  48.             { e.Accepted = true; }
  49.             else
  50.             {
  51.                 e.Accepted = search.Fullname.Contains(Filter);
  52.                 RaisePropertyChanged();
  53.             }
  54.  
  55.  
  56.         }
  57.  
  58.         private string filter;
  59.         public string Filter
  60.         {
  61.             get => this.filter;
  62.             set
  63.             {
  64.                 if (value != filter)
  65.                 {
  66.                     this.filter = value;
  67.                     //RaisePropertyChanged();
  68.                     Listable.View.Refresh();
  69.                     RaisePropertyChanged(nameof(Filter));
  70.                 }
  71.             }
  72.         }
  73.         #endregion
  74.  
  75.         #region Colections für Binding und Zugehörige Listen
  76.         private ObservableCollection<PersonenDaten> personendatenliste = new ObservableCollection<PersonenDaten>();
  77.         public ObservableCollection<PersonenDaten> Personendatenliste
  78.         {
  79.             get => personendatenliste;
  80.             set
  81.             {
  82.                 if (value != personendatenliste)
  83.                 {
  84.                     personendatenliste = value;
  85.                     RaisePropertyChanged();
  86.  
  87.                 }
  88.             }
  89.         }
  90.         private ObservableCollection<Adressdaten> adressDatenliste = new ObservableCollection<Adressdaten>();
  91.         public ObservableCollection<Adressdaten> Adressdatenliste
  92.         {
  93.             get => adressDatenliste;
  94.             set
  95.             {
  96.                 if (value != adressDatenliste)
  97.                 {
  98.                     adressDatenliste = value;
  99.                     RaisePropertyChanged();
  100.                 }
  101.             }
  102.         }
  103.  
  104.         private ObservableCollection<MailDaten> maildata = new ObservableCollection<MailDaten>();
  105.         public ObservableCollection<MailDaten> Maildata
  106.         {
  107.             get => maildata;
  108.             set
  109.             {
  110.                 if (value != maildata)
  111.                 {
  112.                     maildata = value;
  113.                     RaisePropertyChanged();
  114.                 }
  115.             }
  116.         }
  117.  
  118.         private ObservableCollection<TelefonDaten> kontaktdatenliste = new ObservableCollection<TelefonDaten>();
  119.         public ObservableCollection<TelefonDaten> Kontaktdatenliste
  120.         {
  121.             get => kontaktdatenliste;
  122.             set
  123.             {
  124.                 if (value != kontaktdatenliste)
  125.                 {
  126.                     kontaktdatenliste = value;
  127.                     RaisePropertyChanged();
  128.  
  129.                 }
  130.             }
  131.         }
  132.  
  133.         private ObservableCollection<Adresstypen> adresstypenliste = new();
  134.         public ObservableCollection<Adresstypen> Adresstypenliste
  135.         {
  136.             get => adresstypenliste;
  137.             set
  138.             {
  139.                 if (value != adresstypenliste)
  140.                 {
  141.                     adresstypenliste = value;
  142.                     RaisePropertyChanged();
  143.                 }
  144.             }
  145.         }
  146.  
  147.         TelefonDaten kontData = new TelefonDaten();
  148.         public TelefonDaten KontData
  149.         {
  150.             get => kontData;
  151.             set
  152.             {
  153.                 if (value != kontData)
  154.                 {
  155.                     kontData = value;
  156.                     RaisePropertyChanged();
  157.                 }
  158.             }
  159.         }
  160.  
  161.         /// <summary>
  162.         /// Select a single Name and get more information about it.
  163.         /// Clear the ObservableCollections for Adress, Telefon and Mail
  164.         /// </summary>
  165.         PersonenDaten persData = new PersonenDaten();
  166.         public PersonenDaten PersData
  167.         {
  168.             get => persData;
  169.             set
  170.             {
  171.                 if (value != persData)
  172.                 {
  173.                     persData = value;
  174.                     RaisePropertyChanged();
  175.                     Adressdatenliste.Clear();
  176.                     Adressabfrage(PersData.ID);
  177.                     Kontaktdatenliste.Clear();
  178.                     KontaktDatenabfrage(PersData.ID);
  179.                     Maildata.Clear();
  180.                     MailAdressDatenabfrage(PersData.ID);
  181.  
  182.                 }
  183.             }
  184.         }
  185.  
  186.         Adressdaten addData = new Adressdaten();
  187.         public Adressdaten AddData
  188.         {
  189.             get => addData;
  190.             set
  191.             {
  192.                 if (value != addData)
  193.                 {
  194.                     addData = value;
  195.                     RaisePropertyChanged();
  196.                 }
  197.             }
  198.         }
  199.         #endregion
  200.  
  201.         #region DelegateCommands
  202.         public DelegateCommand Abfrage{ get; set; }
  203.  
  204.         public DelegateCommand Speichern { get; set; }
  205.  
  206.         public DelegateCommand NeueAdresse { get; set; }
  207.         #endregion
  208.         public event EventHandler Safesucces;
  209.  
  210.         Datenbankzugriff zugriff = Datenbankzugriff.GetDBZugriff();
  211.        
  212.  
  213.         private void LoadnewData()
  214.         {
  215.  
  216.             RaisePropertyChanged(nameof(Anzeigeändern));
  217.             RaisePropertyChanged(nameof(Anzeigeändern1));
  218.             //Personendatenliste.Clear();
  219.             //kontaktdatenliste.Clear();
  220.             //Adressdatenliste.Clear();
  221.  
  222.             PersData.Vorname = " ";
  223.             PersData.Nachname = "";
  224.             PersData.Geburtsdatum = "";
  225.             PersData.ID = "";
  226.             PersData.Geburtsname = "";
  227.             AddData.Straße = "";
  228.             AddData.Hausnummer = "";
  229.             AddData.Plz = "";
  230.             AddData.Ort = "";
  231.             AddData.Land = "";
  232.             KontData.Telefonnummer = "";
  233.             KontData.Nummertyp = "";
  234.             Adressdatenliste.Clear();
  235.             Kontaktdatenliste.Clear();
  236.            
  237.  
  238.  
  239.         }
  240.         /// <summary>
  241.         /// Abfrage der Daten und zuordnung zu den ObservableCollections Personendatenliste und Kontakdatenliste
  242.         /// </summary>
  243.  
  244.         #region Abfragemethoden
  245.         private void Datenabfrage()
  246.         {
  247.  
  248.             SqliteConnection connect = zugriff.connect();
  249.             //string datenabfrage = "Select ID_Person, Vorname, Nachname, Geburtsdatum, Geburtsname FROM Person";
  250.             string datenabfrage = "Select p.ID_Person, Vorname, Nachname, Geburtsname, Geburtsdatum From Person p ";
  251.             SqliteCommand com = new(datenabfrage, connect);
  252.  
  253.             connect.Open();
  254.             SqliteDataReader reader = com.ExecuteReader();
  255.             if (reader.HasRows)
  256.                 while (reader.Read())
  257.                 {
  258.                     Personendatenliste.Add(new PersonenDaten
  259.                     {
  260.                         ID = reader.GetString(reader.GetOrdinal("ID_Person")),
  261.                         Vorname = reader.GetString(reader.GetOrdinal("Vorname")),
  262.                         Nachname = reader.GetString(reader.GetOrdinal("Nachname")),
  263.                         Geburtsdatum = reader.GetString(reader.GetOrdinal("Geburtsdatum")),
  264.                         Geburtsname = reader.GetString(reader.GetOrdinal("Geburtsname")),
  265.  
  266.                     });
  267.                 }
  268.  
  269.  
  270.             connect.Close();
  271.         }
  272.  
  273.         private void Adressabfrage(string identify)
  274.         {
  275.  
  276.             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";
  277.             SqliteConnection connect = zugriff.connect();
  278.             SqliteCommand com = new(abfrage, connect);
  279.  
  280.             SqliteParameter p1 = new();
  281.             p1.ParameterName = "@ID_Person";
  282.             p1.Value = identify;
  283.             com.Parameters.Add(p1);
  284.  
  285.             connect.Open();
  286.             SqliteDataReader reader = com.ExecuteReader();
  287.             if (reader.HasRows)
  288.             {
  289.                 while (reader.Read())
  290.                 {
  291.                     Adressdatenliste.Add(new Adressdaten
  292.                     {
  293.                         ID_Adresse = reader.GetString(reader.GetOrdinal("ID_Adresse")),
  294.                         Straße = reader.GetString(reader.GetOrdinal("Straße")),
  295.                         Hausnummer = reader.GetString(reader.GetOrdinal("Hausnummer")),
  296.                         Plz = reader.GetString(reader.GetOrdinal("Postleitzahl")),
  297.                         Ort = reader.GetString(reader.GetOrdinal("Ort")),
  298.                         Land = reader.GetString(reader.GetOrdinal("Land")),
  299.                         AdressTyp = reader.GetString(reader.GetOrdinal("Typ_Name"))
  300.                         //Etage = reader.GetString(reader.GetOrdinal("Etage")),
  301.                         //Abteilung = reader.GetString(reader.GetOrdinal("Abteilung")),
  302.                         //Gebäude = reader.GetString(reader.GetOrdinal("Gebäude")),
  303.                     });
  304.                 }
  305.             }
  306.         }
  307.  
  308.         private void MailAdressDatenabfrage(string identify)
  309.         {
  310.             SqliteConnection connect = zugriff.connect();
  311.             string abfrage = "Select e.Mailadresse, mt.Typ_Art_Mail From  EMail e " +
  312.                 "JOIN EMail_Typ mt ON e.ID_Email_Typ = mt.ID_Email_Typ " +
  313.                 "Where e.ID_Person = @Person";
  314.             SqliteCommand com = new(abfrage, connect);
  315.  
  316.             SqliteParameter p1 = new();
  317.             p1.ParameterName = "@Person";
  318.             p1.Value = identify;
  319.             com.Parameters.Add(p1);
  320.  
  321.  
  322.  
  323.             connect.Open();
  324.  
  325.             SqliteDataReader reader = com.ExecuteReader();
  326.             if (reader.HasRows)
  327.             {
  328.                 while (reader.Read())
  329.                 {
  330.                     Maildata.Add(new MailDaten
  331.                     {
  332.                         Mailadresse = reader.GetString(reader.GetOrdinal("Mailadresse")),
  333.                         Mailtyp = reader.GetString(reader.GetOrdinal("Typ_Art_Mail"))
  334.                     });
  335.                 }
  336.             }
  337.         }
  338.  
  339.         private void KontaktDatenabfrage(string identify)
  340.         {
  341.             SqliteConnection connect = zugriff.connect();
  342.             string abfrage = "Select t.Nummer,  Typ_Art From Telefon t " +
  343.                 "JOIN Telefon_Typ tt ON t.ID_Telefon_Typ = tt.ID_Telefon_Typ " +
  344.                 "Where t.ID_Person = @Person";
  345.             SqliteCommand com = new(abfrage, connect);
  346.  
  347.             SqliteParameter p1 = new();
  348.             p1.ParameterName = "@Person";
  349.             p1.Value = identify;
  350.             com.Parameters.Add(p1);
  351.  
  352.  
  353.  
  354.             connect.Open();
  355.  
  356.             SqliteDataReader reader = com.ExecuteReader();
  357.             if (reader.HasRows)
  358.             {
  359.                 while (reader.Read())
  360.                 {
  361.                     Kontaktdatenliste.Add(new TelefonDaten
  362.                     {
  363.                         Telefonnummer = reader.GetString(reader.GetOrdinal("Nummer")),
  364.                         Nummertyp = reader.GetString(reader.GetOrdinal("Typ_Art")),
  365.  
  366.                     });
  367.                 }
  368.             }
  369.         }
  370.         /// <summary>
  371.         /// Speichern von Änderungen an Pesonendaten und Adressen
  372.         /// </summary>
  373.         private void Datenänderungspeichern()
  374.         {
  375.  
  376.             string Update = "Update Person Set Vorname = @Vorname, Nachname = @Nachname, Geburtsdatum = @Geburtsdatum WHERE ID_Person = @ID_Person ";
  377.             SqliteConnection connect = zugriff.connect();
  378.             SqliteCommand com = new(Update, connect);
  379.  
  380.             SqliteParameter vn = new();
  381.             vn.ParameterName = "@Vorname";
  382.             vn.Value = PersData.Vorname;
  383.             com.Parameters.Add(vn);
  384.  
  385.             SqliteParameter nn = new();
  386.             nn.ParameterName = "@Nachname";
  387.             nn.Value = PersData.Nachname;
  388.             com.Parameters.Add(nn);
  389.  
  390.             SqliteParameter gd = new();
  391.             gd.ParameterName = "@Geburtsdatum";
  392.             gd.Value = PersData.Geburtsdatum;
  393.             com.Parameters.Add(gd);
  394.  
  395.             SqliteParameter id = new();
  396.             id.ParameterName = "@ID_Person";
  397.             id.Value = PersData.ID;
  398.             com.Parameters.Add(id);
  399.  
  400.             connect.Open();
  401.             com.ExecuteNonQuery();
  402.             connect.Close();
  403.  
  404.             Safesucces?.Invoke(this, EventArgs.Empty);
  405.  
  406.         }
  407.  
  408.         public void Adressänderungspeichern()
  409.         {
  410.             string Update = "Update Adresse Set Straße = @Str, Hausnummer = @HNr, Postleitzahl = @PLZ, Ort = @Ort, Land = @Land WHERE ID_Adresse = @ID_Adresse";
  411.             SqliteConnection con = zugriff.connect();
  412.             SqliteCommand com = new(Update, con);
  413.  
  414.             SqliteParameter st = new();
  415.             st.ParameterName = "@Str";
  416.             st.Value = AddData.Straße;
  417.             com.Parameters.Add(st);
  418.  
  419.             SqliteParameter hn = new();
  420.             hn.ParameterName = "@HNr";
  421.             hn.Value = AddData.Hausnummer;
  422.             com.Parameters.Add(hn);
  423.  
  424.             SqliteParameter pl = new();
  425.             pl.ParameterName = "@PLZ";
  426.             pl.Value = AddData.Plz;
  427.             com.Parameters.Add(pl);
  428.  
  429.             SqliteParameter or = new();
  430.             or.ParameterName = "@Ort";
  431.             or.Value = AddData.Ort;
  432.             com.Parameters.Add(or);
  433.  
  434.             SqliteParameter la = new();
  435.             la.ParameterName = "@Land";
  436.             la.Value = AddData.Land;
  437.             com.Parameters.Add(la);
  438.  
  439.             SqliteParameter id = new();
  440.             id.ParameterName = "@ID_Adresse";
  441.             id.Value = AddData.ID_Adresse;
  442.             com.Parameters.Add(id);
  443.  
  444.             con.Open();
  445.             com.ExecuteNonQuery();
  446.             con.Close();
  447.  
  448.             Safesucces?.Invoke(this, EventArgs.Empty);
  449.         }
  450.  
  451.         public void NeueAdresseSpeichern()
  452.         {
  453.             string insert = "Insert Into Adresse(Straße, Hausnummer, Postleitzahl, Ort, Land) Values(@str, @hnr, @plz, @ort, @land)";
  454.             SqliteConnection connect = zugriff.connect();
  455.             SqliteCommand com = new(insert, connect);
  456.  
  457.             SqliteParameter param = new();
  458.             param.ParameterName = "@str";
  459.             param.Value = AddData.Straße;
  460.             com.Parameters.Add(param);
  461.  
  462.             SqliteParameter param2 = new();
  463.             param2.ParameterName = "@hnr";
  464.             param2.Value = AddData.Hausnummer;
  465.             com.Parameters.Add(param2);
  466.  
  467.             SqliteParameter param3 = new();
  468.             param3.ParameterName = "@plz";
  469.             param3.Value = AddData.Plz;
  470.             com.Parameters.Add(param3);
  471.  
  472.             SqliteParameter param4 = new();
  473.             param4.ParameterName = "@ort";
  474.             param4.Value = AddData.Ort;
  475.             com.Parameters.Add(param4);
  476.  
  477.             SqliteParameter param5 = new();
  478.             param5.ParameterName = "@land";
  479.             param5.Value = AddData.Land;
  480.             com.Parameters.Add(param5);
  481.  
  482.  
  483.             connect.Open();
  484.             com.ExecuteNonQuery();
  485.             connect.Close();
  486.  
  487.  
  488.             GetIDAdress();
  489.             SchreibePersonAdresse();
  490.  
  491.  
  492.             Safesucces?.Invoke(this, EventArgs.Empty);
  493.  
  494.  
  495.  
  496.         }
  497.  
  498.         public string ID_Adresse { get; set; }
  499.  
  500.         public void GetIDAdress()
  501.         {
  502.             SqliteConnection connect = zugriff.connect();
  503.             string abfrage = "Select ID_Adresse FROM Adresse Where ID_Adresse = (Select max(ID_Adresse) FROM Adresse)";
  504.  
  505.             SqliteCommand com2 = new(abfrage, connect);
  506.             connect.Open();
  507.             SqliteDataReader reader = com2.ExecuteReader();
  508.             if (reader.HasRows)
  509.             {
  510.                 while (reader.Read())
  511.                 { ID_Adresse = reader.GetString(reader.GetOrdinal("ID_Adresse")); }
  512.             }
  513.             connect.Close();
  514.  
  515.         }
  516.  
  517.         public void SchreibePersonAdresse()
  518.         {
  519.             SqliteConnection connect = zugriff.connect();
  520.             string schreibedaten = "Insert into Person_Adresse(ID_Person, ID_Adresse, ID_Adress_Typ) Values(@idpers, @idaddr, @id_ad_typ)";
  521.             SqliteCommand com3 = new(schreibedaten, connect);
  522.             SqliteParameter p1 = new();
  523.             p1.ParameterName = "@idpers";
  524.             p1.Value = PersData.ID;
  525.             com3.Parameters.Add(p1);
  526.  
  527.             SqliteParameter p2 = new();
  528.             p2.ParameterName = "@idaddr";
  529.             p2.Value = ID_Adresse;
  530.             com3.Parameters.Add(p2);
  531.  
  532.             SqliteParameter p3 = new();
  533.             p3.ParameterName = "@id_ad_typ";
  534.             p3.Value = "1";
  535.             com3.Parameters.Add(p3);
  536.  
  537.  
  538.             connect.Open();
  539.             com3.ExecuteNonQuery();
  540.             connect.Close();
  541.         }
  542.  
  543.         public void Datenspeichern()
  544.         {
  545.             if (NeuerDatensatz)
  546.             {
  547.  
  548.                 NeueAdresseSpeichern();
  549.             }
  550.             else
  551.             {
  552.                 Datenänderungspeichern();
  553.                 Adressänderungspeichern();
  554.  
  555.             }
  556.         }
  557.  
  558.         #endregion
  559.     }
  560. }
  561.  
RAW Paste Data