937 lines
37 KiB
C#
937 lines
37 KiB
C#
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.Collections.ObjectModel;
|
|
using System.Globalization;
|
|
using System.IO;
|
|
using System.Linq;
|
|
using System.Security.Cryptography;
|
|
using System.Text;
|
|
using System.Threading;
|
|
using System.Windows;
|
|
using System.Windows.Controls;
|
|
using System.Windows.Media.Animation;
|
|
using System.Windows.Media.Imaging;
|
|
using brecal.model;
|
|
using brecal.mysql;
|
|
using ExcelDataReader;
|
|
using Microsoft.Win32;
|
|
|
|
|
|
namespace RoleEditor
|
|
{
|
|
/// <summary>
|
|
/// Interaction logic for MainWindow.xaml
|
|
/// </summary>
|
|
public partial class MainWindow : Window
|
|
{
|
|
#region private fields
|
|
|
|
private readonly ObservableCollection<Participant> _participants = new ObservableCollection<Participant>();
|
|
private readonly ObservableCollection<Participant> _terminals = new ObservableCollection<Participant>();
|
|
private readonly ObservableCollection<Participant> _authorities = new ObservableCollection<Participant>();
|
|
|
|
private readonly ObservableCollection<Role> _roles = new ObservableCollection<Role>();
|
|
private readonly ObservableCollection<Securable> _securables = new ObservableCollection<Securable>();
|
|
private readonly ObservableCollection<User> _users = new ObservableCollection<User>();
|
|
private readonly ObservableCollection<RoleAssignment> _assignedRoles = new ObservableCollection<RoleAssignment>();
|
|
private readonly ObservableCollection<SecurableAssignment> _assignedSecurables = new ObservableCollection<SecurableAssignment>();
|
|
private readonly ObservableCollection<Berth> _berths = new ObservableCollection<Berth>();
|
|
private readonly ObservableCollection<Ship> _ships = new ObservableCollection<Ship>();
|
|
private readonly ObservableCollection<Port> _ports = new ObservableCollection<Port>();
|
|
private readonly ObservableCollection<PortAssignment> _assignedPorts = new ObservableCollection<PortAssignment>();
|
|
private DBManager _dbManager;
|
|
|
|
#endregion
|
|
|
|
#region Construction / Loading
|
|
|
|
public MainWindow()
|
|
{
|
|
InitializeComponent();
|
|
_dbManager = new();
|
|
System.Text.Encoding.RegisterProvider(System.Text.CodePagesEncodingProvider.Instance); // for ExcelDataReader on .NET Core
|
|
}
|
|
|
|
private async void Window_Loaded(object sender, RoutedEventArgs e)
|
|
{
|
|
try
|
|
{
|
|
DBManager.SetConnectionString(Properties.Settings.Default.ConnectionString);
|
|
|
|
// load all participants
|
|
List<Participant> participants = await Participant.LoadAll(_dbManager);
|
|
participants.Sort((x, y) => string.Compare(x.Name, y.Name));
|
|
|
|
foreach (Participant p in participants)
|
|
{
|
|
_participants.Add(p);
|
|
if(p.IsTypeFlagSet(Participant.ParticipantType.TERMINAL)) { _terminals.Add(p); }
|
|
if(p.IsTypeFlagSet(Participant.ParticipantType.PORT_ADMINISTRATION)) { _authorities.Add(p); }
|
|
}
|
|
this.listBoxParticipant.ItemsSource = _participants;
|
|
|
|
// load all roles
|
|
foreach(Role r in await Role.LoadAll(_dbManager))
|
|
_roles.Add(r);
|
|
this.listBoxRoles.ItemsSource = _roles;
|
|
|
|
// load all securables
|
|
foreach(Securable s in await Securable.LoadAll(_dbManager))
|
|
_securables.Add(s);
|
|
this.listBoxSecurables.ItemsSource = _securables;
|
|
|
|
// load all ports
|
|
foreach (Port port in await Port.LoadAll(_dbManager)) _ports.Add(port);
|
|
this.listBoxPort.ItemsSource = _ports;
|
|
|
|
// load all berths
|
|
foreach (Berth b in await Berth.LoadAll(_dbManager))
|
|
{
|
|
_berths.Add(b);
|
|
if (b.Owner_Id != null)
|
|
{
|
|
b.Owner = participants.Where(p => p.Id == b.Owner_Id).FirstOrDefault();
|
|
}
|
|
if (b.Authority_Id != null)
|
|
{
|
|
b.Authority = participants.Where(p => p.Id == b.Authority_Id).FirstOrDefault();
|
|
}
|
|
if (b.Port_Id != null)
|
|
{
|
|
b.Port = _ports.Where(p => p.Id == b.Port_Id).FirstOrDefault();
|
|
}
|
|
}
|
|
this.dataGridBerths.Initialize();
|
|
this.dataGridBerths.ItemsSource = _berths;
|
|
|
|
this.dataGridBerths.CreateRequested += DataGridBerths_CreateRequested;
|
|
this.dataGridBerths.EditRequested += DataGridBerths_EditRequested;
|
|
this.dataGridBerths.DeleteRequested += DataGridBerths_DeleteRequested;
|
|
|
|
|
|
// load all ships
|
|
foreach (Ship s in await Ship.LoadAll(_dbManager))
|
|
{
|
|
_ships.Add(s);
|
|
if(s.Participant_Id != null)
|
|
{
|
|
s.Participant = participants.Where( p => p.Id == s.Participant_Id ).FirstOrDefault();
|
|
}
|
|
}
|
|
this.dataGridShips.Initialize();
|
|
this.dataGridShips.ItemsSource = _ships;
|
|
|
|
this.dataGridShips.CreateRequested += DataGridShips_CreateRequested;
|
|
this.dataGridShips.EditRequested += DataGridShips_EditRequested;
|
|
this.dataGridShips.DeleteRequested += DataGridShips_DeleteRequested;
|
|
|
|
|
|
// set other item sources (filled later after selection)
|
|
this.listBoxUser.ItemsSource = _users;
|
|
this.listBoxRoleSecurables.ItemsSource = _assignedSecurables;
|
|
this.listBoxUserRoles.ItemsSource = _assignedRoles;
|
|
this.listBoxPortAssignment.ItemsSource = _assignedPorts;
|
|
|
|
this.comboBoxParticipantType.ItemsSource = EnumHelper.GetAllValuesAndDescription(typeof(Participant.ParticipantType));
|
|
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
MessageBox.Show($"Database connection couldn't be established: {ex.Message}");
|
|
this.Close();
|
|
}
|
|
}
|
|
|
|
#region ship context menu callbacks
|
|
|
|
private async void DataGridShips_DeleteRequested(DbEntity obj)
|
|
{
|
|
if (obj is Ship s)
|
|
{
|
|
await s.Delete(this._dbManager);
|
|
this._ships.Remove(s);
|
|
}
|
|
}
|
|
|
|
private async void DataGridShips_EditRequested(DbEntity obj)
|
|
{
|
|
if(obj is Ship s)
|
|
{
|
|
EditShipDialog esd = new();
|
|
esd.Ship = s;
|
|
esd.Participants.AddRange(this._participants);
|
|
if (esd.ShowDialog() ?? false)
|
|
{
|
|
await s.Save(_dbManager);
|
|
this.dataGridShips.ItemsSource = null;
|
|
this.dataGridShips.ItemsSource = _ships;
|
|
}
|
|
}
|
|
}
|
|
|
|
private async void DataGridShips_CreateRequested()
|
|
{
|
|
Ship s = new();
|
|
EditShipDialog esd = new();
|
|
esd.Ship = s;
|
|
esd.Participants.AddRange(this._participants);
|
|
if(esd.ShowDialog() ?? false)
|
|
{
|
|
_ships.Add(s);
|
|
await s.Save(_dbManager);
|
|
this.dataGridShips.ItemsSource = null;
|
|
this.dataGridShips.ItemsSource = _ships;
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region berth context menu callbacks
|
|
|
|
private async void DataGridBerths_DeleteRequested(DbEntity obj)
|
|
{
|
|
if (obj is Berth b)
|
|
{
|
|
await b.Delete(this._dbManager);
|
|
this._berths.Remove(b);
|
|
}
|
|
}
|
|
|
|
private async void DataGridBerths_EditRequested(DbEntity obj)
|
|
{
|
|
if(obj is Berth b)
|
|
{
|
|
EditBerthDialog ebd = new();
|
|
ebd.Berth = b;
|
|
ebd.Owners.AddRange(this._terminals);
|
|
ebd.Authorities.AddRange(this._authorities);
|
|
ebd.Ports.AddRange(this._ports.Where(p => !p.IsDeleted));
|
|
if (ebd.ShowDialog() ?? false)
|
|
{
|
|
await b.Save(_dbManager);
|
|
this.dataGridBerths.ItemsSource = null; // extreme stupidity for me not wanting to implement INotifyPropertyChanged
|
|
this.dataGridBerths.ItemsSource = _berths;
|
|
}
|
|
}
|
|
}
|
|
|
|
private async void DataGridBerths_CreateRequested()
|
|
{
|
|
Berth b = new();
|
|
EditBerthDialog ebd = new();
|
|
ebd.Berth = b;
|
|
ebd.Owners.AddRange(this._terminals);
|
|
ebd.Authorities.AddRange(this._authorities);
|
|
ebd.Ports.AddRange(_ports.Where(p => !p.IsDeleted));
|
|
if (ebd.ShowDialog() ?? false)
|
|
{
|
|
_berths.Add(b);
|
|
await b.Save(_dbManager);
|
|
this.dataGridBerths.ItemsSource = null;
|
|
this.dataGridBerths.ItemsSource = _berths;
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#endregion
|
|
|
|
#region button callbacks
|
|
|
|
private async void buttonParticipantSave_Click(object sender, RoutedEventArgs e)
|
|
{
|
|
Participant? p = this.listBoxParticipant.SelectedItem as Participant;
|
|
if (p != null)
|
|
{
|
|
p.Name = this.textBoxParticipantName.Text.Trim();
|
|
p.Street = this.textBoxParticipantStreet.Text.Trim();
|
|
p.PostalCode = this.textBoxParticipantPostalCode.Text.Trim();
|
|
p.City = this.textBoxParticipantCity.Text.Trim();
|
|
p.SetFlag(this.checkBoxParticipantAllowBSMD.IsChecked ?? false, Participant.ParticipantFlags.ALLOW_BSMD);
|
|
p.Type = 0;
|
|
for(int i = 0; i < this.comboBoxParticipantType?.SelectedItems.Count; i++)
|
|
{
|
|
object? v = this.comboBoxParticipantType?.SelectedItems[i];
|
|
if (v != null)
|
|
{
|
|
KeyValuePair<string, string> kvp = (KeyValuePair<string, string>)v;
|
|
Participant.ParticipantType pType = (Participant.ParticipantType)Enum.Parse(typeof(Participant.ParticipantType), kvp.Key);
|
|
p.SetTypeFlag(true, pType);
|
|
}
|
|
}
|
|
await p.Save(_dbManager);
|
|
this.listBoxParticipant.ItemsSource = null;
|
|
this.listBoxParticipant.ItemsSource = _participants;
|
|
this.listBoxParticipant.SelectedItem = p;
|
|
}
|
|
}
|
|
|
|
private async void buttonUserSave_Click(object sender, RoutedEventArgs e)
|
|
{
|
|
User? u = this.listBoxUser.SelectedItem as User;
|
|
if(u != null)
|
|
{
|
|
u.Firstname = this.textBoxUserFirstName.Text.Trim();
|
|
u.Lastname = this.textBoxUserLastName.Text.Trim();
|
|
u.Username = this.textBoxUserUserName.Text.Trim();
|
|
u.EMail = this.textBoxUserEMail.Text.Trim();
|
|
u.Phone = this.textBoxUserPhone.Text.Trim();
|
|
if(this.textBoxUserPassword.Text.Trim().Length > 0 )
|
|
{
|
|
string passwortText = this.textBoxUserPassword.Text.Trim();
|
|
byte[] bytes = Encoding.Default.GetBytes(passwortText);
|
|
passwortText = Encoding.UTF8.GetString(bytes);
|
|
// Das sollte nicht verändert werden um kompatibel zu der Python Implementierung zu bleiben
|
|
string salt = BCrypt.Net.BCrypt.GenerateSalt(12, 'b');
|
|
u.PasswordHash = BCrypt.Net.BCrypt.HashPassword(passwortText, salt);
|
|
}
|
|
u.APIKey = this.textBoxUserAPIKey.Text.Trim();
|
|
await u.Save(_dbManager);
|
|
this.listBoxUser.ItemsSource = null;
|
|
this.listBoxUser.ItemsSource = _users;
|
|
this.listBoxUser.SelectedItem = u;
|
|
}
|
|
}
|
|
|
|
private async void buttonAddRole_Click(object sender, RoutedEventArgs e)
|
|
{
|
|
Role? r = this.listBoxRoles.SelectedItem as Role;
|
|
User? u = this.listBoxUser.SelectedItem as User;
|
|
if((r != null) && (u != null))
|
|
{
|
|
// test if assignment is already present
|
|
bool foundMatchingAssignment = false;
|
|
foreach(RoleAssignment ra in _assignedRoles)
|
|
{
|
|
if((ra.UserId == u.Id) && (ra.RoleId == r.Id))
|
|
{
|
|
foundMatchingAssignment = true;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if(!foundMatchingAssignment)
|
|
{
|
|
RoleAssignment ra = new RoleAssignment();
|
|
ra.UserId = (int) u.Id;
|
|
ra.RoleId = (int) r.Id;
|
|
ra.AssignedRole = r;
|
|
ra.AssignedUser = u;
|
|
await ra.Save(_dbManager);
|
|
_assignedRoles.Add(ra);
|
|
}
|
|
}
|
|
}
|
|
|
|
private async void buttonRemoveRole_Click(object sender, RoutedEventArgs e)
|
|
{
|
|
// remove role from user
|
|
RoleAssignment? ra = this.listBoxUserRoles.SelectedItem as RoleAssignment;
|
|
if(ra != null)
|
|
{
|
|
await ra.Delete(_dbManager);
|
|
if(_assignedRoles.Contains(ra))
|
|
_assignedRoles.Remove(ra);
|
|
}
|
|
}
|
|
|
|
private async void buttonAddSecurable_Click(object sender, RoutedEventArgs e)
|
|
{
|
|
if ((this.listBoxRoles.SelectedItem is Role r) && (this.listBoxSecurables.SelectedItem is Securable s))
|
|
{
|
|
// test if assignment is already present
|
|
bool foundMatchingAssignment = false;
|
|
foreach (SecurableAssignment sa in _assignedSecurables)
|
|
{
|
|
if ((sa.SecurableId == s.Id) && (sa.RoleId == r.Id))
|
|
{
|
|
foundMatchingAssignment = true;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (!foundMatchingAssignment)
|
|
{
|
|
SecurableAssignment sa = new SecurableAssignment();
|
|
sa.SecurableId = (int)s.Id;
|
|
sa.RoleId = (int)r.Id;
|
|
sa.AssignedRole = r;
|
|
sa.AssignedSecurable = s;
|
|
await sa.Save(_dbManager);
|
|
_assignedSecurables.Add(sa);
|
|
}
|
|
}
|
|
}
|
|
|
|
private async void buttonRemoveSecurable_Click(object sender, RoutedEventArgs e)
|
|
{
|
|
SecurableAssignment? sa = this.listBoxRoleSecurables.SelectedItem as SecurableAssignment;
|
|
if(sa != null)
|
|
{
|
|
await sa.Delete(_dbManager);
|
|
if (_assignedSecurables.Contains(sa))
|
|
_assignedSecurables.Remove(sa);
|
|
}
|
|
}
|
|
|
|
private async void buttonSaveSecurable_Click(object sender, RoutedEventArgs e)
|
|
{
|
|
Securable? s = this.listBoxSecurables.SelectedItem as Securable;
|
|
if(s != null)
|
|
{
|
|
s.Name = this.textBoxSecurableName.Text.Trim();
|
|
await s.Save(_dbManager);
|
|
this.listBoxSecurables.ItemsSource = null;
|
|
this.listBoxSecurables.ItemsSource = _securables;
|
|
this.listBoxSecurables.SelectedItem = s;
|
|
}
|
|
}
|
|
|
|
private async void buttonSaveRole_Click(object sender, RoutedEventArgs e)
|
|
{
|
|
Role? r = this.listBoxRoles.SelectedItem as Role;
|
|
if(r != null)
|
|
{
|
|
r.Name = this.textBoxRoleName.Text.Trim();
|
|
r.Description = this.textBoxRoleDescription.Text.Trim();
|
|
await r.Save(_dbManager);
|
|
this.listBoxRoles.ItemsSource = null;
|
|
this.listBoxRoles.ItemsSource = _roles;
|
|
this.listBoxRoles.SelectedItem = r;
|
|
}
|
|
}
|
|
|
|
private async void buttonPortSave_Click(object sender, RoutedEventArgs e)
|
|
{
|
|
Port? p = this.listBoxPort.SelectedItem as Port;
|
|
if (p != null)
|
|
{
|
|
p.Name = this.textBoxPortName.Text.Trim();
|
|
p.Locode = this.textBoxPortLocode.Text.Trim();
|
|
await p.Save(_dbManager);
|
|
this.listBoxPort.ItemsSource = null;
|
|
this.listBoxPort.ItemsSource = _ports;
|
|
this.listBoxPort.SelectedItem = p;
|
|
}
|
|
}
|
|
|
|
private async void buttonAddPortAssignment_Click(object sender, RoutedEventArgs e)
|
|
{
|
|
if ((this.listBoxPort.SelectedItem is Port p) && (this.listBoxParticipant.SelectedItem is Participant pa))
|
|
{
|
|
// test if assignment is already present
|
|
bool foundMatchingAssignment = false;
|
|
foreach (PortAssignment portAssignment in _assignedPorts)
|
|
{
|
|
if ((portAssignment.PortId == p.Id) && (portAssignment.ParticipantId == pa.Id))
|
|
{
|
|
foundMatchingAssignment = true;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (!foundMatchingAssignment)
|
|
{
|
|
PortAssignment portAssignment = new PortAssignment();
|
|
portAssignment.PortId = (int)p.Id;
|
|
portAssignment.ParticipantId = (int)pa.Id;
|
|
portAssignment.AssignedParticipant = pa;
|
|
portAssignment.AssignedPort = p;
|
|
await portAssignment.Save(_dbManager);
|
|
_assignedPorts.Add(portAssignment);
|
|
}
|
|
}
|
|
}
|
|
|
|
private async void buttonRemovePortAssignment_Click(object sender, RoutedEventArgs e)
|
|
{
|
|
PortAssignment? pa = this.listBoxPortAssignment.SelectedItem as PortAssignment;
|
|
if (pa != null)
|
|
{
|
|
await pa.Delete(_dbManager);
|
|
if (_assignedPorts.Contains(pa))
|
|
_assignedPorts.Remove(pa);
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region listbox selection callbacks
|
|
|
|
private async void listBoxParticipant_SelectionChanged(object sender, SelectionChangedEventArgs e)
|
|
{
|
|
Participant? p = this.listBoxParticipant.SelectedItem as Participant;
|
|
|
|
this.textBoxParticipantName.Text = (p != null) ? p.Name : string.Empty;
|
|
this.textBoxParticipantStreet.Text = (p != null) ? p.Street : string.Empty;
|
|
this.textBoxParticipantPostalCode.Text = (p != null) ? p.PostalCode : string.Empty;
|
|
this.textBoxParticipantCity.Text = (p != null) ? p.City : string.Empty;
|
|
this.textBoxParticipantCreated.Text = (p != null) ? p.Created.ToString() : string.Empty;
|
|
this.checkboxParticipantDeleted.IsChecked = (p != null) ? p.Deleted : null;
|
|
this.textBoxParticipantModified.Text = (p != null) ? p.Modified.ToString() : string.Empty;
|
|
this.checkBoxParticipantAllowBSMD.IsChecked = (p != null) ? p.IsFlagSet(Participant.ParticipantFlags.ALLOW_BSMD) : null;
|
|
this.comboBoxParticipantType.SelectedItems.Clear();
|
|
bool hasAgencyType = false;
|
|
if (p != null)
|
|
{
|
|
foreach (Participant.ParticipantType pType in Enum.GetValues(typeof(Participant.ParticipantType)))
|
|
{
|
|
if (p.IsTypeFlagSet(pType))
|
|
{
|
|
if(pType == Participant.ParticipantType.AGENCY) hasAgencyType = true;
|
|
foreach (KeyValuePair<string, string> kvp in this.comboBoxParticipantType.Items)
|
|
{
|
|
if (kvp.Key.Equals(pType.ToString()))
|
|
{
|
|
this.comboBoxParticipantType.SelectedItems.Add(kvp);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
this.checkBoxParticipantAllowBSMD.IsEnabled = hasAgencyType;
|
|
|
|
// -> load users for this participant selection
|
|
this._users.Clear();
|
|
if (p != null)
|
|
{
|
|
foreach (User u in await User.LoadForParticipant(p, _dbManager))
|
|
_users.Add(u);
|
|
}
|
|
|
|
// -> load port assignments for this participant selection
|
|
this._assignedPorts.Clear();
|
|
if(p != null)
|
|
{
|
|
foreach (PortAssignment pa in await PortAssignment.LoadForParticipant(p, this._dbManager))
|
|
{
|
|
foreach (Port port in this._ports)
|
|
if (pa.PortId == port.Id)
|
|
pa.AssignedPort = port;
|
|
_assignedPorts.Add(pa);
|
|
}
|
|
}
|
|
|
|
this.contextMenuUser.IsEnabled = !p.Deleted;
|
|
this.buttonAddPortAssignment.IsEnabled = !p.Deleted;
|
|
this.buttonRemovePortAssignment.IsEnabled = !p.Deleted;
|
|
|
|
}
|
|
|
|
private async void listBoxRoles_SelectionChanged(object sender, SelectionChangedEventArgs e)
|
|
{
|
|
Role? r = this.listBoxRoles.SelectedItem as Role;
|
|
this.textBoxRoleName.Text = (r != null) ? r.Name : string.Empty;
|
|
this.textBoxRoleDescription.Text = (r != null) ? r.Description : string.Empty;
|
|
|
|
_assignedSecurables.Clear();
|
|
if (r != null)
|
|
{
|
|
// load assigned securables
|
|
foreach (SecurableAssignment sa in await SecurableAssignment.LoadForRole(r, _dbManager))
|
|
{
|
|
foreach (Securable s in this._securables)
|
|
{
|
|
if (sa.SecurableId == s.Id)
|
|
{
|
|
sa.AssignedSecurable = s;
|
|
break;
|
|
}
|
|
}
|
|
_assignedSecurables.Add(sa);
|
|
}
|
|
}
|
|
}
|
|
|
|
private async void listBoxUser_SelectionChanged(object sender, SelectionChangedEventArgs e)
|
|
{
|
|
User? u = this.listBoxUser.SelectedItem as User;
|
|
this.textBoxUserFirstName.Text = (u != null) ? u.Firstname : string.Empty;
|
|
this.textBoxUserLastName.Text = (u != null) ? u.Lastname : string.Empty;
|
|
this.textBoxUserUserName.Text = (u != null) ? u.Username : string.Empty;
|
|
this.textBoxUserEMail.Text = (u != null) ? u.EMail : string.Empty;
|
|
this.textBoxUserPhone.Text = (u != null) ? u.Phone : string.Empty;
|
|
this.textBoxUserAPIKey.Text = (u != null) ? u.APIKey : string.Empty;
|
|
this.textBoxUserCreated.Text = (u != null) ? u.Created.ToString() : string.Empty;
|
|
this.textBoxUserModified.Text = (u != null) ? u.Modified.ToString() : string.Empty;
|
|
this.textBoxUserPassword.Text = string.Empty;
|
|
|
|
_assignedRoles.Clear();
|
|
|
|
if (u != null)
|
|
{
|
|
// load roles assigned to user
|
|
foreach (RoleAssignment ra in await RoleAssignment.LoadForUser(u, _dbManager))
|
|
{
|
|
foreach (Role r in this._roles)
|
|
{
|
|
if (ra.RoleId == r.Id)
|
|
{
|
|
ra.AssignedRole = r;
|
|
break;
|
|
}
|
|
}
|
|
_assignedRoles.Add(ra);
|
|
}
|
|
}
|
|
}
|
|
|
|
private void listBoxSecurables_SelectionChanged(object sender, SelectionChangedEventArgs e)
|
|
{
|
|
Securable? s = this.listBoxSecurables.SelectedItem as Securable;
|
|
this.textBoxSecurableName.Text = (s != null) ? s.Name : string.Empty;
|
|
}
|
|
|
|
private void listBoxPort_SelectionChanged(object sender, SelectionChangedEventArgs e)
|
|
{
|
|
Port? p = this.listBoxPort.SelectedItem as Port;
|
|
this.textBoxPortName.Text = (p != null) ? p.Name : string.Empty;
|
|
this.textBoxPortLocode.Text = (p != null) ? p.Locode : string.Empty;
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region menuitem callbacks
|
|
|
|
private async void menuItemDeleteParticipant_Click(object sender, RoutedEventArgs e)
|
|
{
|
|
try
|
|
{
|
|
if(this.listBoxParticipant.SelectedItem is Participant p)
|
|
{
|
|
await p.Delete(_dbManager);
|
|
p.Deleted = true;
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
MessageBox.Show(ex.Message, "Error", MessageBoxButton.OK, MessageBoxImage.Error);
|
|
}
|
|
}
|
|
|
|
private void menuItemNewParticipant_Click(object sender, RoutedEventArgs e)
|
|
{
|
|
Participant p = new();
|
|
this._participants.Add(p);
|
|
this.listBoxParticipant.SelectedItem = p;
|
|
}
|
|
|
|
private void menuItemNewUser_Click(object sender, RoutedEventArgs e)
|
|
{
|
|
Participant? p = this.listBoxParticipant.SelectedItem as Participant;
|
|
if(p != null)
|
|
{
|
|
User u = new();
|
|
u.Participant_Id = p.Id;
|
|
_users.Add(u);
|
|
this.listBoxUser.SelectedItem = u;
|
|
}
|
|
}
|
|
|
|
private async void menuItemDeleteUser_Click(object sender, RoutedEventArgs e)
|
|
{
|
|
try
|
|
{
|
|
if (this.listBoxUser.SelectedItem is User u)
|
|
{
|
|
await u.ExecuteNonQuery(_dbManager); // extra history delete happens here
|
|
await u.Delete(_dbManager);
|
|
this._users.Remove(u);
|
|
}
|
|
}
|
|
catch(Exception ex)
|
|
{
|
|
MessageBox.Show(ex.Message, "Error", MessageBoxButton.OK, MessageBoxImage.Error);
|
|
}
|
|
}
|
|
|
|
private void menuItemNewRole_Click(object sender, RoutedEventArgs e)
|
|
{
|
|
Role r = new();
|
|
this._roles.Add(r);
|
|
this.listBoxRoles.SelectedItem = r;
|
|
}
|
|
|
|
private async void menuItemDeleteRole_Click(object sender, RoutedEventArgs e)
|
|
{
|
|
try
|
|
{
|
|
if (this.listBoxRoles.SelectedItem is Role r)
|
|
{
|
|
await r.Delete(_dbManager);
|
|
this._roles.Remove(r);
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
MessageBox.Show(ex.Message, "Error", MessageBoxButton.OK, MessageBoxImage.Error);
|
|
}
|
|
}
|
|
|
|
private void menuItemNewSecurable_Click(object sender, RoutedEventArgs e)
|
|
{
|
|
Securable s = new Securable();
|
|
_securables.Add(s);
|
|
this.listBoxSecurables.SelectedItem = s;
|
|
}
|
|
|
|
private async void menuItemDeleteSecurable_Click(object sender, RoutedEventArgs e)
|
|
{
|
|
try
|
|
{
|
|
if (this.listBoxSecurables.SelectedItem is Securable s)
|
|
{
|
|
await s.Delete(_dbManager);
|
|
this._securables.Remove(s);
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
MessageBox.Show(ex.Message, "Error", MessageBoxButton.OK, MessageBoxImage.Error);
|
|
}
|
|
}
|
|
|
|
private void menuItemNewPort_Click(object sender, RoutedEventArgs e)
|
|
{
|
|
Port p = new();
|
|
this._ports.Add(p);
|
|
this.listBoxPort.SelectedItem = p;
|
|
}
|
|
|
|
private async void menuItemDeletePort_Click(object sender, RoutedEventArgs e)
|
|
{
|
|
try
|
|
{
|
|
if (this.listBoxPort.SelectedItem is Port p)
|
|
{
|
|
await p.Delete(_dbManager);
|
|
this._ports.Remove(p);
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
MessageBox.Show(ex.Message, "Error", MessageBoxButton.OK, MessageBoxImage.Error);
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region Excel import
|
|
|
|
private async void buttonImportBerths_Click(object sender, RoutedEventArgs e)
|
|
{
|
|
OpenFileDialog ofd = new OpenFileDialog
|
|
{
|
|
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<Berth> importBerthList = new();
|
|
int bCounter = 0;
|
|
int pCounter = 0;
|
|
|
|
try
|
|
{
|
|
do
|
|
{
|
|
while (reader.Read())
|
|
{
|
|
if (reader.FieldCount < 2)
|
|
{
|
|
throw new InvalidDataException("Sheet must have at least 3 Columns of data");
|
|
}
|
|
|
|
if (reader.IsDBNull(0) && reader.IsDBNull(1)) continue;
|
|
string berth_name = "";
|
|
if (!reader.IsDBNull(0)) berth_name = reader.GetString(0);
|
|
if (berth_name.Equals("Liegeplatz", StringComparison.OrdinalIgnoreCase)) continue;
|
|
|
|
string participant_name = "";
|
|
if (!reader.IsDBNull(1)) participant_name = reader.GetString(1);
|
|
|
|
// find berth in existing list
|
|
if (_berths.Any(predicate: x => (x.Name != null) && x.Name.Equals(berth_name, StringComparison.OrdinalIgnoreCase)))
|
|
continue;
|
|
|
|
string port_name = "";
|
|
if (!reader.IsDBNull(2)) port_name = reader.GetString(2);
|
|
|
|
// find port in list
|
|
if(!_ports.Any(x => (x.Name != null) && x.Name.Equals(port_name, StringComparison.OrdinalIgnoreCase)))
|
|
continue;
|
|
|
|
Port port = _ports.First(x => (x.Name != null) && x.Name.Equals(port_name, StringComparison.OrdinalIgnoreCase));
|
|
|
|
Berth b = new Berth();
|
|
b.Name = berth_name;
|
|
b.Port = port;
|
|
b.Port_Id = port.Id;
|
|
|
|
bool found_participant = false;
|
|
|
|
foreach(Participant p in this._participants)
|
|
{
|
|
if ((p.Name != null) && p.Name.Contains(participant_name, StringComparison.OrdinalIgnoreCase))
|
|
{
|
|
b.Owner_Id = p.Id;
|
|
found_participant = true;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (!found_participant)
|
|
{
|
|
// create new participant
|
|
Participant p = new Participant();
|
|
p.Name = participant_name;
|
|
p.Type = (uint) Participant.ParticipantType.TERMINAL;
|
|
await p.Save(_dbManager);
|
|
_participants.Add(p);
|
|
pCounter++;
|
|
b.Owner_Id = p.Id;
|
|
}
|
|
|
|
await b.Save(_dbManager);
|
|
_berths.Add(b);
|
|
bCounter++;
|
|
|
|
}
|
|
} while (reader.NextResult());
|
|
|
|
if((pCounter > 0) || (bCounter > 0))
|
|
{
|
|
MessageBox.Show($"Imported {bCounter} berths and added {pCounter} participants while doing so");
|
|
}
|
|
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
MessageBox.Show("Error reading Excel: " + ex.Message, "Error", MessageBoxButton.OK, MessageBoxImage.Error);
|
|
}
|
|
}
|
|
|
|
stream.Close();
|
|
|
|
}
|
|
}
|
|
|
|
private async void buttonImportShipss_Click(object sender, RoutedEventArgs e)
|
|
{
|
|
OpenFileDialog ofd = new OpenFileDialog
|
|
{
|
|
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<Ship> importShipList = new();
|
|
int bCounter = 0;
|
|
int pCounter = 0;
|
|
|
|
try
|
|
{
|
|
do
|
|
{
|
|
while (reader.Read())
|
|
{
|
|
if (reader.FieldCount < 4)
|
|
{
|
|
throw new InvalidDataException("Sheet must have at least 4 Columns of data");
|
|
}
|
|
|
|
if (reader.IsDBNull(0) && reader.IsDBNull(1)) continue;
|
|
string ship_name = "";
|
|
if (!reader.IsDBNull(0)) ship_name = reader.GetString(0);
|
|
if (ship_name.Equals("Name", StringComparison.OrdinalIgnoreCase)) continue;
|
|
|
|
// find ship in existing list
|
|
if (_ships.Any(predicate: x => (x.Name != null) && x.Name.Equals(ship_name, StringComparison.OrdinalIgnoreCase)))
|
|
continue;
|
|
|
|
Ship s = new();
|
|
s.Name = ship_name;
|
|
|
|
if (!reader.IsDBNull(1))
|
|
s.IMO = (int) reader.GetDouble(1);
|
|
if (!reader.IsDBNull(2))
|
|
s.Length = reader.GetDouble(2);
|
|
if(!reader.IsDBNull(3))
|
|
s.Width = reader.GetDouble(3);
|
|
|
|
await s.Save(_dbManager);
|
|
_ships.Add(s);
|
|
bCounter++;
|
|
|
|
}
|
|
} while (reader.NextResult());
|
|
|
|
if ((pCounter > 0) || (bCounter > 0))
|
|
{
|
|
MessageBox.Show($"Imported {bCounter} ships");
|
|
}
|
|
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
MessageBox.Show("Error reading Excel: " + ex.Message, "Error", MessageBoxButton.OK, MessageBoxImage.Error);
|
|
}
|
|
}
|
|
|
|
stream.Close();
|
|
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region private static helper
|
|
|
|
private static BitmapImage? LoadImage(byte[] imageData)
|
|
{
|
|
if (imageData == null || imageData.Length == 0) return null;
|
|
var image = new BitmapImage();
|
|
using (var mem = new MemoryStream(imageData))
|
|
{
|
|
mem.Position = 0;
|
|
image.BeginInit();
|
|
image.CreateOptions = BitmapCreateOptions.PreservePixelFormat;
|
|
image.CacheOption = BitmapCacheOption.OnLoad;
|
|
image.UriSource = null;
|
|
image.StreamSource = mem;
|
|
image.EndInit();
|
|
}
|
|
image.Freeze();
|
|
return image;
|
|
}
|
|
|
|
#endregion
|
|
|
|
}
|
|
}
|