FahrzeugVerwaltung/FahrzeugProjekt/FahrzeugAnzeigenWindow.xaml.cs

using System.IO;
using System.Windows;
using Microsoft.EntityFrameworkCore;
using Microsoft.Win32;
using PdfSharp.Drawing;
using PdfSharp.Fonts;
using PdfSharp.Pdf;

namespace FahrzeugProjekt
{
    public partial class FahrzeugeAnzeigenWindow : Window
    {
        private FahrzeugProjektKontext Kontext;
        private List<Fahrzeug> alleFahrzeuge;
        public MainWindow main { get; set; }

        public FahrzeugeAnzeigenWindow(FahrzeugProjektKontext dbKontext)
        {
            InitializeComponent();
            this.WindowState = WindowState.Maximized;
            Kontext = dbKontext;

            // font resolver
            GlobalFontSettings.FontResolver = new SimpleFontResolver();


            this.Loaded += (sender, e) =>
            {
                FahrzeugeDatenLaden();
                Vorbereitung();
            };
        }

        private void FahrzeugeDatenLaden()
        {
            alleFahrzeuge = Kontext.Fahrzeuge
                .Include(f => f.Modell)
                    .ThenInclude(m => m.Marke)
                .ToList();

            dgFahrzeuge.ItemsSource = alleFahrzeuge;
        }

        private void Vorbereitung()
        {
            // Marken für Filter laden
            List<Marke> markenFürFilter = new List<Marke> { new Marke { MarkeID = -1, Markenname = "Alle Marken" } };
            List<Marke> alleMarken = Kontext.Marken.ToList();
            markenFürFilter.AddRange(alleMarken);
            cmbFilterMarke.ItemsSource = markenFürFilter;
            cmbFilterMarke.DisplayMemberPath = "Markenname";
            cmbFilterMarke.SelectedIndex = 0;

            // Alle Modelle für Filter laden
            List<Modell> modelleFürFilter = new List<Modell> { new Modell { ModellID = -1, Modellname = "Alle Modelle" } };
            List<Modell> alleModelle = Kontext.Modelle.ToList();
            modelleFürFilter.AddRange(alleModelle);
            cmbFilterModell.ItemsSource = modelleFürFilter;
            cmbFilterModell.DisplayMemberPath = "Modellname";
            cmbFilterModell.SelectedIndex = 0;

            // Kraftstoffe für Filter
            List<string> kraftstoffListe = new List<string> { "Alle", "Benzin", "Diesel", "Elektro", "Hybrid" };
            cmbFilterKraftstoff.ItemsSource = kraftstoffListe;
            cmbFilterKraftstoff.SelectedIndex = 0;

            // Getriebe für Filter
            List<string> getriebeListe = new List<string> { "Alle", "Manuell", "Automatik", "Halbautomatik" };
            cmbFilterGetriebe.ItemsSource = getriebeListe;
            cmbFilterGetriebe.SelectedIndex = 0;
        }

        private void Erstellen(object sender, RoutedEventArgs e)
        {
            int fahrzeugID = int.Parse(txtFahrzeugID.Text);

            Fahrzeug fahrzeug = alleFahrzeuge.FirstOrDefault(f => f.FahrzeugID == fahrzeugID);

            SaveFileDialog saveDialog = new SaveFileDialog
            {
                FileName = $"{fahrzeug.FahrzeugID}.pdf"
            };

            if (saveDialog.ShowDialog() == true)
            {
                CreateVehiclePDF(fahrzeug, saveDialog.FileName);
                MessageBox.Show("PDF erfolgreich erstellt!");
            }
        }

        private void CreateVehiclePDF(Fahrzeug fahrzeug, string filePath)
        {
            // PDF erstellen
            PdfDocument document = new PdfDocument();
            PdfPage page = document.AddPage();
            XGraphics gfx = XGraphics.FromPdfPage(page);
            XFont font = new XFont("Arial", 12);
            XFont titleFont = new XFont("Arial", 16);

            // start pos
            double yPos = 50;
            double lineHeight = 25;

            // Title
            gfx.DrawString("Fahrzeug Information", titleFont, XBrushes.Black, 50, yPos);
            yPos += lineHeight * 2;

            // Vehicle details
            gfx.DrawString($"Fahrzeug ID: {fahrzeug.FahrzeugID}", font, XBrushes.Black, 50, yPos);
            yPos += lineHeight;

            gfx.DrawString($"Marke: {fahrzeug.Modell?.Marke?.Markenname ?? "N/A"}", font, XBrushes.Black, 50, yPos);
            yPos += lineHeight;

            gfx.DrawString($"Modell: {fahrzeug.Modell?.Modellname ?? "N/A"}", font, XBrushes.Black, 50, yPos);
            yPos += lineHeight;

            gfx.DrawString($"Baujahr: {fahrzeug.Baujahr}", font, XBrushes.Black, 50, yPos);
            yPos += lineHeight;

            gfx.DrawString($"Kraftstoff: {fahrzeug.Kraftstoff ?? "N/A"}", font, XBrushes.Black, 50, yPos);
            yPos += lineHeight;

            gfx.DrawString($"Getriebe: {fahrzeug.Getriebe ?? "N/A"}", font, XBrushes.Black, 50, yPos);
            yPos += lineHeight;

            gfx.DrawString($"Kilometerstand: {fahrzeug.Kilometerstand} km", font, XBrushes.Black, 50, yPos);

            // Save 
            document.Save(filePath);
            document.Close();
        }

        private void Aktualisieren(object sender, RoutedEventArgs e)
        {
            List<Fahrzeug> ergebnisse = alleFahrzeuge.ToList();

            // Marken Filter
            Marke ausgewählteMarke = cmbFilterMarke.SelectedItem as Marke;
            if (ausgewählteMarke.MarkeID != -1)
            {
                ergebnisse = ergebnisse
                    .Where(f => f.Modell.MarkeID == ausgewählteMarke.MarkeID)
                    .ToList();
            }

            // Modell Filter
            Modell ausgewähltesModell = cmbFilterModell.SelectedItem as Modell;
            if (ausgewähltesModell.ModellID != -1)
            {
                ergebnisse = ergebnisse
                    .Where(f => f.ModellID == ausgewähltesModell.ModellID)
                    .ToList();
            }

            // Kraftstoff Filter
            if (cmbFilterKraftstoff.SelectedItem.ToString() != "Alle")
            {
                string ausgewählterKraftstoff = cmbFilterKraftstoff.SelectedItem.ToString();
                ergebnisse = ergebnisse
                    .Where(f => f.Kraftstoff == ausgewählterKraftstoff)
                    .ToList();
            }

            // Getriebe Filter
            if (cmbFilterGetriebe.SelectedItem.ToString() != "Alle")
            {
                string ausgewähltesGetriebe = cmbFilterGetriebe.SelectedItem.ToString();
                ergebnisse = ergebnisse
                    .Where(f => f.Getriebe == ausgewähltesGetriebe)
                    .ToList();
            }

            dgFahrzeuge.ItemsSource = ergebnisse;
            this.Title = $"Fahrzeuge Anzeigen ({ergebnisse.Count} von {alleFahrzeuge.Count})";
        }

        private void Zurücksetzen(object sender, RoutedEventArgs e)
        {
            cmbFilterMarke.SelectedIndex = 0;
            cmbFilterModell.SelectedIndex = 0;
            cmbFilterKraftstoff.SelectedIndex = 0;
            cmbFilterGetriebe.SelectedIndex = 0;

            dgFahrzeuge.ItemsSource = alleFahrzeuge;
            this.Title = "Fahrzeuge Anzeigen";
        }

        private void Schließ(object sender, RoutedEventArgs e)
        {
            this.Close();
            main.Show();
        }
    }

    // Font resolver 
    public class SimpleFontResolver : IFontResolver
    {
        public FontResolverInfo ResolveTypeface(string familyName, bool isBold, bool isItalic)
        {
            return new FontResolverInfo("Arial");
        }

        public byte[] GetFont(string faceName)
        {
            string windowsFontsPath = Path.Combine(
            Environment.GetFolderPath(Environment.SpecialFolder.Windows), "Fonts");
            string fontPath = Path.Combine(windowsFontsPath, "arial.ttf");

            return File.ReadAllBytes(fontPath);

        }

    }
}