Exemple #1
0
 internal void NeuerVerbrauch(Abrechnung abrechnung, Verbrauch verbrauch)
 {
     abrechnung.Verbrauche.Add(verbrauch);
     verbrauch.Abrechnung = abrechnung;
     Kontext.SaveChanges();
     VerbrauchHinzugefügt?.Invoke(verbrauch);
 }
        public void FügeHinzu(Abrechnung abrechnung, ICollection <Produkt> produkte)
        {
            produkte = produkte.Except(abrechnung.Produkte).ToList();
            if (produkte.Count == 0)
            {
                return;
            }

            using (var transaktion = Kontext.Database.BeginOrReuseTransaction())
            {
                var verkaufsprodukte = produkte.Select(p => new Verkaufsprodukt()
                {
                    Produkt = p, Bestand = 0, Verkaufspreis = p.AktuellerVerkaufspreis
                }).ToList();
                Verbrauchsteuerung.NeueVerbrauche(abrechnung, verkaufsprodukte.SelectMany(p => abrechnung.Benutzer.Select(b => new Verbrauch()
                {
                    Benutzer = b, Verkaufsprodukt = p, AnzahlFlaschen = 0
                })).ToList());
                Verkaufsproduktsteuerung.NeueVerkaufsprodukte(abrechnung, verkaufsprodukte);

                BearbeiteAbrechnung(abrechnung);

                transaktion?.Commit();
            }
        }
 public VerkaufProxy(Abrechnung abrechnung, ICollection <BenutzerProxy> proxies)
 {
     this.abrechnung     = abrechnung;
     verkäufe            = abrechnung.BerechneVerbrauche();
     verbrauchPreisTotal = abrechnung.Verbrauche.Select(v => v.Verkaufsprodukt.Verkaufspreis * v.AnzahlFlaschen).Sum();
     gesamtSchulden      = proxies.Select(p => p.NeuesGuthabenDouble).Sum();
 }
 public void Entferne(Abrechnung abrechnung, Einkauf einkauf)
 {
     abrechnung.Einkäufe.Remove(einkauf);
     einkauf.Abrechnung = null;
     BearbeiteAbrechnung(abrechnung);
     Einkaufsteuerung.BearbeiteEinkauf(einkauf);
 }
Exemple #5
0
        private void AbrechnungBearbeitet(Abrechnung abrechnung)
        {
            if (abrechnung != Abrechnung)
            {
                return;
            }

            Fülle();
        }
 public void FügeHinzu(Abrechnung abrechnung, Benutzer benutzer)
 {
     abrechnung.Benutzer.Add(benutzer);
     Verbrauchsteuerung.NeueVerbrauche(abrechnung, abrechnung.Verkaufsprodukte.Select(p => new Verbrauch()
     {
         Benutzer = benutzer, Verkaufsprodukt = p, AnzahlFlaschen = 0
     }).ToList());
     BearbeiteAbrechnung(abrechnung);
 }
 public BenutzerProxy(Abrechnung abrechnung, Benutzer benutzer, double verluste)
 {
     this.abrechnung = abrechnung;
     this.benutzer   = benutzer;
     verbrauche      = abrechnung.Verkaufsprodukte.ToDictionary(p => p.Produkt, p => abrechnung.Verbrauche.Single(v => v.Verkaufsprodukt == p && v.Benutzer == benutzer));
     verbrauchKosten = verbrauche.Values.Select(v => v.AnzahlFlaschen * v.Verkaufsprodukt.Verkaufspreis).Sum();
     zahlung         = abrechnung.Gebucht ? abrechnung.Zahlungen.Single(z => z.Benutzer == benutzer) : null;
     verlustKosten   = verluste;
 }
Exemple #8
0
        private void Abrechnungssteuerung_AbrechnungVerändert(Abrechnung abrechnung)
        {
            if (abrechnung != Abrechnung)
            {
                return;
            }

            Fülle();
        }
 public void FügeHinzu(Abrechnung abrechnung, ICollection <Benutzer> benutzer)
 {
     abrechnung.Benutzer.AddRange(benutzer);
     Verbrauchsteuerung.NeueVerbrauche(abrechnung, abrechnung.Verkaufsprodukte.SelectMany(p => benutzer.Select(b => new Verbrauch()
     {
         Benutzer = b, Verkaufsprodukt = p, AnzahlFlaschen = 0
     })).ToList());
     BearbeiteAbrechnung(abrechnung);
 }
Exemple #10
0
 internal void NeueVerbrauche(Abrechnung abrechnung, ICollection <Verbrauch> verbrauche)
 {
     abrechnung.Verbrauche.AddRange(verbrauche);
     foreach (var verbrauch in verbrauche)
     {
         verbrauch.Abrechnung = abrechnung;
         VerbrauchHinzugefügt?.Invoke(verbrauch);
     }
     Kontext.SaveChanges();
 }
Exemple #11
0
        public Konfigurationsansicht()
        {
            InitializeComponent();

            AbrechnungBox.DisplayMember = "Name";
            DummyAbrechnung             = new Abrechnung()
            {
                Name = "(keine)"
            };
        }
        private void Aktualisiere(Abrechnung abrechnung = null)
        {
            if (abrechnung != null && abrechnung != Abrechnung)
            {
                return;
            }

            FülleKnöpfe();

            Text = Abrechnung.Name;
        }
        public void BucheAbrechnung(Abrechnung abrechnung)
        {
            using (var transaktion = Kontext.Database.BeginOrReuseTransaction())
            {
                var zahlungen = abrechnung.Buche();
                zahlungen.ForEach(z => Zahlungssteuerung.NeueZahlung(z));

                transaktion?.Commit();
            }
            AbrechnungGebucht?.Invoke(abrechnung);
        }
        public void Entferne(Abrechnung abrechnung, Produkt produkt)
        {
            if (!KannEntferntWerden(abrechnung, produkt))
            {
                return;
            }

            Verbrauchsteuerung.LöscheVerbrauche(abrechnung.Verbrauche.Where(v => v.Verkaufsprodukt.Produkt == produkt).ToList());
            Verkaufsproduktsteuerung.LöscheVerkaufsprodukt(abrechnung.Verkaufsprodukte.Single(b => b.Produkt == produkt));
            BearbeiteAbrechnung(abrechnung);
        }
        internal void NeuesVerkaufsprodukt(Abrechnung abrechnung, Verkaufsprodukt verkaufsprodukt)
        {
            if (abrechnung.Gebucht)
            {
                throw new InvalidOperationException("Zu gebuchten Abrechnungen können keine Bestände mehr hinzugefügt werden.");
            }

            verkaufsprodukt.Abrechnung = abrechnung;
            abrechnung.Verkaufsprodukte.Add(verkaufsprodukt);
            Kontext.SaveChanges();
            VerkaufsproduktHinzugefügt?.Invoke(verkaufsprodukt);
        }
        public void Entferne(Abrechnung abrechnung, ICollection <Benutzer> benutzer)
        {
            foreach (var ben in benutzer)
            {
                abrechnung.Benutzer.Remove(ben);
            }

            var hashBenutzer = benutzer.ToHashSet(); // höhöhö

            Verbrauchsteuerung.LöscheVerbrauche(abrechnung.Verbrauche.Where(v => hashBenutzer.Contains(v.Benutzer)).ToList());
            BearbeiteAbrechnung(abrechnung);
        }
 public void FügeHinzu(Abrechnung abrechnung, Einkauf einkauf)
 {
     using (var transaktion = Kontext.Database.BeginOrReuseTransaction())
     {
         abrechnung.Einkäufe.Add(einkauf);
         einkauf.Abrechnung = abrechnung;
         FügeHinzu(abrechnung, einkauf.Positionen.Select(p => p.Kastengröße.Produkt).Distinct().ToList());
         BearbeiteAbrechnung(abrechnung);
         Einkaufsteuerung.BearbeiteEinkauf(einkauf);
         transaktion?.Commit();
     }
 }
        private void FülleAbrechnungen(Abrechnung abrechnung = null)
        {
            if (abrechnung == null)
            {
                Abrechnungsliste.SetObjects(abrechnungssteuerung.Abrechnungen.OrderByDescending(x => x.Startzeitpunkt).Take(8).ToList());
            }
            else
            {
                Abrechnungsliste.RefreshObject(abrechnung);
            }
            StatusSpalte.AutoResize(ColumnHeaderAutoResizeStyle.ColumnContent);

            NeueAbrechnungKnopf.Enabled = !abrechnungssteuerung.Abrechnungen.Any(a => !a.Gebucht);
        }
        public void Entferne(Abrechnung abrechnung, ICollection <Einkauf> einkäufe)
        {
            using (var transaktion = Kontext.Database.BeginOrReuseTransaction())
            {
                foreach (var einkauf in einkäufe)
                {
                    abrechnung.Einkäufe.Remove(einkauf);
                    einkauf.Abrechnung = null;
                    Einkaufsteuerung.BearbeiteEinkauf(einkauf);
                }
                BearbeiteAbrechnung(abrechnung);

                transaktion?.Commit();
            }
        }
        internal void NeueVerkaufsprodukte(Abrechnung abrechnung, ICollection <Verkaufsprodukt> verkaufsprodukte)
        {
            if (abrechnung.Gebucht)
            {
                throw new InvalidOperationException("Zu gebuchten Abrechnungen können keine Bestände mehr hinzugefügt werden.");
            }

            foreach (var verkaufsprodukt in verkaufsprodukte)
            {
                verkaufsprodukt.Abrechnung = abrechnung;
                abrechnung.Verkaufsprodukte.Add(verkaufsprodukt);
                VerkaufsproduktHinzugefügt?.Invoke(verkaufsprodukt);
            }
            Kontext.SaveChanges();
        }
        public void FügeHinzu(Abrechnung abrechnung, ICollection <Einkauf> einkäufe)
        {
            using (var transaktion = Kontext.Database.BeginOrReuseTransaction())
            {
                abrechnung.Einkäufe.AddRange(einkäufe);

                foreach (var einkauf in einkäufe)
                {
                    einkauf.Abrechnung = abrechnung;
                    Einkaufsteuerung.BearbeiteEinkauf(einkauf);
                }
                FügeHinzu(abrechnung, einkäufe.SelectMany(e => e.Positionen).Select(p => p.Kastengröße.Produkt).Distinct().ToList());
                BearbeiteAbrechnung(abrechnung);

                transaktion?.Commit();
            }
        }
        public void Entferne(Abrechnung abrechnung, ICollection <Produkt> produkte)
        {
            produkte = produkte.Except(BenötigteProdukte(abrechnung)).ToList();
            if (produkte.Count == 0)
            {
                return;
            }

            using (var transaktion = Kontext.Database.BeginOrReuseTransaction())
            {
                var hashProdukte = produkte.ToHashSet(); // höhöhöhöhöhö
                Verbrauchsteuerung.LöscheVerbrauche(abrechnung.Verbrauche.Where(v => hashProdukte.Contains(v.Verkaufsprodukt.Produkt)).ToList());
                Verkaufsproduktsteuerung.LöscheVerkaufsprodukte(abrechnung.Verkaufsprodukte.Where(b => hashProdukte.Contains(b.Produkt)).ToList());
                BearbeiteAbrechnung(abrechnung);

                transaktion?.Commit();
            }
        }
Exemple #23
0
        /// <summary>
        /// Öffnet den Abrechnungs dialog und resettet anschließend die Abrechnungsliste
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private void Button_Click_1(object sender, RoutedEventArgs e)
        {
            double Kosten = 0.0;

            foreach (var Item in ProductList.Items)
            {
                var Product = Item as Core.Product;
                Kosten += Product.Price;
            }
            Abrechnung abrechnung = new Abrechnung(Kosten);

            abrechnung.ShowDialog();
            var Man = Core.ProductManager.GetManager();

            Man.BillProducts.Clear();
            ProductList.ItemsSource = Man.BillProducts;
            UpdateDisplay();
            // TODO: Rechnung mit passender Steuer in Datenbank schreiben.
        }
        public void FügeHinzu(Abrechnung abrechnung, Produkt produkt)
        {
            if (abrechnung.Produkte.Contains(produkt))
            {
                return;
            }

            var verkaufsprodukt = new Verkaufsprodukt()
            {
                Produkt = produkt, Bestand = 0, Verkaufspreis = produkt.AktuellerVerkaufspreis
            };

            Verbrauchsteuerung.NeueVerbrauche(abrechnung, abrechnung.Benutzer.Select(b => new Verbrauch()
            {
                Benutzer = b, Verkaufsprodukt = verkaufsprodukt, AnzahlFlaschen = 0
            }).ToList());
            Verkaufsproduktsteuerung.NeuesVerkaufsprodukt(abrechnung, verkaufsprodukt);
            BearbeiteAbrechnung(abrechnung);
        }
        public void LöscheAbrechnung(Abrechnung abrechnung)
        {
            if (abrechnung.Gebucht)
            {
                throw new InvalidOperationException("Diese Abrechnung kann nicht gelöscht werden, sie ist bereits gebucht.");
            }

            using (var transaktion = Kontext.Database.BeginOrReuseTransaction())
            {
                Entferne(abrechnung, abrechnung.Benutzer.ToList());
                Entferne(abrechnung, abrechnung.Einkäufe.ToList());
                Entferne(abrechnung, abrechnung.Produkte.ToList());

                Kontext.Abrechnungen.Remove(abrechnung);
                Kontext.SaveChanges();

                transaktion?.Commit();
            }
            AbrechnungGelöscht?.Invoke(abrechnung);
        }
        private void NeueAbrechnungKnopf_Click(object sender, EventArgs e)
        {
            var letzteGebuchte = abrechnungssteuerung.Abrechnungen.Where(a => a.Gebucht).OrderByDescending(a => a.Endzeitpunkt).FirstOrDefault();

            var jetzt = DateTime.Now;

            var abrechnung = new Abrechnung
            {
                Startzeitpunkt = letzteGebuchte?.Endzeitpunkt ?? jetzt,
                Endzeitpunkt   = jetzt,
                Name           = "Abrechnung " + jetzt.ToString("MMMM"),
            };

            abrechnung.AusgangsBestandAbrechnung = abrechnungssteuerung.AusgangsBestandAbrechnungen(abrechnung).OrderByDescending(a => a.Endzeitpunkt).FirstOrDefault();
            abrechnung.Benutzer.AddRange(abrechnungssteuerung.Benutzersteuerung.Benutzer.Where(b => b.Aktiv));

            abrechnungssteuerung.NeueAbrechnung(abrechnung);

            Abrechnungsfenster.Abrechnung = abrechnung;
            Abrechnungsfenster.Show();
            Abrechnungsfenster.Focus();
        }
 public void Entferne(Abrechnung abrechnung, Benutzer benutzer)
 {
     abrechnung.Benutzer.Remove(benutzer);
     Verbrauchsteuerung.LöscheVerbrauche(abrechnung.Verbrauche.Where(v => v.Benutzer == benutzer).ToList());
     BearbeiteAbrechnung(abrechnung);
 }
 public void NeueAbrechnung(Abrechnung abrechnung)
 {
     Kontext.Abrechnungen.Add(abrechnung);
     Kontext.SaveChanges();
     AbrechnungHinzugefügt?.Invoke(abrechnung);
 }
 public void BearbeiteAbrechnung(Abrechnung abrechnung)
 {
     Kontext.SaveChanges();
     AbrechnungVerändert?.Invoke(abrechnung);
 }
 public IEnumerable <Produkt> BenötigteProdukte(Abrechnung abrechnung) => abrechnung.Einkäufe.SelectMany(e => e.Positionen).Select(p => p.Kastengröße.Produkt).Distinct();