dschick/git_bsmd
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
abc2afdc11
git_bsmd/ENI2/DetailViewControls/WasteDetailControl.xaml.cs
Daniel Schick d1c131c52b Added logic to return to the previously selected tab page on a detail control, 
but only if the control has a tab control and the save button was hit. In this case a complete reload happens.
2025-03-07 16:04:53 +01:00

723 lines
31 KiB
C#
Raw Blame History

// Copyright (c) 2017 schick Informatik
// Description: Detailansicht Müllmeldung
//
using System.Linq;
using System.Collections.Generic;
using System.Windows;
using System.Windows.Controls;
using ENI2.EditControls;
using ENI2.Util;
using bsmd.database;
using ExcelDataReader;
using System.IO;
using System;
using Microsoft.Win32;
using System.Diagnostics;
using System.Threading.Tasks;
namespace ENI2.DetailViewControls
{
/// <summary>
/// Interaction logic for WasteDetailControl.xaml
/// </summary>
public partial class WasteDetailControl : DetailBaseControl
{
private Message _wasMessage;
private WAS _was;
private Message _wasRcptMessage;
private WAS_RCPT _selectedWAS_RCPT;
private static List<WasteDisposalServiceProvider_Template> _wsdpTemplates = null;
private WasteDisposalServiceProvider_Template _currentTemplate;
private string _undoTemplate;
public WasteDetailControl()
{
InitializeComponent();
Loaded += WasteDetailControl_Loaded;
}
private void WasteDetailControl_Loaded(object sender, RoutedEventArgs e)
{
this.RegisterLocodeChange(this.locodeCtrlLastWastePort, Message.NotificationClass.WAS);
this.RegisterLocodeChange(this.locodeCtrlNextWastePort, Message.NotificationClass.WAS);
this.RegisterCheckboxChange(this.checkBoxAccurateCorrectDetails, Message.NotificationClass.WAS);
this.RegisterCheckboxChange(this.checkBoxValidExemption, Message.NotificationClass.WAS);
this.RegisterDatePickerChange(this.datePickerDateLastDisposal, Message.NotificationClass.WAS);
this.RegisterTextboxChange(this.textBoxWasteDisposalServiceProviders, Message.NotificationClass.WAS);
this.dataGridWasteReceived.CellEditEnding += (obj, ev) => { this.SublistElementChanged(Message.NotificationClass.WAS_RCPT); };
}
private void CheckBoxValidExemption_Checked(object sender, RoutedEventArgs e)
{
bool on = !(this.checkBoxValidExemption.IsChecked ?? false);
this.checkBoxAccurateCorrectDetails.IsEnabled = on;
this.locodeCtrlNextWastePort.IsEnabled = on;
this.textBoxWasteDisposalServiceProviders.IsEnabled = on;
this.dataGridWaste.IsEnabled = on;
this.locodeCtrlLastWastePort.IsEnabled = on;
this.datePickerDateLastDisposal.IsEnabled = on;
}
private void buttonAddMissingEntries_Click(object sender, RoutedEventArgs e)
{
// TODO: Das muss noch für NSW 7.0 gefixt werden, alles doppelt etc.
this._was.AddMissingWaste();
if(this._was.Waste.Count < 15)
{
Waste newWaste = new Waste
{
Identifier = DatabaseEntity.GetNewIdentifier(this._was.Waste),
WAS = this._was,
WasteAmountGeneratedTillNextPort_MTQ = 0,
WasteAmountRetained_MTQ = 0,
WasteCapacity_MTQ = 0,
WasteDescription = "",
WasteDisposalAmount_MTQ = 0,
WasteDisposalPort = "ZZUKN"
};
this._was.Waste.Add(newWaste);
}
this.SublistElementChanged(Message.NotificationClass.WAS);
this.dataGridWaste.Items.Refresh();
}
private void buttonWasteReceivedAddMissingEntries_Click(object sender, RoutedEventArgs e)
{
if (this._selectedWAS_RCPT != null)
{
this._selectedWAS_RCPT.AddMissingWasteReceived();
this.SublistElementChanged(Message.NotificationClass.WAS_RCPT);
this.dataGridWasteReceived.Items.Refresh();
}
}
public async override void Initialize()
{
base.Initialize();
foreach (Message aMessage in this.Messages)
{
if (aMessage.MessageNotificationClass == Message.NotificationClass.WAS) { this._wasMessage = aMessage; this.ControlMessages.Add(aMessage); }
if(aMessage.MessageNotificationClass == Message.NotificationClass.WAS_RCPT) { this._wasRcptMessage = aMessage; this.ControlMessages.Add(aMessage); }
}
#region init WAS
if (this._wasMessage == null)
{
this._wasMessage = this.Core.CreateMessage(Message.NotificationClass.WAS);
this.Messages.Add(this._wasMessage);
}
WAS was = null;
if (this._wasMessage.Elements.Count > 0)
was = this._wasMessage.Elements[0] as WAS;
if (was == null)
{
was = new WAS();
was.MessageCore = this.Core;
was.MessageHeader = this._wasMessage;
_wasMessage.Elements.Add(was);
}
else
{
// remove "old" Waste Entries from display (not deleted in the DB!)
for(int i = (was.Waste.Count - 1); i >= 0; i--)
{
if (was.Waste[i].WasteType > 999)
was.Waste.RemoveAt(i);
}
}
this.wasGroupBox.DataContext = was;
this._was = was;
this.dataGridWaste.Initialize();
this.dataGridWaste.ItemsSource = was.Waste;
this.dataGridWaste.AddingNewItem += DataGridWaste_AddingNewItem;
this.dataGridWaste.EditRequested += DataGridWaste_EditRequested;
this.dataGridWaste.DeleteRequested += DataGridWaste_DeleteRequested;
this.dataGridWaste.CreateRequested += DataGridWaste_CreateRequested;
this.checkBoxValidExemption.Checked += CheckBoxValidExemption_Checked;
this.checkBoxValidExemption.Unchecked += CheckBoxValidExemption_Checked;
#endregion
#region init WAS_RCPT
if(this._wasRcptMessage == null)
{
this._wasRcptMessage = this.Core.CreateMessage(Message.NotificationClass.WAS_RCPT);
this.Messages.Add(this._wasRcptMessage);
}
this.dataGridWasteReceipt.Initialize();
this.dataGridWasteReceipt.ItemsSource = this._wasRcptMessage.Elements;
this.dataGridWasteReceipt.AddingNewItem += DataGridWasteReceipt_AddingNewItem;
this.dataGridWasteReceipt.EditRequested += DataGridWasteReceipt_EditRequested;
this.dataGridWasteReceipt.DeleteRequested += DataGridWasteReceipt_DeleteRequested;
this.dataGridWasteReceipt.CreateRequested += DataGridWasteReceipt_CreateRequested;
this.dataGridWasteReceived.Initialize();
this.dataGridWasteReceived.AddingNewItem += DataGridWasteReceived_AddingNewItem;
this.dataGridWasteReceived.EditRequested += DataGridWasteReceived_EditRequested;
this.dataGridWasteReceived.DeleteRequested += DataGridWasteReceived_DeleteRequested;
this.dataGridWasteReceived.CreateRequested += DataGridWasteReceived_CreateRequested;
if(this._wasRcptMessage.Elements.Count > 0)
{
this.dataGridWasteReceipt.SelectedItem = this._wasRcptMessage.Elements[0];
this.dataGridWasteReceipt_SelectionChanged(null, null);
}
#endregion
#region init WSDP provider
await InitTemplates();
this.comboBox_WSDPTemplate.ItemsSource = _wsdpTemplates;
#endregion
}
public override int SelectedTabIndex
{
get { return this.mainFrame.SelectedIndex; }
set { this.mainFrame.SelectedIndex = value; }
}
#region Waste receipt grid event handler
private async void DataGridWasteReceipt_CreateRequested()
{
EditWasteReceiptDialog epd = new EditWasteReceiptDialog();
epd.WAS_RCPT = new WAS_RCPT();
epd.WAS_RCPT.MessageHeader = _wasRcptMessage;
epd.WAS_RCPT.Identifier = WAS_RCPT.GetNewIdentifier(_wasRcptMessage.Elements);
epd.WAS_RCPT.AddMissingWasteReceived();
epd.AddClicked += () =>
{
epd.CopyValuesToEntity();
if (!this._wasRcptMessage.Elements.Contains(epd.WAS_RCPT))
this._wasRcptMessage.Elements.Add(epd.WAS_RCPT);
this.dataGridWasteReceipt.Items.Refresh();
epd.WAS_RCPT = new WAS_RCPT();
epd.WAS_RCPT.MessageHeader = _wasRcptMessage;
epd.WAS_RCPT.Identifier = WAS_RCPT.GetNewIdentifier(_wasRcptMessage.Elements);
epd.WAS_RCPT.AddMissingWasteReceived();
this.SublistElementChanged(Message.NotificationClass.WAS_RCPT);
};
if (epd.ShowDialog() ?? false)
{
if (!this._wasRcptMessage.Elements.Contains(epd.WAS_RCPT))
_wasRcptMessage.Elements.Add(epd.WAS_RCPT);
this.dataGridWasteReceipt.Items.Refresh();
this.dataGridWasteReceipt.SelectedItem = epd.WAS_RCPT;
this.SublistElementChanged(Message.NotificationClass.WAS_RCPT);
this.dataGridWasteReceived.ItemsSource = null;
dataGridWasteReceipt_SelectionChanged(this, null);
}
await InitTemplates(); // templates might have changed in the dialog
}
private void DataGridWasteReceipt_DeleteRequested(DatabaseEntity obj)
{
if (obj is WAS_RCPT wasRCPT)
{
// are you sure dialog is in base class
_wasRcptMessage.Elements.Remove(wasRCPT);
wasRCPT.DeleteElements();
DBManager.GetSingleCon(Properties.Settings.Default.ConnectionString).Delete(wasRCPT);
DatabaseEntity.ResetIdentifiers(new List<DatabaseEntity>(_wasRcptMessage.Elements));
this.SublistElementChanged(Message.NotificationClass.WAS_RCPT);
this.dataGridWasteReceipt.Items.Refresh();
this.dataGridWasteReceived.ItemsSource = null;
this._selectedWAS_RCPT = null;
}
}
private async void DataGridWasteReceipt_EditRequested(DatabaseEntity obj)
{
EditWasteReceiptDialog epd = new EditWasteReceiptDialog();
epd.WAS_RCPT = obj as WAS_RCPT;
epd.AddClicked += () =>
{
epd.CopyValuesToEntity();
if (!_wasRcptMessage.Elements.Contains(epd.WAS_RCPT))
_wasRcptMessage.Elements.Add(epd.WAS_RCPT);
this.dataGridWasteReceipt.Items.Refresh();
epd.WAS_RCPT = new WAS_RCPT();
epd.WAS_RCPT.Identifier = WAS_RCPT.GetNewIdentifier(_wasRcptMessage.Elements);
epd.WAS_RCPT.MessageHeader = _wasRcptMessage;
epd.WAS_RCPT.AddMissingWasteReceived();
this.SublistElementChanged(Message.NotificationClass.WAS_RCPT);
};
if (epd.ShowDialog() ?? false)
{
if (!_wasRcptMessage.Elements.Contains(epd.WAS_RCPT))
_wasRcptMessage.Elements.Add(epd.WAS_RCPT);
}
this.dataGridWasteReceipt.SelectedItem = epd.WAS_RCPT;
this.dataGridWasteReceipt.Items.Refresh();
this.SublistElementChanged(Message.NotificationClass.WAS_RCPT);
dataGridWasteReceipt_SelectionChanged(this, null);
await InitTemplates(); // templates might have changed in the dialog
}
private void DataGridWasteReceipt_AddingNewItem(object sender, AddingNewItemEventArgs e)
{
this.DataGridWasteReceipt_CreateRequested();
}
private void dataGridWasteReceipt_SelectionChanged(object sender, SelectionChangedEventArgs e)
{
if (this.dataGridWasteReceipt.SelectedItem is WAS_RCPT was_rcpt)
{
this.dataGridWasteReceived.ItemsSource = was_rcpt.WasteReceived;
this._selectedWAS_RCPT = was_rcpt;
}
}
#endregion
#region Waste received grid event handler
private void DataGridWasteReceived_DeleteRequested(DatabaseEntity obj)
{
if (obj is WasteReceived wasteReceived)
{
this.dataGridWasteReceived.CancelEdit();
this.dataGridWasteReceived.CancelEdit();
// are you sure dialog is in base class
_selectedWAS_RCPT.WasteReceived.Remove(wasteReceived);
DBManager.GetSingleCon(Properties.Settings.Default.ConnectionString).Delete(wasteReceived);
DatabaseEntity.ResetIdentifiers(new List<DatabaseEntity>(_selectedWAS_RCPT.WasteReceived));
this.SublistElementChanged(Message.NotificationClass.WAS_RCPT);
this.dataGridWasteReceived.Items.Refresh();
}
}
private void DataGridWasteReceived_CreateRequested()
{
if (_selectedWAS_RCPT == null) return;
this.dataGridWasteReceived.CancelEdit();
this.dataGridWasteReceived.CancelEdit();
EditWasteReceivedDialog ewrd = new EditWasteReceivedDialog();
ewrd.WasteReceived = new WasteReceived();
ewrd.WasteReceived.WAS_RCPT = _selectedWAS_RCPT;
ewrd.WasteReceived.Identifier = WasteReceived.GetNewIdentifier(_selectedWAS_RCPT.WasteReceived);
ewrd.AddClicked += () =>
{
ewrd.CopyValuesToEntity();
if ((ewrd.WasteReceived.WasteCode != null) && !this._selectedWAS_RCPT.WasteReceived.Any(wr => wr.WasteCode == ewrd.WasteReceived.WasteCode))
{
this._selectedWAS_RCPT.WasteReceived.Add(ewrd.WasteReceived);
this.dataGridWasteReceived.Items.Refresh();
ewrd.WasteReceived = new WasteReceived();
ewrd.WasteReceived.WAS_RCPT = _selectedWAS_RCPT;
ewrd.WasteReceived.Identifier = WasteReceived.GetNewIdentifier(_selectedWAS_RCPT.WasteReceived);
this.SublistElementChanged(Message.NotificationClass.WAS_RCPT);
}
};
if (ewrd.ShowDialog() ?? false)
{
if ((ewrd.WasteReceived.WasteCode != null) && !this._selectedWAS_RCPT.WasteReceived.Any(wr => wr.WasteCode == ewrd.WasteReceived.WasteCode))
{
this._selectedWAS_RCPT.WasteReceived.Add(ewrd.WasteReceived);
this.dataGridWasteReceived.Items.Refresh();
this.SublistElementChanged(Message.NotificationClass.WAS_RCPT);
}
}
}
private void DataGridWasteReceived_EditRequested(DatabaseEntity obj)
{
this.dataGridWasteReceived.CancelEdit();
this.dataGridWasteReceived.CancelEdit();
EditWasteReceivedDialog ewrd = new EditWasteReceivedDialog();
ewrd.WasteReceived = obj as WasteReceived;
ewrd.AddClicked += () =>
{
ewrd.CopyValuesToEntity();
if ((ewrd.WasteReceived.WasteCode != null) && !this._selectedWAS_RCPT.WasteReceived.Any(wr => wr.WasteCode == ewrd.WasteReceived.WasteCode))
{
_selectedWAS_RCPT.WasteReceived.Add(ewrd.WasteReceived);
this.dataGridWasteReceived.Items.Refresh();
ewrd.WasteReceived = new WasteReceived();
ewrd.WasteReceived.Identifier = WasteReceived.GetNewIdentifier(_selectedWAS_RCPT.WasteReceived);
ewrd.WasteReceived.WAS_RCPT = _selectedWAS_RCPT;
this.SublistElementChanged(Message.NotificationClass.WAS_RCPT);
}
};
if (ewrd.ShowDialog() ?? false)
{
if ((ewrd.WasteReceived.WasteCode != null) && !_selectedWAS_RCPT.WasteReceived.Any(wr => wr.WasteCode == ewrd.WasteReceived.WasteCode))
{
_selectedWAS_RCPT.WasteReceived.Add(ewrd.WasteReceived);
}
this.dataGridWasteReceived.Items.Refresh();
this.SublistElementChanged(Message.NotificationClass.WAS_RCPT);
}
}
private void DataGridWasteReceived_AddingNewItem(object sender, AddingNewItemEventArgs e)
{
DataGridWasteReceived_CreateRequested();
}
#endregion
#region Waste grid event handler
private void DataGridWaste_CreateRequested()
{
EditWasteDialog epd = new EditWasteDialog();
epd.Waste = new Waste();
epd.Waste.Identifier = Waste.GetNewIdentifier(_was.Waste);
epd.Waste.WAS = this._was;
epd.AddClicked += () =>
{
epd.CopyValuesToEntity();
if (!this._was.Waste.Any(w => w.WasteType == epd.Waste.WasteType)) {
this._was.Waste.Add(epd.Waste);
this.dataGridWaste.Items.Refresh();
epd.Waste = new Waste();
epd.Waste.WAS = this._was;
epd.Waste.Identifier = Waste.GetNewIdentifier(_was.Waste);
this.SublistElementChanged(Message.NotificationClass.WAS);
}
};
if (epd.ShowDialog() ?? false)
{
if (!this._was.Waste.Any(w => w.WasteType == epd.Waste.WasteType))
{
_was.Waste.Add(epd.Waste);
this.dataGridWaste.Items.Refresh();
this.SublistElementChanged(Message.NotificationClass.WAS);
}
}
}
private void DataGridWaste_DeleteRequested(DatabaseEntity obj)
{
if (obj is Waste waste)
{
// are you sure dialog is in base class
_was.Waste.Remove(waste);
DBManager.GetSingleCon(Properties.Settings.Default.ConnectionString).Delete(waste);
DatabaseEntity.ResetIdentifiers(new List<DatabaseEntity>(_was.Waste));
this.SublistElementChanged(Message.NotificationClass.WAS);
this.dataGridWaste.Items.Refresh();
}
}
private void DataGridWaste_EditRequested(DatabaseEntity obj)
{
EditWasteDialog epd = new EditWasteDialog();
epd.Waste = obj as Waste;
epd.AddClicked += () =>
{
epd.CopyValuesToEntity();
if (!_was.Waste.Any(w => w.WasteType == epd.Waste.WasteType))
{
_was.Waste.Add(epd.Waste);
this.dataGridWaste.Items.Refresh();
epd.Waste = new Waste();
epd.Waste.Identifier = Waste.GetNewIdentifier(_was.Waste);
epd.Waste.WAS = _was;
this.SublistElementChanged(Message.NotificationClass.WAS);
}
};
if (epd.ShowDialog() ?? false)
{
if (!_was.Waste.Contains(epd.Waste))
_was.Waste.Add(epd.Waste);
this.dataGridWaste.Items.Refresh();
this.SublistElementChanged(Message.NotificationClass.WAS);
}
}
private void DataGridWaste_AddingNewItem(object sender, AddingNewItemEventArgs e)
{
this.DataGridWaste_CreateRequested();
}
#endregion
#region Highlighting
public override void HighlightErrorMessageContainer()
{
if (this._wasMessage.HasErrors)
{
HighlightService.HighlightControl(this.wasGroupBox, HighlightService.HighlightStyle.ERROR, this._wasMessage);
}
}
public override void HighlightViolationMessageContainer()
{
if (this._wasMessage.HasViolations)
HighlightService.HighlightControl(this.wasGroupBox, HighlightService.HighlightStyle.VIOLATION, this._wasMessage);
}
#endregion
#region Excel file import
private void buttonImportFromExcel_Click(object sender, RoutedEventArgs e)
{
OpenFileDialog ofd = new OpenFileDialog();
ofd.Filter = "Excel Files|*.xls;*.xlsx";
if (ofd.ShowDialog() ?? false)
{
FileStream stream;
try
{
stream = File.Open(ofd.FileName, FileMode.Open, FileAccess.Read);
}
catch (Exception ex)
{
MessageBox.Show(ex.Message, "Error", MessageBoxButton.OK, MessageBoxImage.Error);
return;
}
using (var reader = ExcelReaderFactory.CreateReader(stream))
{
List<Waste> importWasteList = new List<Waste>();
try
{
do
{
// skip first three rows
reader.Read();
reader.Read();
reader.Read();
int cnt = 0;
object o = null;
// Diese Funktion kann das "alte" Sheet Format nicht mehr einlesen!
while (reader.Read() && (cnt < 35))
{
if (reader.FieldCount < 9)
{
throw new InvalidDataException("Sheet must have 9 Columns of data");
}
if (!reader.IsDBNull(1)) o = reader.GetValue(1); else o = null;
if ((o != null) && Int32.TryParse(o.ToString(), out int wasteType))
{
Waste waste = _was.GetWasteForType(wasteType);
if (waste == null)
{
waste = new Waste();
waste.WasteType = wasteType;
waste.WAS = this._was;
waste.IsDirty = true;
waste.Identifier = Waste.GetNewIdentifier(this._was.Waste);
this._was.Waste.Add(waste);
}
else
{
waste.IsDirty = true;
}
if (!reader.IsDBNull(4)) waste.WasteDescription = reader.GetString(4);
if (waste.WasteDescription.IsNullOrEmpty())
waste.WasteDescription = "-";
if (!reader.IsDBNull(5)) o = reader.GetValue(5); else o = null;
if (o != null) waste.WasteDisposalAmount_MTQ = Convert.ToDouble(o);
if (!reader.IsDBNull(6)) o = reader.GetValue(6); else o = null;
if (o != null) waste.WasteCapacity_MTQ = Convert.ToDouble(o);
if (!reader.IsDBNull(7)) o = reader.GetValue(7); else o = null;
if (o != null) waste.WasteAmountRetained_MTQ = Convert.ToDouble(o);
if (!reader.IsDBNull(8)) waste.WasteDisposalPort = reader.GetString(8).ToUpper();
if (!reader.IsDBNull(9)) o = reader.GetValue(9); else o = null;
if (o != null) waste.WasteAmountGeneratedTillNextPort_MTQ = Convert.ToDouble(o);
importWasteList.Add(waste);
cnt++;
}
}
} while (reader.NextResult());
}
catch (Exception ex)
{
MessageBox.Show("Error reading Excel: " + ex.Message, Properties.Resources.textCaptionError, MessageBoxButton.OK, MessageBoxImage.Error);
}
if (importWasteList.Count > 0)
{
this.dataGridWaste.Items.Refresh();
this.SublistElementChanged(Message.NotificationClass.WAS);
MessageBox.Show(String.Format(Properties.Resources.textWasteImported, importWasteList.Count), Properties.Resources.textCaptionInformation, MessageBoxButton.OK, MessageBoxImage.Information);
}
}
stream.Close();
}
}
#endregion
#region Waste disposal Service Provider templates event handler
private async Task InitTemplates()
{
_wsdpTemplates = await DBManagerAsync.GetWastDisposalServiceProviderTemplatesAsync();
_wsdpTemplates.Sort();
this.comboBox_WSDPTemplate.ItemsSource = null;
this.comboBox_WSDPTemplate.ItemsSource = _wsdpTemplates;
Trace.WriteLine($"{_wsdpTemplates.Count} WSDP templates loaded");
}
private void comboBox_WSDPTemplate_SelectionChanged(object sender, SelectionChangedEventArgs e)
{
Trace.WriteLine("WSDP combo selection changed");
if(this.comboBox_WSDPTemplate.SelectedItem is WasteDisposalServiceProvider_Template wdsp_t)
{
this.textBoxTemplateTitle.Text = wdsp_t.Remark;
this.buttonDeleteTemplate.IsEnabled = true;
this._currentTemplate = wdsp_t;
this._undoTemplate = this.textBoxWasteDisposalServiceProviders.Text.Trim();
this.buttonUndoTemplate.IsEnabled = this._undoTemplate.Length > 0;
this.textBoxWasteDisposalServiceProviders.Text = wdsp_t.WasteDisposalServiceProviderName;
}
}
private async void buttonSaveTemplate_Click(object sender, RoutedEventArgs e)
{
string currentWSDPProviderName = this.textBoxWasteDisposalServiceProviders.Text.Trim();
string currentRemark = this.textBoxTemplateTitle.Text.Trim();
if ((currentWSDPProviderName.Length == 0) || (currentRemark.Length == 0)) return;
WasteDisposalServiceProvider_Template existingTemplate = null;
foreach(WasteDisposalServiceProvider_Template wdsp_template in _wsdpTemplates)
{
// bei gefundenem Match wird ggf. der Remark überschrieben
if (wdsp_template.Remark.Equals(currentRemark))
{
existingTemplate = wdsp_template;
break;
}
}
if(existingTemplate != null)
{
if (MessageBox.Show("A template with this name already exists, overwrite?", "Confirmation", MessageBoxButton.YesNo, MessageBoxImage.Question, MessageBoxResult.No) == MessageBoxResult.No)
return;
existingTemplate.WasteDisposalServiceProviderName = currentWSDPProviderName;
await DBManagerAsync.SaveAsync(existingTemplate);
return;
}
WasteDisposalServiceProvider_Template newTemplate = new WasteDisposalServiceProvider_Template();
newTemplate.WasteDisposalServiceProviderName = currentWSDPProviderName;
newTemplate.Remark = currentRemark;
await DBManagerAsync.SaveAsync(newTemplate);
comboBox_WSDPTemplate.ItemsSource = null;
_wsdpTemplates.Add(newTemplate);
_wsdpTemplates.Sort();
comboBox_WSDPTemplate.ItemsSource = _wsdpTemplates;
MessageBox.Show("Template saved", "OK", MessageBoxButton.OK, MessageBoxImage.Information);
}
private void buttonDeleteTemplate_Click(object sender, RoutedEventArgs e)
{
if(_currentTemplate != null)
{
if (MessageBox.Show("Delete this template?", "Confirmation", MessageBoxButton.YesNo, MessageBoxImage.Question, MessageBoxResult.No) == MessageBoxResult.Yes)
{
this.comboBox_WSDPTemplate.SelectedItem = null;
this.comboBox_WSDPTemplate.ItemsSource = null;
DBManager.Instance.Delete(_currentTemplate);
_wsdpTemplates.Remove(_currentTemplate);
this.textBoxTemplateTitle.Text = null;
this.buttonDeleteTemplate.IsEnabled = false;
this.comboBox_WSDPTemplate.ItemsSource = _wsdpTemplates;
}
}
}
private void buttonUndoTemplate_Click(object sender, RoutedEventArgs e)
{
if(this._undoTemplate != null)
{
this.textBoxWasteDisposalServiceProviders.Text = this._undoTemplate;
this.buttonUndoTemplate.IsEnabled = false;
this._undoTemplate = null;
this.comboBox_WSDPTemplate.SelectedItem = null;
}
}
#endregion
#region Copy WAS to WAS_RCPT handler
private void buttonCopyFromWAS_Click(object sender, RoutedEventArgs e)
{
if (_selectedWAS_RCPT == null) return;
if(MessageBox.Show(Properties.Resources.textCopyToWASConfirmation, Properties.Resources.textConfirmation,
MessageBoxButton.YesNo, MessageBoxImage.Question, MessageBoxResult.No) == MessageBoxResult.Yes)
{
foreach(Waste waste in _was.Waste)
{
if(waste.WasteDisposalAmount_MTQ.HasValue && waste.WasteDisposalAmount_MTQ > 0)
{
// find matching WAS_RCPT entry
foreach(WasteReceived wasteReceived in _selectedWAS_RCPT.WasteReceived)
{
if(wasteReceived.WasteCode.Equals(waste.WasteType.ToString()))
{
wasteReceived.AmountWasteReceived_MTQ = waste.WasteDisposalAmount_MTQ;
break;
}
}
}
}
this.dataGridWasteReceived.Items.Refresh();
}
}
#endregion
}
}
Reference in New Issue View Git Blame Copy Permalink