1537 lines
56 KiB
C#
1537 lines
56 KiB
C#
using BrightIdeasSoftware;
|
||
using DatenDB;
|
||
using Deckungsbeitrag.AA_Forms;
|
||
using Deckungsbeitrag.AA_Klassen;
|
||
using Deckungsbeitrag.Properties;
|
||
using Deckungsbeitrag.UserControls;
|
||
using Microsoft.VisualBasic;
|
||
using Npgsql;
|
||
using System;
|
||
using System.Collections.Generic;
|
||
using System.Configuration;
|
||
using System.Data;
|
||
using System.Diagnostics;
|
||
using System.Diagnostics.Eventing.Reader;
|
||
using System.Drawing;
|
||
using System.IO;
|
||
using System.Linq;
|
||
using System.Net.Sockets;
|
||
using System.Reflection;
|
||
using System.Text;
|
||
using System.Threading.Tasks;
|
||
using System.Windows.Forms;
|
||
using System.Windows.Forms.DataVisualization.Charting;
|
||
using System.Xml.Resolvers;
|
||
using TrelloIntegration;
|
||
using ZXing;
|
||
|
||
namespace Deckungsbeitrag
|
||
{
|
||
public enum ListenArt
|
||
{
|
||
Auftragliste = 0,
|
||
Sonderliste = 1,
|
||
Geschäftliste = 2,
|
||
Suchliste = 3,
|
||
Rampenliste = 4,
|
||
Vorbereitetliste = 5
|
||
}
|
||
|
||
|
||
public partial class FormExpedit : Form
|
||
{
|
||
#region Properties
|
||
private readonly UserSettingsManager _settings = new UserSettingsManager();
|
||
private readonly ToolTip cellTooltip = new ToolTip();
|
||
public Meldungen fehlermeldung = new Meldungen();
|
||
public Image etikett = null;
|
||
public Auftrag auftrag;
|
||
public Auftrag NeuerAuftrag; //NEU FÜR UPDATE
|
||
public Benutzer benutzer;
|
||
public Kunde kunde;
|
||
DateTime? letzterLiefertag = null;
|
||
readonly bool nocont = false;
|
||
private readonly Meldungen meldung = new Meldungen();
|
||
private List<KundeArtikel> artikelListe;
|
||
private List<Auftrag> suchliste;
|
||
int? altecontclean = null;
|
||
private readonly Timer timer1 = new Timer(); // Timer für Nachwäsche
|
||
private readonly Timer timer2 = new Timer(); // Timer für Refresh Auftragliste
|
||
private readonly Screen[] screens;
|
||
private Point itemlocation;
|
||
private const int MAX_FAILURES = 3;
|
||
private readonly OnboardingSchritt onBoardingArt = OnboardingSchritt.Expedit;
|
||
private List<View_Auftrag_Expedit> listAuftragToday;
|
||
private List<View_Auftrag_Expedit> listAuftragGeschaeft;
|
||
private List<View_Auftrag_Expedit> listVorbereitet;
|
||
private List<View_Auftrag_Expedit> listSonderAuftrag;
|
||
private List<View_Auftrag_Expedit> listRampe;
|
||
public TrelloCardClient _trelloClient;
|
||
private bool TrelloKarte = true;
|
||
#endregion
|
||
public FormExpedit(Benutzer benutzer)
|
||
{
|
||
InitializeComponent();
|
||
|
||
this.Text += " Version: " + Assembly.GetExecutingAssembly().GetName().Version.ToString();
|
||
this.benutzer = benutzer;
|
||
this.Text += " Benutzer: " + benutzer.Vorname + " " + benutzer.Nachname;
|
||
this.StartPosition = FormStartPosition.CenterScreen;
|
||
this.tabControlAuftragList.Visible = true;
|
||
}
|
||
public FormExpedit(Benutzer benutzer, Screen[] screens) : this(benutzer)
|
||
{
|
||
this.screens = screens;
|
||
foreach (Screen screen in screens)
|
||
{
|
||
if (screen.Primary)
|
||
{
|
||
if (screen.WorkingArea.Width < 1500) { this.objectListViewAuftrag.Font = new Font(this.objectListViewAuftrag.Font.FontFamily, 10); }
|
||
}
|
||
}
|
||
}
|
||
|
||
#region Form-Funktionen
|
||
private void FormExpedit_Load(object sender, EventArgs e)
|
||
{
|
||
this.UseWaitCursor = true;
|
||
this.SuspendLayout();
|
||
_settings.Load();
|
||
|
||
if (TrelloConfig.HasCredentials())
|
||
{
|
||
var apiKey = TrelloConfig.GetApiKey();
|
||
var token = TrelloConfig.GetToken();
|
||
_trelloClient = new TrelloCardClient(apiKey, token);
|
||
}
|
||
|
||
UCFeedback fb = new UCFeedback(this.benutzer);
|
||
this.Controls.Add(fb);
|
||
|
||
//Auftragslisten erstellen und in ObjectListViews laden.
|
||
// DB PARALLEL im Background (NON-BLOCKING!)
|
||
_ = Task.Run(async () =>
|
||
{
|
||
try
|
||
{
|
||
await Task.WhenAll(
|
||
GetAuftraegeAsync(null));
|
||
|
||
// UI-Update NACH Daten (Invoke!)
|
||
this.Invoke(new Action(() =>
|
||
{
|
||
// OLVs füllen
|
||
if (listAuftragToday.Count > 0) Load_OLV(this.objectListViewAuftrag, listAuftragToday);
|
||
if (listAuftragGeschaeft != null && listAuftragGeschaeft.Count > 0) Load_OLV(this.objectListViewGeschaeft, listAuftragGeschaeft);
|
||
if (listSonderAuftrag.Count > 0) Load_OLV(this.objectListViewSonder, listSonderAuftrag);
|
||
if (listVorbereitet != null && listVorbereitet.Count > 0) Load_OLV(this.objectListViewVorbereitet, listVorbereitet);
|
||
if (listRampe!= null && listRampe.Count > 0) Load_OLV(this.objectListViewRampe, listRampe);
|
||
|
||
// Controls aktivieren und deaktivieren nach BenutzerRolle
|
||
Enable_Controls();
|
||
|
||
}));
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
// Vermeide $ für C# älter
|
||
Random rnd = new Random();
|
||
int zahl = rnd.Next(1, 10001);
|
||
this.BeginInvoke(new Action(() => MessageBox.Show(string.Format($"Laden fehlgeschlagen. Leite den Fehler {zahl} an Kilian weiter. ", ex.Message))));
|
||
Program.AddFehler(this.benutzer, $"Fehler {zahl} - ex.Message", ex.StackTrace, null);
|
||
}
|
||
});
|
||
}
|
||
private void FormExpedit_FormClosing(object sender, FormClosingEventArgs e)
|
||
{
|
||
|
||
// === SPEICHERN DES OLV-STATUS ===
|
||
_settings.OLV_State = this.objectListViewAuftrag.SaveState();
|
||
_settings.OLV_Rampe_State = this.objectListViewRampe.SaveState();
|
||
_settings.OLV_Geschaeft_State = this.objectListViewGeschaeft.SaveState();
|
||
_settings.OLV_Sonder_State = this.objectListViewSonder.SaveState();
|
||
_settings.OLV_Vorbereitet_State = this.objectListViewVorbereitet.SaveState();
|
||
_settings.Save();
|
||
}
|
||
private void FormExpedit_Resize(object sender, EventArgs e)
|
||
{
|
||
this.tabControlAuftragList.Width = this.ClientSize.Width;
|
||
}
|
||
|
||
/// <summary>
|
||
/// Wenn FormExpedit angezeigt wird, wird die Location des FeedbackButtons berechnet.
|
||
/// </summary>
|
||
/// <param name="sender"></param>
|
||
/// <param name="e"></param>
|
||
private void FormExpedit_Shown(object sender, EventArgs e)
|
||
{
|
||
// Location des Feedback Buttons wird berechnet. (Screengröße ist hier klar)
|
||
UCFeedback fb = this.Controls.Find("feedback", false)[0] as UCFeedback;
|
||
Button btn = fb.Controls[0] as Button;
|
||
if (fb != null) fb.Location = new Point(this.ClientSize.Width - fb.Width, 0);
|
||
btn.BackColor = Program.Wirlblau;
|
||
btn.ForeColor = Color.White;
|
||
btn.FlatAppearance.BorderColor = Color.White;
|
||
fb.BringToFront();
|
||
|
||
//WindowState = FormWindowState.Maximized;
|
||
}
|
||
#endregion
|
||
|
||
#region Button_Click-Events
|
||
private async void ButtonNeuerAuftrag_Click(object sender, EventArgs e)
|
||
{
|
||
DialogResult result = DialogResult.Cancel;
|
||
AuftragTyp? auftragTyp = null;
|
||
result = MessageBox.Show("Welchen Auftrag möchtest du erstellen?\n\n[JA] => Geschäft\n[NEIN] => Standart", "FRAGE", MessageBoxButtons.YesNoCancel);
|
||
|
||
switch (result)
|
||
{
|
||
case DialogResult.Yes:
|
||
auftragTyp = AuftragTyp.Geschäft;
|
||
break;
|
||
case DialogResult.No:
|
||
auftragTyp = AuftragTyp.Standart;
|
||
break;
|
||
default:
|
||
return;
|
||
}
|
||
|
||
FormNeuerAuftrag neuerAuftrag = new FormNeuerAuftrag(benutzer, this.letzterLiefertag, auftragTyp);
|
||
if (neuerAuftrag.ShowDialog() == DialogResult.OK)
|
||
{
|
||
this.letzterLiefertag = neuerAuftrag.letzterLiefertag;
|
||
await GetAuftraegeAsync(ListenArt.Auftragliste);
|
||
await GetAuftraegeAsync(ListenArt.Geschäftliste);
|
||
//List<Auftrag> auftraglist = Auftrag.GetAuftragListToday(DateTime.Today);
|
||
OLV_SetObjects(this.objectListViewAuftrag, listAuftragToday);
|
||
OLV_SetObjects(this.objectListViewGeschaeft, listAuftragGeschaeft);
|
||
}
|
||
}
|
||
private void ButtonSWS_Drucken_Click(object sender, EventArgs e)
|
||
{
|
||
Kunde knd = Funktionen.KundenAuswahl();
|
||
if(knd != null) Funktionen.SWS_Drucken(null, knd, this);
|
||
}
|
||
private void ButtonEinstellung_Click(object sender, EventArgs e)
|
||
{
|
||
FormEinstellung einstellung = new FormEinstellung(this.benutzer);
|
||
einstellung.ShowDialog();
|
||
}
|
||
private void ButtonGetKundeVW_Click(object sender, EventArgs e)
|
||
{
|
||
FormKundeVW kundeVW = new FormKundeVW();
|
||
kundeVW.ShowDialog();
|
||
}
|
||
private void ButtonReklamation_Click(object sender, EventArgs e)
|
||
{
|
||
FormFehlmengeCount reklamation = new FormFehlmengeCount(this.benutzer);
|
||
reklamation.ShowDialog();
|
||
}
|
||
private void ButtonTourenListe_Click(object sender, EventArgs e)
|
||
{
|
||
List<Benutzer> fahrerliste = Benutzer.GetFahrerList();
|
||
Benutzer fahrer;
|
||
FormBenutzerVW benutzerVW = new FormBenutzerVW(fahrerliste);
|
||
if (benutzerVW.ShowDialog() == DialogResult.OK)
|
||
{
|
||
fahrer = benutzerVW.user;
|
||
}
|
||
else fahrer = null;
|
||
|
||
if (fahrer != null)
|
||
{
|
||
//List<Auftrag> auftragliste = Auftrag.GetTourenListe(fahrer);
|
||
//if (auftragliste.Count > 0) Funktionen.TourenListe_Drucken(auftragliste, fahrer, this, this.benutzer);
|
||
}
|
||
|
||
}
|
||
private void ButtonStats_Click(object sender, EventArgs e)
|
||
{
|
||
FormShowUserControl showGroupBox = new FormShowUserControl("Statistik", this.benutzer);
|
||
showGroupBox.ShowDialog();
|
||
}
|
||
private void ButtonEtikettenDrucken_Click(object sender, EventArgs e)
|
||
{
|
||
ObjectListView olv = (ObjectListView)this.tabControlAuftragList.SelectedTab.Controls[0];
|
||
if (olv.SelectedItems.Count == 0 || olv.SelectedItems.Count > 1) return;
|
||
View_Auftrag_Expedit view = (View_Auftrag_Expedit)olv.SelectedItem.RowObject;
|
||
Auftrag auftrag = Auftrag.GetAuftrag(view.AuftragID);
|
||
|
||
this.UseWaitCursor = true;
|
||
|
||
HandleEtikettClick(auftrag);
|
||
|
||
Neuladen_OLV(olv);
|
||
this.UseWaitCursor = false;
|
||
|
||
}
|
||
private void ButtonNW_Click(object sender, EventArgs e)
|
||
{
|
||
FormArtikelVW artikelVW = new FormArtikelVW(this.benutzer);
|
||
artikelVW.ShowDialog();
|
||
}
|
||
private void ContextMenuStripBearbeiten_Click(object sender, EventArgs e)
|
||
{
|
||
ObjectListView olv = (ObjectListView)this.tabControlAuftragList.SelectedTab.Controls[0];
|
||
ToolStripItem item = (ToolStripItem)sender;
|
||
string aspect = item.AccessibleName;
|
||
var col = olv.AllColumns.OfType<OLVColumn>().First(x => x.AspectName == aspect);
|
||
if (this.benutzer.Rolle == BenutzerRolle.Admin) col.IsEditable = true;
|
||
|
||
if (olv.SelectedItem != null)
|
||
{
|
||
TrelloKarte = true;
|
||
int idx = col.Index;
|
||
olv.StartCellEdit(olv.SelectedItem, idx);
|
||
}
|
||
|
||
}
|
||
private void ContextMenuStripAufgabeErledigt_Click(object sender, EventArgs e)
|
||
{
|
||
ObjectListView olv = (ObjectListView)this.tabControlAuftragList.SelectedTab.Controls[0];
|
||
// Überprüfung ob Click auf einem Item war.
|
||
if (olv.SelectedObject == null) return;
|
||
Auftrag _auftrag = Auftrag.GetAuftrag(((View_Auftrag_Expedit)olv.SelectedObject).AuftragID);
|
||
Kunde _kunde = Kunde.GetKunde(null, _auftrag.KundeID, null);
|
||
string name;
|
||
if (string.IsNullOrWhiteSpace(_kunde.Suchtext)) name = _kunde.KundeName;
|
||
else name = _kunde.Suchtext;
|
||
|
||
if (_auftrag.AufgabeID == null) return;
|
||
Aufgabe _aufgabe = Aufgabe.GetAufgabe(null, _auftrag.AufgabeID);
|
||
if (meldung.GetFrage(this, $"Hast du beim Kunden {name} die Aufgabe {_aufgabe.Bezeichnung} erledigt?", false) == DialogResult.Yes)
|
||
{
|
||
Aufgabe_erledigt(_auftrag, _kunde, name);
|
||
}
|
||
|
||
}
|
||
private void ContextMenuStripAuftragVerschieben_Click(object sender, EventArgs e)
|
||
{
|
||
ObjectListView olv = (ObjectListView)this.tabControlAuftragList.SelectedTab.Controls[0];
|
||
if (!olv.Name.Contains("Rampe")) return;
|
||
// Überprüfung ob Click auf einem Item war.
|
||
if (olv.SelectedObject == null) return;
|
||
Auftrag _auftrag = Auftrag.GetAuftrag(((View_Auftrag_Expedit)olv.SelectedObject).AuftragID);
|
||
|
||
if (_auftrag == null) return;
|
||
_auftrag.Status = AuftragStatus.Gewaschen;
|
||
_auftrag.Save();
|
||
|
||
Neuladen_OLV(olv);
|
||
}
|
||
private void ContextMenuStripAuftragDelete_Click(object sender, EventArgs e)
|
||
{
|
||
ObjectListView olv = (ObjectListView)this.tabControlAuftragList.SelectedTab.Controls[0];
|
||
// Überprüfung ob Click auf einem Item war.
|
||
if (olv.SelectedObject == null) return;
|
||
Auftrag _auftrag = Auftrag.GetAuftrag(((View_Auftrag_Expedit)olv.SelectedObject).AuftragID);
|
||
|
||
if (_auftrag == null) return;
|
||
string knd = ((View_Auftrag_Expedit)olv.SelectedObject).KundeName;
|
||
if (MessageBox.Show($"Möchtest du den Auftrag von {knd} mit Liefertag am {_auftrag.Liefertag} wirklich löschen?", "FRAGE", MessageBoxButtons.YesNo, MessageBoxIcon.Question) == DialogResult.No) return;
|
||
else
|
||
{
|
||
_auftrag.Delete();
|
||
Neuladen_OLV(olv);
|
||
}
|
||
}
|
||
private void ContextMenuStripAuftragInfo_Click(object sender, EventArgs e)
|
||
{
|
||
ObjectListView olv = (ObjectListView)this.tabControlAuftragList.SelectedTab.Controls[0];
|
||
// Überprüfung ob Click auf einem Item war.
|
||
if (olv.SelectedObject == null) return;
|
||
Auftrag _auftrag = Auftrag.GetAuftrag(((View_Auftrag_Expedit)olv.SelectedObject).AuftragID);
|
||
|
||
if (_auftrag == null) return;
|
||
|
||
FormShowUserControl showUserControl = new FormShowUserControl("AuftragInfo", this.benutzer, _auftrag);
|
||
showUserControl.Show();
|
||
|
||
}
|
||
|
||
#endregion
|
||
private void ContextMenuStripBearbeiten_DropDownOpening(object sender, EventArgs e)
|
||
{
|
||
ObjectListView olv = (ObjectListView)this.tabControlAuftragList.SelectedTab.Controls[0];
|
||
ToolStripMenuItem tsi = (ToolStripMenuItem)sender;
|
||
foreach (ToolStripDropDownItem item in tsi.DropDownItems)
|
||
{
|
||
string aspect = item.AccessibleName;
|
||
var col = olv.AllColumns.OfType<OLVColumn>().First(x => x.AspectName == aspect);
|
||
if (col.IsEditable) item.Enabled = true;
|
||
else item.Enabled = false;
|
||
}
|
||
}
|
||
private void ContextMenuStripExpedit_Opening(object sender, System.ComponentModel.CancelEventArgs e)
|
||
{
|
||
ObjectListView olv = (ObjectListView)this.tabControlAuftragList.SelectedTab.Controls[0];
|
||
olv.CellEditFinished += ObjectListViewAuftrag_CellEditFinished;
|
||
if (olv.SelectedObject == null) return;
|
||
Auftrag _auftrag = Auftrag.GetAuftrag(((View_Auftrag_Expedit)olv.SelectedObject).AuftragID);
|
||
|
||
// Überprüfen ob ObjectListView Rampe ist.
|
||
if (!olv.Name.Contains("Rampe")) this.auftragVerschiebenToolStripMenuItem.Enabled = false;
|
||
else this.auftragVerschiebenToolStripMenuItem.Enabled = true;
|
||
// Überprüfen ob Auftrag eine Aufgabe hat.
|
||
if (_auftrag.AufgabeID == null) this.aufgabeErledigtToolStripMenuItem.Enabled = false;
|
||
else this.aufgabeErledigtToolStripMenuItem.Enabled = true;
|
||
// Überprüfen ob User Admin ist.
|
||
if (this.benutzer.Rolle != BenutzerRolle.Admin & this.benutzer.Rolle != BenutzerRolle.Master) this.auftragLöschenToolStripMenuItem.Enabled = false;
|
||
else this.auftragLöschenToolStripMenuItem.Enabled = true;
|
||
}
|
||
|
||
#region ObjectListView-Events
|
||
|
||
private void Load_OLV(ObjectListView olv, List<View_Auftrag_Expedit> auftragliste)
|
||
{
|
||
this.UseWaitCursor = true;
|
||
|
||
// === LAYOUT & UPDATE PAUSIEREN ===
|
||
olv.BeginUpdate();
|
||
olv.SuspendLayout();
|
||
|
||
try
|
||
{
|
||
// === SPALTEN NUR EINMAL GENERIEREN (falls sinnvoll) ===
|
||
if (olv.AllColumns.Count == 0)
|
||
{
|
||
Generator.GenerateColumns(olv, typeof(View_Auftrag_Expedit), true);
|
||
ConfigureColumns(olv);
|
||
}
|
||
|
||
// === IMAGE-LIST (einmalig zentral konfigurieren, hier nur zuweisen) ===
|
||
Program.imagelist.ImageSize = new Size(24, 24);
|
||
olv.SmallImageList = Program.imagelist;
|
||
|
||
// === TOOLTIP-EVENT EINMALIG REGISTRIEREN ===
|
||
olv.CellToolTipShowing -= Olv_CellToolTipShowing;
|
||
olv.CellToolTipShowing += Olv_CellToolTipShowing;
|
||
|
||
// === DATEN LADEN ===
|
||
OLV_SetObjects(olv, auftragliste);
|
||
|
||
// === SORTIERUNG ===
|
||
var statusCol = olv.AllColumns.Cast<OLVColumn>().FirstOrDefault(c => c.Text == "Status");
|
||
var liefertagCol = olv.AllColumns.Cast<OLVColumn>().FirstOrDefault(c => c.Text == "Liefertag");
|
||
|
||
if (statusCol != null) olv.PrimarySortColumn = statusCol;
|
||
if (liefertagCol != null) olv.SecondarySortColumn = liefertagCol;
|
||
|
||
if (olv.Name.Contains("Rampe") && liefertagCol != null)
|
||
olv.Sort(liefertagCol);
|
||
else
|
||
olv.Sort();
|
||
|
||
// === SPALTEN JE NACH TAB/ROLLE ===
|
||
GetUnvisibleColumns(olv);
|
||
|
||
// === RESTORE OLV-STATUS ===
|
||
if (olv.Name.Contains("Auftrag")) this.objectListViewAuftrag.RestoreState(_settings.OLV_State);
|
||
if (olv.Name.Contains("Rampe")) this.objectListViewRampe.RestoreState(_settings.OLV_Rampe_State);
|
||
if (olv.Name.Contains("Vorbereitet")) this.objectListViewVorbereitet.RestoreState(_settings.OLV_Vorbereitet_State);
|
||
if (olv.Name.Contains("Sonder")) this.objectListViewSonder.RestoreState(_settings.OLV_Sonder_State);
|
||
if (olv.Name.Contains("Geschaeft")) this.objectListViewGeschaeft.RestoreState(_settings.OLV_Geschaeft_State);
|
||
|
||
// === SPALTENBREITE ANPASSEN ===
|
||
olv = Funktionen.Columns_Resize(null, olv).olv;
|
||
|
||
// === FILTER ===
|
||
olv.FilterMenuBuildStrategy = new MeinFilterMenu();
|
||
}
|
||
finally
|
||
{
|
||
olv.ResumeLayout();
|
||
olv.EndUpdate();
|
||
olv.Focus();
|
||
this.UseWaitCursor = false;
|
||
}
|
||
}
|
||
private void ConfigureColumns(ObjectListView olv)
|
||
{
|
||
var columns = olv.AllColumns.Cast<OLVColumn>().ToList();
|
||
|
||
OLVColumn Find(string header) =>
|
||
columns.FirstOrDefault(c => String.Equals(c.Text, header, StringComparison.OrdinalIgnoreCase));
|
||
|
||
// --- Aufgabe-Icon ---
|
||
var aufgabeCol = Find("Aufgabe");
|
||
if (aufgabeCol != null)
|
||
{
|
||
aufgabeCol.ImageGetter = rowObject =>
|
||
{
|
||
if (!(rowObject is View_Auftrag_Expedit a)) return -1;
|
||
return string.IsNullOrEmpty(a.AufgabeBezeichnung) ? -1 : 0;
|
||
};
|
||
}
|
||
|
||
// --- Kunde-Icon ---
|
||
var kundeCol = Find("Kunde");
|
||
if (kundeCol != null)
|
||
{
|
||
kundeCol.ImageGetter = rowObject =>
|
||
{
|
||
if (!(rowObject is View_Auftrag_Expedit a)) return -1;
|
||
return string.IsNullOrEmpty(a.Zusatz) ? -1 : 1;
|
||
};
|
||
|
||
}
|
||
|
||
// --- Kunde-Icon ---
|
||
var tourCol = Find("TourID");
|
||
if (tourCol != null)
|
||
{
|
||
tourCol.AspectName = "Tour";
|
||
|
||
}
|
||
|
||
|
||
// --- Schmutzig / Sauber ---
|
||
var dirtCol = Find("Schmutzig");
|
||
if (dirtCol != null)
|
||
{
|
||
dirtCol.HeaderImageKey = "dirt";
|
||
dirtCol.ShowTextInHeader = false;
|
||
dirtCol.MinimumWidth = dirtCol.MaximumWidth = 80;
|
||
}
|
||
var cleanCol = Find("Sauber");
|
||
if (cleanCol != null)
|
||
{
|
||
cleanCol.HeaderImageKey = "clean";
|
||
cleanCol.ShowTextInHeader = false;
|
||
cleanCol.MinimumWidth = cleanCol.MaximumWidth = 80; // Bugfix: nicht dirtCol.MaximumWidth
|
||
}
|
||
|
||
// --- Abschließen-Button ---
|
||
var fertigCol = Find("Abschließen");
|
||
if (fertigCol != null)
|
||
{
|
||
fertigCol.IsButton = true;
|
||
fertigCol.ButtonSizing = OLVColumn.ButtonSizingMode.CellBounds;
|
||
fertigCol.HeaderImageKey = "abschließen";
|
||
fertigCol.ShowTextInHeader = false;
|
||
fertigCol.MinimumWidth = fertigCol.MaximumWidth = 80;
|
||
}
|
||
|
||
|
||
foreach (OLVColumn col in columns)
|
||
{
|
||
switch (this.benutzer.Rolle)
|
||
{
|
||
case BenutzerRolle.Verwaltung:
|
||
break;
|
||
case BenutzerRolle.Fahrer:
|
||
break;
|
||
case BenutzerRolle.Admin: if (col.AspectName is "ContainerDirt" || col.AspectName is "Liefertag" || col.AspectName is "ContainerClean" || col.AspectName is "Status" || col.AspectName is "Tour") col.IsEditable = true;
|
||
break;
|
||
case BenutzerRolle.Waschstrasse:
|
||
break;
|
||
case BenutzerRolle.Master:
|
||
break;
|
||
case BenutzerRolle.Expedit: if (col.AspectName is "ContainerClean" || col.AspectName is "Liefertag" || col.AspectName is "Tour") col.IsEditable = true;
|
||
break;
|
||
case BenutzerRolle.Frottee:
|
||
break;
|
||
case BenutzerRolle.Flach:
|
||
break;
|
||
default:
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
private void Olv_CellToolTipShowing(object sender, ToolTipShowingEventArgs e)
|
||
{
|
||
// Kein Model, kein Tooltip
|
||
if (e.Model == null || e.Column == null)
|
||
return;
|
||
|
||
// Aufgabe-Tooltip
|
||
if (e.Column.Text == "Aufgabe" && e.Model is View_Auftrag_Expedit expeditAufgabe)
|
||
{
|
||
var auftrag = Auftrag.GetAuftrag(expeditAufgabe.AuftragID);
|
||
var aufgabe = Aufgabe.GetAufgabe(null, auftrag.AufgabeID);
|
||
e.Text = aufgabe?.Beschreibung;
|
||
return;
|
||
}
|
||
|
||
// Kunde-Tooltip
|
||
if (e.Column.Text == "Kunde" && e.Model is View_Auftrag_Expedit expeditKunde)
|
||
{
|
||
var auftrag = Auftrag.GetAuftrag(expeditKunde.AuftragID);
|
||
var kunde = Kunde.GetKunde(null, expeditKunde.KundeID, null);
|
||
if (!string.IsNullOrWhiteSpace(kunde?.Anmerkung))
|
||
e.Text = kunde.Anmerkung;
|
||
else e.Text = auftrag.ZusatzInfo;
|
||
return;
|
||
}
|
||
|
||
// Typ-Tooltip
|
||
if (e.Column.Text == "Typ" && e.Model is View_Auftrag_Expedit expeditTyp)
|
||
{
|
||
var auftrag = Auftrag.GetAuftrag(expeditTyp.AuftragID);
|
||
if (e.SubItem.Text == "Laufzettel") e.Text = auftrag.ZusatzInfo;
|
||
return;
|
||
}
|
||
|
||
// Fahrer-Tooltip – Typfix: hier passt View_Auftrag_Expedit besser
|
||
if (e.Column.Text == "Fahrer" && e.Model is View_Auftrag_Expedit expeditFahrer)
|
||
{
|
||
e.Text = expeditFahrer.Zusatz;
|
||
}
|
||
}
|
||
private void ObjectListViewAuftrag_FormatCell(object sender, FormatCellEventArgs e)
|
||
{
|
||
if (e.Column.IsButton)
|
||
{
|
||
if(e.SubItem.BackColor != Color.LightBlue)
|
||
{
|
||
e.SubItem.BackColor = Color.AliceBlue;
|
||
e.SubItem.ForeColor = Color.Black;
|
||
}
|
||
else
|
||
{
|
||
e.SubItem.BackColor = Color.LightSteelBlue;
|
||
e.SubItem.ForeColor = Color.Black;
|
||
|
||
}
|
||
}
|
||
if (e.Column.Text == "FR" || e.Column.Text == "KT" || e.Column.Text == "GT")
|
||
{
|
||
if (e.CellValue.ToString() == "☑")
|
||
{
|
||
e.SubItem.Font = new Font("Segoe UI Symbol", 14F, FontStyle.Bold);
|
||
e.SubItem.ForeColor = Color.YellowGreen;
|
||
}
|
||
if (e.CellValue.ToString() == "☐")
|
||
{
|
||
e.SubItem.Font = new Font("Segoe UI Symbol", 14F, FontStyle.Bold);
|
||
e.SubItem.ForeColor = Color.Yellow;
|
||
}
|
||
if (e.CellValue.ToString() == "☒")
|
||
{
|
||
e.SubItem.Font = new Font("Segoe UI Symbol", 14F, FontStyle.Bold);
|
||
e.SubItem.ForeColor = Color.Red;
|
||
}
|
||
|
||
}
|
||
|
||
|
||
}
|
||
private async void ObjectListViewAuftrag_CellClick(object sender, CellClickEventArgs e)
|
||
{
|
||
itemlocation = new Point(e.Location.X, e.Location.Y);
|
||
ObjectListView olv = (ObjectListView)sender;
|
||
if (e.Model == null) { chartFehlmenge.Visible = false; groupBoxKndInfo.Visible = false; return; }
|
||
Auftrag _auftrag = Auftrag.GetAuftrag(((View_Auftrag_Expedit)e.Model).AuftragID);
|
||
|
||
if (_auftrag.Status != AuftragStatus.Fertig)
|
||
{
|
||
this.auftrag = _auftrag;
|
||
this.kunde = Kunde.GetKunde(null, this.auftrag.KundeID, null);
|
||
this.artikelListe = KundeArtikel.GetList(kunde.KundeID.ToString());
|
||
|
||
// Chart wird eingeblendet statt Gridview. NUR wenn isttest = true.
|
||
var chartliste = await KundeArtikel.LoadArtikelDatenAsync(kunde);
|
||
if (chartliste.Count > 0)
|
||
{
|
||
this.chartFehlmenge = Funktionen.Load_FehlmengeChart(chartliste, chartFehlmenge);
|
||
this.chartFehlmenge.Visible = true;
|
||
}
|
||
else this.chartFehlmenge.Visible = false;
|
||
if (!string.IsNullOrWhiteSpace(this.kunde.Anmerkung) || auftrag.AufgabeID != null) this.groupBoxKndInfo.Visible = true;
|
||
else this.groupBoxKndInfo.Visible = false;
|
||
if (!string.IsNullOrWhiteSpace(this.kunde.Anmerkung))
|
||
{
|
||
labelAnmerkung.Visible = true;
|
||
labelAnmerkung.Text = this.kunde.Anmerkung;
|
||
}
|
||
else { labelAnmerkung.Visible = false; }
|
||
if (auftrag.AufgabeID != null)
|
||
{
|
||
labelAufgabe.Text = Aufgabe.GetAufgabe(null, auftrag.AufgabeID).Bezeichnung.ToString();
|
||
labelAufgabe.Visible = true;
|
||
}
|
||
else { labelAufgabe.Visible = false; }
|
||
if (auftrag.ZusatzInfo != null)
|
||
{
|
||
labelZusatz.Text = auftrag.ZusatzInfo;
|
||
labelZusatz.Visible = true;
|
||
}
|
||
else { labelZusatz.Visible = false; }
|
||
|
||
// GroupBox einblenden wenn notwendig.
|
||
if (labelAufgabe.Visible || labelAnmerkung.Visible || chartFehlmenge.Visible || labelZusatz.Visible) this.groupBoxKndInfo.Visible = true;
|
||
else this.groupBoxKndInfo.Visible = false;
|
||
|
||
}
|
||
else
|
||
{
|
||
if (e.ClickCount == 1) fehlermeldung.AuftragFertig();
|
||
}
|
||
|
||
olv.Focus();
|
||
|
||
}
|
||
private void ObjectListViewAuftrag_ButtonClick(object sender, CellClickEventArgs e)
|
||
{
|
||
var olv = (ObjectListView)sender;
|
||
var view = (View_Auftrag_Expedit)e.Model;
|
||
var auftrag = Auftrag.GetAuftrag(view.AuftragID);
|
||
|
||
this.UseWaitCursor = true;
|
||
|
||
try
|
||
{
|
||
switch (e.Column.Text)
|
||
{
|
||
case "Abschließen":
|
||
HandleAbschliessenClick(olv, auftrag);
|
||
break;
|
||
|
||
case "Etikett":
|
||
HandleEtikettClick(auftrag);
|
||
break;
|
||
}
|
||
}
|
||
finally
|
||
{
|
||
Neuladen_OLV(olv);
|
||
this.UseWaitCursor = false;
|
||
}
|
||
}
|
||
private void ObjectListView_DoubleClick(object sender, EventArgs e)
|
||
{
|
||
ObjectListView olv = (ObjectListView)sender;
|
||
olv.CellEditFinished -= ObjectListViewAuftrag_CellEditFinished;
|
||
Auftrag _auftrag = Auftrag.GetAuftrag(((View_Auftrag_Expedit)olv.SelectedObject).AuftragID);
|
||
Kunde _kunde = Kunde.GetKunde(null, _auftrag.KundeID, null);
|
||
|
||
// Wenn NICHT erfasster Kunde dann nichts öffnen.
|
||
if (_kunde.KundeNummer == "2320000") return;
|
||
|
||
if (_auftrag.Typ is AuftragTyp.Standart || _auftrag.Typ is AuftragTyp.Geschäft || _auftrag.Typ is AuftragTyp.AufAbruf || olv.Name.Contains("Vorbereitet"))
|
||
{
|
||
if (_auftrag == null) return;
|
||
|
||
FormKundeVW kndVW = new FormKundeVW(_kunde, this.benutzer);
|
||
if (kndVW.ShowDialog() == DialogResult.OK)
|
||
{
|
||
if (kndVW.aufgabeErledigt) Aufgabe_erledigt(_auftrag, _kunde, _kunde.Suchtext ?? _kunde.KundeName);
|
||
|
||
}
|
||
return;
|
||
}
|
||
else
|
||
{
|
||
FormAuftragDetail auftragDetail = new FormAuftragDetail(_auftrag, this.benutzer);
|
||
if (auftragDetail.ShowDialog() == DialogResult.OK)
|
||
{
|
||
Neuladen_OLV(olv);
|
||
}
|
||
return;
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// Behandelt den Fall, dass der Button in der Spalte Abschliessen geclickt wurde
|
||
/// </summary>
|
||
/// <param name="olv"></param>
|
||
/// <param name="auftrag"></param>
|
||
private void HandleAbschliessenClick(ObjectListView olv, Auftrag auftrag)
|
||
{
|
||
// Sonderfall Frottee: nur Abteilung beenden und raus
|
||
if (this.benutzer.Rolle == BenutzerRolle.Frottee)
|
||
{
|
||
this.auftrag = auftrag;
|
||
Auftrag_Fertig();
|
||
return;
|
||
}
|
||
|
||
if (olv.CheckedItems.Count > 0)
|
||
{
|
||
HandleBatchAbschliessen(olv);
|
||
return;
|
||
}
|
||
|
||
HandleSingleAbschliessen(auftrag);
|
||
}
|
||
|
||
/// <summary>
|
||
/// Wenn angehackte Datensätze im Bulk abeschlossen werden sollen.
|
||
/// Hier sind mehrere oder nur ein Auftrag abschließen möglich.
|
||
/// </summary>
|
||
/// <param name="olv"></param>
|
||
private void HandleBatchAbschliessen(ObjectListView olv)
|
||
{
|
||
var count = olv.CheckedItems.Count;
|
||
var result = MessageBox.Show(
|
||
$"Möchtest du die ausgewählten {count} Aufträge abschließen?",
|
||
"AUFTRÄGE FERTIG",
|
||
MessageBoxButtons.YesNo,
|
||
MessageBoxIcon.Question);
|
||
|
||
if (result == DialogResult.No)
|
||
return;
|
||
|
||
foreach (OLVListItem item in olv.CheckedItems)
|
||
{
|
||
this.auftrag = Auftrag.GetAuftrag(((View_Auftrag_Expedit)item.RowObject).AuftragID);
|
||
Auftrag_Fertig();
|
||
}
|
||
|
||
var kundeColumn = olv.AllColumns
|
||
.Cast<OLVColumn>()
|
||
.FirstOrDefault(col => col.Text == "Kunde");
|
||
|
||
if (kundeColumn != null && kundeColumn.HeaderCheckBox)
|
||
olv.UncheckHeaderCheckBox(kundeColumn);
|
||
}
|
||
|
||
/// <summary>
|
||
/// Wenn der Button geclickt wurde ohne anhacken. Es wird garantiert nur 1 Auftrag abgeschlossen
|
||
/// </summary>
|
||
/// <param name="auftrag"></param>
|
||
private void HandleSingleAbschliessen(Auftrag auftrag)
|
||
{
|
||
if (this.auftrag != auftrag)
|
||
altecontclean = null;
|
||
|
||
this.auftrag = auftrag;
|
||
|
||
if (this.auftrag.ContainerClean == 0 & this.auftrag.Typ < AuftragTyp.Inventur)
|
||
{
|
||
if (meldung.NoCleanContainer() == DialogResult.OK)
|
||
return;
|
||
}
|
||
else
|
||
{
|
||
if (!HandleContainerCleanChange())
|
||
return;
|
||
}
|
||
|
||
Auftrag_Fertig();
|
||
}
|
||
|
||
/// <summary>
|
||
/// Behandelt den Fall, dass sich ContainerClean geändert hat.
|
||
/// Gibt false zurück, wenn der Vorgang abgebrochen werden soll.
|
||
/// </summary>
|
||
private bool HandleContainerCleanChange()
|
||
{
|
||
if (altecontclean == null || this.auftrag.ContainerClean == altecontclean)
|
||
return true;
|
||
|
||
switch (meldung.DifferentCleanContainer())
|
||
{
|
||
case DialogResult.Cancel:
|
||
return false;
|
||
|
||
case DialogResult.Yes:
|
||
return TryDruckMitNeuemContainerClean();
|
||
|
||
case DialogResult.No:
|
||
this.auftrag.Erstellt = DateTime.Now;
|
||
this.auftrag.ErstelltVon = (int)benutzer.BenutzerID;
|
||
return true;
|
||
|
||
default:
|
||
return true;
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// Wenn eine neue Anzahl an sauberen Containern eingegeben wurde wird ein erneuter Druck abgefragt.
|
||
/// </summary>
|
||
private bool TryDruckMitNeuemContainerClean()
|
||
{
|
||
this.auftrag.Gedruckt = DateTime.Now;
|
||
this.auftrag.GedrucktVon = benutzer.BenutzerID;
|
||
|
||
var nocont = false;
|
||
|
||
if (this.auftrag.ContainerClean > 10)
|
||
{
|
||
var res = MessageBox.Show(
|
||
"Möchtest du die Containeranzahl am Etikett anzeigen?",
|
||
"FRAGE",
|
||
MessageBoxButtons.YesNo,
|
||
MessageBoxIcon.Question);
|
||
|
||
nocont = (res == DialogResult.No);
|
||
}
|
||
|
||
try
|
||
{
|
||
Funktionen.Etikett_Drucken(auftrag, nocont);
|
||
return true;
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
MessageBox.Show(
|
||
"Etiketten konnten nicht gedruckt werden. Versuche es nochmals.",
|
||
"DRUCKFEHLER",
|
||
MessageBoxButtons.OK,
|
||
MessageBoxIcon.Error);
|
||
|
||
Program.AddFehler(this.benutzer, ex.Message, ex.StackTrace, null);
|
||
return false;
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// Behandelt den Fall, dass der Button in der Spalte Etikett geclickt wurde.
|
||
/// </summary>
|
||
/// <param name="auftrag"></param>
|
||
private void HandleEtikettClick(Auftrag auftrag)
|
||
{
|
||
this.auftrag = auftrag;
|
||
|
||
if (this.auftrag.AufgabeID != null)
|
||
{
|
||
var aufgabe = Aufgabe.GetAufgabe(null, auftrag.AufgabeID);
|
||
var text = $"Bei dem ausgewählten Auftrag ist die Aufgabe {aufgabe.Bezeichnung} zu erledigen. Hast du die Aufgabe erledigt? ";
|
||
|
||
if (meldung.GetAchtung(this, text, false) == DialogResult.No) return;
|
||
else
|
||
{
|
||
Kunde _kunde = Kunde.GetKunde(null, this.auftrag.KundeID, null);
|
||
string name;
|
||
if (string.IsNullOrWhiteSpace(_kunde.Suchtext)) name = _kunde.KundeName;
|
||
else name = _kunde.Suchtext;
|
||
|
||
this.auftrag.Erledigt = DateTime.Now;
|
||
this.auftrag.ErledigtVon = (int)this.benutzer.BenutzerID;
|
||
Aufgabe_erledigt(this.auftrag, _kunde, name);
|
||
}
|
||
}
|
||
|
||
if (this.auftrag.Typ < AuftragTyp.Inventur || (this.auftrag.Typ >= AuftragTyp.Inventur && this.auftrag.ContainerClean > 0))
|
||
{
|
||
var rslt = DialogResult.None;
|
||
PrepareContainerCleanForEtikett();
|
||
|
||
if (this.auftrag.ContainerClean == 0)
|
||
{
|
||
rslt = MessageBox.Show("Der Auftrag hat 0 saubere Container. Möchtest du ein Etikett drucken?", "FRAGE", MessageBoxButtons.YesNoCancel, MessageBoxIcon.Question);
|
||
}
|
||
|
||
switch (rslt)
|
||
{
|
||
case DialogResult.Cancel:
|
||
return;
|
||
case DialogResult.Yes:
|
||
goto default;
|
||
case DialogResult.No:
|
||
break;
|
||
default:
|
||
var result = Funktionen.Etikett_Drucken(auftrag, nocont);
|
||
if (result == DialogResult.OK)
|
||
{
|
||
this.auftrag.Gedruckt = DateTime.Now;
|
||
this.auftrag.GedrucktVon = (int)this.benutzer.BenutzerID;
|
||
}
|
||
break;
|
||
}
|
||
|
||
}
|
||
|
||
this.auftrag.Status = AuftragStatus.Vorbereitet;
|
||
this.auftrag.Save();
|
||
this.auftrag = null;
|
||
|
||
}
|
||
|
||
private void PrepareContainerCleanForEtikett()
|
||
{
|
||
if (this.auftrag.ContainerClean != 0)
|
||
{
|
||
letzterLiefertag = this.auftrag.Liefertag;
|
||
return;
|
||
}
|
||
|
||
string eingabe = PromptForText(
|
||
"Der Auftrag hat keine sauberen Container oder Pakete. \n\n" +
|
||
"Bitte gib an wieviele Container oder Pakete der Auftrag hat:",
|
||
"Container/Pakete eingeben",
|
||
"0");
|
||
|
||
if (string.IsNullOrWhiteSpace(eingabe) || !int.TryParse(eingabe, out int anzahl))
|
||
{
|
||
this.UseWaitCursor = false;
|
||
return;
|
||
}
|
||
|
||
this.auftrag.ContainerClean = anzahl;
|
||
}
|
||
/// <summary>
|
||
/// Die Objecte der ObjectListView werden neu geladen.
|
||
/// </summary>
|
||
/// <param name="olv"></param>
|
||
/// <param name="auftraglist"></param>
|
||
private void OLV_SetObjects(ObjectListView olv, List<View_Auftrag_Expedit> auftraglist)
|
||
{
|
||
if (olv.AllColumns.Count == 0) Load_OLV(olv, auftraglist);
|
||
else
|
||
{
|
||
olv.SetObjects(auftraglist); // Bindet die Auftragsliste an die View
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// Die Objecte der ObjectListView werden neu geladen. Wenn Sie noch keine Spalten hat wird die ObjectListView komplett neu geladen.
|
||
/// </summary>
|
||
/// <param name="olv"></param>
|
||
private async void Neuladen_OLV(ObjectListView olv)
|
||
{
|
||
this.UseWaitCursor = true;
|
||
olv.SuspendLayout();
|
||
|
||
// Neu-Laden der ObjectListView
|
||
if (olv.Name.Contains("Geschaeft")) { await GetAuftraegeAsync(ListenArt.Geschäftliste); OLV_SetObjects(olv, listAuftragGeschaeft); }
|
||
if (olv.Name.Contains("Auftrag")) { await GetAuftraegeAsync(ListenArt.Auftragliste); OLV_SetObjects(olv, listAuftragToday); }
|
||
if (olv.Name.Contains("Rampe")) { await GetAuftraegeAsync(ListenArt.Rampenliste); OLV_SetObjects(olv, listRampe); }
|
||
if (olv.Name.Contains("Vorbereitet")) { await GetAuftraegeAsync(ListenArt.Vorbereitetliste); OLV_SetObjects(olv, listVorbereitet); }
|
||
if (olv.Name.Contains("Sonder")) { await GetAuftraegeAsync(ListenArt.Sonderliste); OLV_SetObjects(olv, listSonderAuftrag); }
|
||
|
||
GetUnvisibleColumns(olv);
|
||
olv.ResumeLayout(false);
|
||
this.UseWaitCursor = false;
|
||
}
|
||
|
||
/// <summary>
|
||
/// Blendet die Button Spalten aus wenn der User dazu nicht berechtigt ist.
|
||
/// </summary>
|
||
private void GetUnvisibleColumns(ObjectListView olv)
|
||
{
|
||
foreach (OLVColumn col in olv.AllColumns)
|
||
{
|
||
switch (tabControlAuftragList.SelectedTab.Text)
|
||
{
|
||
case var t when t == "Vorbereitet": //Wenn Tab ist Vorbereitet wird Abschließen eingeblendet.
|
||
if (col.Text == "Abschließen") col.IsVisible = true;
|
||
if (col.Text == "Etikett") col.IsVisible = false;
|
||
if (col.Text == "Kunde")
|
||
{
|
||
col.HeaderCheckBox = true;
|
||
col.HeaderCheckBoxUpdatesRowCheckBoxes = true;
|
||
}
|
||
if (col.Text == "FR" || col.Text == "GT" || col.Text == "KT") col.IsVisible = false;
|
||
break;
|
||
case var t when t == "Rampe":
|
||
if (col.IsButton) col.IsVisible = false;
|
||
if (col.Text == "FR" || col.Text == "GT" || col.Text == "KT") col.IsVisible = false;
|
||
break;
|
||
case var t when t == "Geschäft":
|
||
if (col.Text == "Abschließen") col.IsVisible = true;
|
||
if (col.Text == "Etikett") col.IsVisible = true;
|
||
break;
|
||
case var t when t == "Aufträge heute":
|
||
if (col.Text == "Abschließen")
|
||
{
|
||
//Für alle BenutzerRollen Abschließen ausblenden.
|
||
//Nur FrotteeExpedit sieht Abschließen um Abteilung zu beenden.
|
||
if (this.benutzer.Rolle == BenutzerRolle.Frottee) col.IsVisible = true;
|
||
else col.IsVisible = false;
|
||
}
|
||
break;
|
||
default:
|
||
break;
|
||
}
|
||
|
||
//Für FrotteeExpedit Etiketten drucken ausblenden.
|
||
if (this.benutzer.Rolle == BenutzerRolle.Frottee) if (col.Text == "Etikett" & col.IsButton) col.IsVisible = false;
|
||
}
|
||
|
||
olv.RebuildColumns();
|
||
}
|
||
|
||
/// <summary>
|
||
/// Cell Edit Finished wird verwendet um die Container Sauber Anzahl festzulegen.
|
||
/// </summary>
|
||
/// <param name="sender"></param>
|
||
/// <param name="e"></param>
|
||
private async void ObjectListViewAuftrag_CellEditFinished(object sender, CellEditEventArgs e)
|
||
{
|
||
ObjectListView olv = (ObjectListView)sender;
|
||
this.auftrag = Auftrag.GetAuftrag(((View_Auftrag_Expedit)e.RowObject).AuftragID);
|
||
var modelType = this.auftrag.GetType();
|
||
var propInfo = modelType.GetProperty(e.Column.AspectName);
|
||
|
||
|
||
switch (e.Column.AspectName)
|
||
{
|
||
case var t when t == "ContainerClean":
|
||
{
|
||
altecontclean = (int?)e.Value;
|
||
|
||
if (e.Value != e.NewValue)
|
||
{
|
||
if (this.auftrag.Status <= AuftragStatus.Warten)
|
||
{
|
||
if (int.TryParse(e.NewValue.ToString(), out int i)) this.auftrag.ContainerClean = i;
|
||
else return;
|
||
|
||
if (this.auftrag.Status == AuftragStatus.Vorbereitet)
|
||
{
|
||
if (MessageBox.Show("Die Containeranzahl wurde verändert. Möchtest du die Etiketten nochmals drucken?", "FRAGE", MessageBoxButtons.YesNo, MessageBoxIcon.Question) == DialogResult.Yes)
|
||
{
|
||
Funktionen.Etikett_Drucken(this.auftrag, nocont);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
break;
|
||
case var t when t == "Tour":
|
||
{ //TODO: Mit Tour statt Fahrer durchgehen.
|
||
if (!string.IsNullOrWhiteSpace(e.NewValue.ToString()))
|
||
{
|
||
Saison saison = Saison.GetAktivSaison();
|
||
Tour tour = Tour.GetTour(saison.SaisonId, e.NewValue.ToString().ToUpper());
|
||
if (tour == null) { e.NewValue = string.Empty; return; }
|
||
this.auftrag.TourID = tour.TourID;
|
||
this.auftrag.Priority = tour.Priority;
|
||
e.NewValue = tour.Bezeichnung;
|
||
}
|
||
}
|
||
break;
|
||
case var t when t == "ContainerDirt":
|
||
{
|
||
if (int.TryParse(e.NewValue.ToString(), out int i)) this.auftrag.Container = i;
|
||
else return;
|
||
}
|
||
break;
|
||
case var t when t == "Liefertag":
|
||
{
|
||
if (this.benutzer.Rolle == BenutzerRolle.Verwaltung || this.benutzer.Rolle == BenutzerRolle.Admin)
|
||
{
|
||
if (!TrelloKarte) return;
|
||
|
||
if (_trelloClient == null)
|
||
{
|
||
MessageBox.Show("Bitte zuerst Credentials speichern.", "Fehler",
|
||
MessageBoxButtons.OK, MessageBoxIcon.Warning);
|
||
return;
|
||
}
|
||
|
||
if (MessageBox.Show("Möchtest du eine Trello-Karte für die Änderung erstellen?", "FRAGE", MessageBoxButtons.YesNo, MessageBoxIcon.Question) == DialogResult.No) { TrelloKarte = false; goto default; }
|
||
|
||
try
|
||
{
|
||
DateTime oldDate = DateTime.Parse(e.Value.ToString());
|
||
DateTime newDate = DateTime.Parse(e.NewValue.ToString());
|
||
Benutzer _fahrer = Benutzer.GetBenutzer(null, this.auftrag.ErstelltVon);
|
||
Kunde _kunde = Kunde.GetKunde(null, this.auftrag.KundeID, null);
|
||
string kndName = _kunde.KundeName?? _kunde.Suchtext;
|
||
|
||
// Wenn kein Fahrer hinterlegt oder keine Tour(Trello-Listen-ID) beim Fahrer wird die Allgmeine-Listen_ID verwendet.
|
||
string listID = _fahrer?.Tour?? "69cf1a3adfbfd598e8d98be9";
|
||
this.auftrag.Liefertag = newDate;
|
||
|
||
var options = new CreateCardOptions
|
||
{
|
||
Name = $"Der Liefertag von {kndName} wurde von {oldDate.Date:d} zu {newDate.Date:d} verschoben.",
|
||
Desc = "Diese Karte wurde automatisch erstellt. Bitte gegebenenfalls korrigieren.",
|
||
IdList = $"{listID}",
|
||
Pos = "top",
|
||
DueDate = newDate
|
||
};
|
||
|
||
var card = _trelloClient.CreateCardAndParseAsync(options);
|
||
TrelloKarte = false;
|
||
|
||
//MessageBox.Show(
|
||
// $"Karte erstellt:\nID: {card.Id}\nName: {card.Name}\nURL: {card.ShortUrl}",
|
||
// "Erfolg",
|
||
// MessageBoxButtons.OK,
|
||
// MessageBoxIcon.Information);
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
MessageBox.Show($"Fehler beim Erstellen der Karte:\n{ex.Message}", "Fehler",
|
||
MessageBoxButtons.OK, MessageBoxIcon.Error);
|
||
}
|
||
|
||
}
|
||
else goto default;
|
||
|
||
}
|
||
break;
|
||
default:
|
||
if (propInfo != null && e.NewValue != null)
|
||
{
|
||
// Dynamisch setzen
|
||
propInfo.SetValue(this.auftrag, Convert.ChangeType(e.NewValue, propInfo.PropertyType));
|
||
}
|
||
break;
|
||
}
|
||
Save_Auftrag(this.auftrag, false);
|
||
Neuladen_OLV(olv);
|
||
|
||
//DONE: ZEILE MARKIEREN?
|
||
olv.SelectedObject = e.RowObject;
|
||
olv.EnsureModelVisible(e.RowObject);
|
||
olv.Focus();
|
||
|
||
}
|
||
|
||
/// <summary>
|
||
/// Ausgelöst durch DoppelClick
|
||
/// </summary>
|
||
/// <param name="sender"></param>
|
||
/// <param name="e"></param>
|
||
private void ObjectListViewAuftrag_CellEditStarting(object sender, CellEditEventArgs e)
|
||
{
|
||
ObjectListView olv = (ObjectListView)sender;
|
||
Auftrag _auftrag = Auftrag.GetAuftrag(((View_Auftrag_Expedit)e.RowObject).AuftragID);
|
||
|
||
if (e.Control is NumericUpDown num) num.Select(0, int.MaxValue);
|
||
if (e.Control is ComboBox cb)
|
||
{
|
||
if (e.Value == null) return;
|
||
if (cb.Created)
|
||
cb.SelectedValue = e.Value;
|
||
else
|
||
this.BeginInvoke(new MethodInvoker(delegate {
|
||
cb.SelectedValue = e.Value;
|
||
}));
|
||
}
|
||
}
|
||
|
||
#endregion
|
||
|
||
/// <summary>
|
||
/// Controls werden nach Benutzer deaktiviert.
|
||
/// </summary>
|
||
private void Enable_Controls()
|
||
{
|
||
switch (this.benutzer.Rolle)
|
||
{
|
||
case BenutzerRolle.Verwaltung:
|
||
this.buttonNeuerAuftrag.Enabled = this.buttonSWS_Drucken.Enabled = false;
|
||
|
||
|
||
GetUnvisibleColumns(this.objectListViewAuftrag);
|
||
break;
|
||
case BenutzerRolle.Fahrer:
|
||
this.buttonNeuerAuftrag.Enabled = this.buttonSWS_Drucken.Enabled = false;
|
||
|
||
|
||
GetUnvisibleColumns(this.objectListViewAuftrag);
|
||
break;
|
||
case BenutzerRolle.Admin:
|
||
break;
|
||
case BenutzerRolle.Waschstrasse:
|
||
this.buttonNeuerAuftrag.Enabled = this.buttonSWS_Drucken.Enabled = false;
|
||
|
||
|
||
GetUnvisibleColumns(this.objectListViewAuftrag);
|
||
break;
|
||
case BenutzerRolle.Master:
|
||
break;
|
||
case BenutzerRolle.Expedit:
|
||
break;
|
||
case BenutzerRolle.Frottee:
|
||
this.buttonEtikettenDrucken.Visible = this.buttonNeuerAuftrag.Visible = this.buttonSWS_Drucken.Visible = false;
|
||
this.buttonStats.Visible = this.buttonEinstellung.Visible = false; // buttonReklamation einblenden wenn Frottee-Expedit auch Reklamation bearbeitet.
|
||
foreach(TabPage tab in this.tabControlAuftragList.TabPages)
|
||
{
|
||
if (tab.Text == "Vorbereitet" || tab.Text == "Rampe") tabControlAuftragList.TabPages.Remove(tab);
|
||
}
|
||
|
||
break;
|
||
case BenutzerRolle.Flach:
|
||
this.buttonNeuerAuftrag.Enabled = this.buttonSWS_Drucken.Enabled = false;
|
||
|
||
|
||
// WENN Rolle Frottee (Expedit Frottee) dann ButtonClick deaktiviert. Nur Expedit kann abschließen
|
||
GetUnvisibleColumns(this.objectListViewAuftrag);
|
||
break;
|
||
default:
|
||
break;
|
||
}
|
||
|
||
}
|
||
|
||
/// <summary>
|
||
/// Aufträge für TabPages werden von DB-VIEW geladen.
|
||
/// </summary>
|
||
/// <param name="liste">null wemm alle Listen neu geladen werden sollen</param>
|
||
/// <returns>Task zu FormLoad</returns>
|
||
private async Task GetAuftraegeAsync(ListenArt? liste)
|
||
{
|
||
if (this.benutzer.Rolle != BenutzerRolle.Frottee)
|
||
{
|
||
if (liste == null || liste == ListenArt.Auftragliste) listAuftragToday = await View_Auftrag_Expedit.GetAuftragExpeditAsync(statusFilter: AuftragStatus.Gewaschen, datum: DateTime.Today.Date.AddDays(2));
|
||
if (liste == null || liste == ListenArt.Geschäftliste) listAuftragGeschaeft = await View_Auftrag_Expedit.GetAuftragExpeditAsync(statusFilter: AuftragStatus.Fertig, minStatusFilter: AuftragStatus.Abgeholt, typFilter: AuftragTyp.Geschäft);
|
||
if (liste == null || liste == ListenArt.Vorbereitetliste) listVorbereitet = await View_Auftrag_Expedit.GetAuftragExpeditAsync(statusFilter: AuftragStatus.Vorbereitet, minTypFilter: AuftragTyp.Standart);
|
||
if (liste == null || liste == ListenArt.Sonderliste) listSonderAuftrag = await View_Auftrag_Expedit.GetAuftragExpeditAsync(statusFilter: AuftragStatus.Fertig, minStatusFilter: AuftragStatus.Herrichten, minTypFilter: AuftragTyp.Inventur);
|
||
if (liste == null || liste == ListenArt.Rampenliste) listRampe = await View_Auftrag_Expedit.GetAuftragExpeditAsync(statusFilter: AuftragStatus.Abgeholt, typFilter: AuftragTyp.Standart);
|
||
}
|
||
else
|
||
{
|
||
if (liste == null || liste == ListenArt.Auftragliste) listAuftragToday = await View_Auftrag_Expedit.GetAuftragExpeditAsync(statusFilter: AuftragStatus.Gewaschen, kategorie: ArtikelKategorie.Frottee, datum: DateTime.Today.Date.AddDays(2));
|
||
if (liste == null || liste == ListenArt.Geschäftliste) listAuftragGeschaeft = await View_Auftrag_Expedit.GetAuftragExpeditAsync(statusFilter: AuftragStatus.Fertig, minStatusFilter: AuftragStatus.Abgeholt, typFilter: AuftragTyp.Geschäft, kategorie: ArtikelKategorie.Frottee);
|
||
if (liste == null || liste == ListenArt.Sonderliste) listSonderAuftrag = await View_Auftrag_Expedit.GetAuftragExpeditAsync(statusFilter: AuftragStatus.Fertig, minStatusFilter: AuftragStatus.Herrichten, typFilter: AuftragTyp.Laufzettel, minTypFilter: AuftragTyp.Inventur, kategorie: ArtikelKategorie.Frottee);
|
||
}
|
||
|
||
}
|
||
|
||
/// <summary>
|
||
/// Zeigt Fenster zur Eingabe von Text.
|
||
/// </summary>
|
||
/// <param name="titel"></param>
|
||
/// <param name="prompt"></param>
|
||
/// <param name="defaultText"></param>
|
||
/// <returns>Anzahl Saubere Container als string</returns>
|
||
private string PromptForText(string titel, string prompt, string defaultText)
|
||
{
|
||
return Interaction.InputBox(prompt, titel, defaultText);
|
||
}
|
||
private void Save_Auftrag(Auftrag auftrag, bool show)
|
||
{
|
||
if (auftrag.Save()[0] == 1) if (show) meldung.Gespeichert();
|
||
else if (show) meldung.Speicherfehler();
|
||
}
|
||
private void Aufgabe_erledigt(Auftrag _auftrag,Kunde _kunde, string name)
|
||
{
|
||
if (_kunde.AufgabeCount <= 0) _kunde.Aufgabe = null;
|
||
else _kunde.AufgabeCount--;
|
||
_auftrag.AufgabeErledigt = true;
|
||
if (_auftrag.Save()[0] != 1) meldung.GetFehler(this, $"Der Auftrag konnte nicht gespeichert und die Aufgabe nicht als erledigt markiert werden. Melde das bitte deinem Vorgesetzten.");
|
||
if (_kunde.Save() != 1) meldung.GetFehler(this, $"Der Kunde {name} konnte nicht gespeichert und die Aufgabe nicht entfernt werden. Melde das bitte deinem Vorgesetzten.");
|
||
|
||
}
|
||
|
||
/// <summary>
|
||
/// Wird aufgerufen wenn ein Auftrag Fertig ist und so gespeichert werden soll.
|
||
/// </summary>
|
||
private void Auftrag_Fertig()
|
||
{
|
||
if (this.benutzer.Rolle == BenutzerRolle.Frottee) this.auftrag.Abteilungen |= AbteilungsStatus.FrotteeBeendet;
|
||
else this.auftrag.Status = AuftragStatus.Fertig;
|
||
this.auftrag.Save();
|
||
|
||
if (this.auftrag.Typ == AuftragTyp.Inventur)
|
||
{
|
||
Program.InventurFertig(this.auftrag);
|
||
}
|
||
|
||
this.auftrag = null;
|
||
}
|
||
|
||
/// <summary>
|
||
/// Beim Wechsel der Tabs wird ObjectListView neu geladen und Spalten ausgeblendet.
|
||
/// </summary>
|
||
/// <param name="sender"></param>
|
||
/// <param name="e"></param>
|
||
private void TabControlAuftragList_SelectedIndexChanged(object sender, EventArgs e)
|
||
{
|
||
TabControl tabControl = sender as TabControl;
|
||
if (!(tabControl.SelectedTab.Controls[0] is ObjectListView olv)) return;
|
||
|
||
tabControl.SuspendLayout();
|
||
olv.SuspendLayout();
|
||
|
||
chartFehlmenge.Visible = false;
|
||
groupBoxKndInfo.Visible = false;
|
||
|
||
//GetUnvisibleColumns(olv);
|
||
|
||
Neuladen_OLV(olv);
|
||
|
||
olv.ResumeLayout();
|
||
tabControl.ResumeLayout();
|
||
this.UseWaitCursor = false;
|
||
}
|
||
|
||
/// <summary>
|
||
/// Wenn Suche mehr als 1 Auftrag wird TabPage mit Ergebnis hinzugefügt.
|
||
/// </summary>
|
||
/// <param name="liste"></param>
|
||
/// <param name="listenArt"></param>
|
||
private void AddTabPage(List<Auftrag> liste, ListenArt listenArt)
|
||
{
|
||
if (liste == null) return;
|
||
UCAuftragListe ucl = new UCAuftragListe(this.benutzer, liste);
|
||
TabPage tabPage = new TabPage();
|
||
|
||
switch (listenArt)
|
||
{
|
||
case ListenArt.Auftragliste: // Aufträge HEUTE
|
||
break;
|
||
case ListenArt.Sonderliste: // Sonderaufträge
|
||
break;
|
||
case ListenArt.Geschäftliste: // Aufträge Geschäftskunden
|
||
break;
|
||
case ListenArt.Suchliste: // Aufträge gesucht
|
||
string closeStr = " ×"; // Unicode X-Symbol
|
||
tabPage.Text = "Suchergebnis" + closeStr;
|
||
break;
|
||
case ListenArt.Rampenliste: // Aufträge auf Rampe
|
||
break;
|
||
case ListenArt.Vorbereitetliste: // Vorbereitete Aufträge
|
||
tabPage.Text = "Vorbereitet";
|
||
break;
|
||
default: //Alle Listen
|
||
break;
|
||
}
|
||
|
||
|
||
// if (!tabPage.Text.Contains("Suche")) return;
|
||
tabPage.Controls.Add(ucl);
|
||
ucl.Dock = DockStyle.Fill;
|
||
this.tabControlAuftragList.Controls.Add(tabPage);
|
||
}
|
||
|
||
/// <summary>
|
||
/// MouseDown um Klick auf TabControl zu erkennen.
|
||
/// Wenn Klick auf "x" wird die TabPage geschlossen. NUR BEI SUCHE MÖGLICH
|
||
/// </summary>
|
||
/// <param name="sender"></param>
|
||
/// <param name="e"></param>
|
||
private void TabControlAuftragList_MouseDown(object sender, MouseEventArgs e)
|
||
{
|
||
this.UseWaitCursor = true;
|
||
if (e.Button == MouseButtons.Left)
|
||
{
|
||
for (int i = 0; i < tabControlAuftragList.TabCount; i++)
|
||
{
|
||
Rectangle r = tabControlAuftragList.GetTabRect(i);
|
||
if (r.Contains(e.X, e.Y))
|
||
{
|
||
// X-Button-Bereich (rechts)
|
||
Rectangle closeRect = new Rectangle(r.Right - 18, r.Top + 4, 14, 14);
|
||
if (closeRect.Contains(e.X, e.Y))
|
||
{
|
||
if (tabControlAuftragList.TabPages[i].Text.Contains("Suche")) tabControlAuftragList.TabPages.RemoveAt(i);
|
||
return;
|
||
}
|
||
tabControlAuftragList.SelectedIndex = i;
|
||
this.UseWaitCursor = false;
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// Malt Border der GroupBox für Anmerkungen. Farbe wechseln wenn ROT schlecht.
|
||
/// </summary>
|
||
/// <param name="sender"></param>
|
||
/// <param name="e"></param>
|
||
private void GroupBoxKndInfo_Paint(object sender, PaintEventArgs e)
|
||
{
|
||
Funktionen.GetGroupBoxBoarder(groupBoxKndInfo, e);
|
||
}
|
||
|
||
/// <summary>
|
||
/// Wenn Chart wird sichtbar wird die Position berechnet.
|
||
/// Das TabControl wird um die Chart schmäler.
|
||
/// </summary>
|
||
/// <param name="sender"></param>
|
||
/// <param name="e"></param>
|
||
private void ChartFehlmenge_VisibleChanged(object sender, EventArgs e)
|
||
{
|
||
UCFeedback fb = this.Controls.Find("feedback", false)[0] as UCFeedback;
|
||
|
||
if (chartFehlmenge.Visible || groupBoxKndInfo.Visible)
|
||
{
|
||
this.tabControlAuftragList.Width = (int)(this.Width * 0.80);
|
||
this.chartFehlmenge.Width = (int)(this.Width * 0.20) - 20;
|
||
this.groupBoxKndInfo.Width = this.chartFehlmenge.Width - 10;
|
||
|
||
int chartHeight = (int)(this.tabControlAuftragList.Height * 0.75);
|
||
int gbHeight = (int)(this.tabControlAuftragList.Height * 0.25);
|
||
|
||
chartFehlmenge.Location = new Point(this.tabControlAuftragList.Right + 10, this.tabControlAuftragList.Top);
|
||
chartFehlmenge.Size = new Size(groupBoxKndInfo.Width, chartHeight);
|
||
groupBoxKndInfo.Height = gbHeight;
|
||
groupBoxKndInfo.Location = new Point(this.tabControlAuftragList.Right + 10, this.tabControlAuftragList.Bottom - gbHeight);
|
||
|
||
fb.Visible = false;
|
||
}
|
||
else
|
||
{
|
||
this.tabControlAuftragList.Width = this.Width - 25;
|
||
fb.Visible = true;
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// Wenn die GroupBox für Aufgabe und Anmerkung sichtbar wird wird die Position berechnet.
|
||
/// Das TabControl wird um die GroupBox schmäler.
|
||
/// </summary>
|
||
/// <param name="sender"></param>
|
||
/// <param name="e"></param>
|
||
private void GroupBoxKndInfo_VisibleChanged(object sender, EventArgs e)
|
||
{
|
||
if (groupBoxKndInfo.Visible)
|
||
{
|
||
this.tabControlAuftragList.Width = (int)(this.Width * 0.80);
|
||
this.groupBoxKndInfo.Width = (int)(this.Width * 0.20) - 20;
|
||
|
||
int gbHeight = (int)(this.tabControlAuftragList.Height * 0.25);
|
||
|
||
groupBoxKndInfo.Height = gbHeight;
|
||
groupBoxKndInfo.Location = new Point(this.tabControlAuftragList.Right + 10, this.tabControlAuftragList.Bottom - gbHeight);
|
||
|
||
}
|
||
else
|
||
{
|
||
this.tabControlAuftragList.Width = this.Width - 25;
|
||
}
|
||
}
|
||
private async void FormExpedit_HelpButtonClicked(object sender, System.ComponentModel.CancelEventArgs e)
|
||
{
|
||
this.benutzer.OnboardingStatus = this.benutzer.ClearOnboardingFlag(onBoardingArt); // OnBoarding zurücksetzen
|
||
await this.benutzer.UpdateOnBoardingAsync(); // Update OnBoardingStatus
|
||
ZeigeOnboarding();
|
||
}
|
||
private async void ZeigeOnboarding()
|
||
{
|
||
if (this.benutzer.IstGesehen(onBoardingArt)) return; // Bereits fertig
|
||
|
||
if (Program.ShowOnBoarding(this.benutzer.Rolle.ToString(), onBoardingArt) == DialogResult.OK)
|
||
{
|
||
// Nächster Schritt → Flag setzen
|
||
this.benutzer.OnboardingStatus = this.benutzer.SetOnboardingFlag(onBoardingArt);
|
||
await this.benutzer.UpdateOnBoardingAsync(); // Deine Update-Methode
|
||
//this.Close(); // Onboarding beendet
|
||
}
|
||
}
|
||
|
||
private void chartFehlmenge_DoubleClick(object sender, EventArgs e)
|
||
{
|
||
Chart chart = (Chart)sender;
|
||
Kunde _knd = chart.Tag as Kunde;
|
||
List<KundeArtikel> kndartListe = KundeArtikel.GetList(_knd.KundeID.ToString());
|
||
|
||
Auftrag _auftrag = new Auftrag()
|
||
{
|
||
KundeID = (int)_knd.KundeID,
|
||
Typ = AuftragTyp.IST_Erhoehung,
|
||
Erstellt = DateTime.Now,
|
||
ErstelltVon = (int)this.benutzer.BenutzerID,
|
||
Status = AuftragStatus.Vorbereitet,
|
||
|
||
};
|
||
|
||
|
||
FormAuftragDetail detail = new FormAuftragDetail(_auftrag, this.benutzer, kndartListe);
|
||
detail.Show();
|
||
//TODO: Wie soll es weiter gehen?
|
||
}
|
||
|
||
private void FormExpedit_MouseMove(object sender, MouseEventArgs e)
|
||
{
|
||
}
|
||
}
|
||
}
|
||
//DONE: Lösung zum Löschen von Aufträgen überlegen. (Kevin fragen)
|
||
//CHANGES: Trello-Karte nach Liefertagänderung kann von Admin oder Verwaltung erstellt werden.
|
||
//CHANGES: Im Tab Vorbereitet wird beim Ändern der sauberen Containeranzahl gefragt ob die Etiketten neu gedruckt werden sollen.
|
||
//CHANGES: Im Tab Rampe wird bei DoppelClick der Auftrag als gewaschen markiert und im Tab Aufträge heute sichtbar.
|
||
//CHANGES: Wenn ein anderer Fahrer ausgewählt wird, wird auch die Priority laut dem Fahrer geändert.
|
||
//CHANGES: NumericUpDown markiert automatisch den Inhalt. Erleichtert die Eingabe.
|
||
//CHANGES: Wenn Expedit NeuerAuftrag aufruft wird gefragt welcher Auftrag gewünscht ist. Geschäftkunde = Geschäft (Notwendig bis ausschließlich Fahrer die Standardaufträge erstellen) |