333 lines
14 KiB
C#
333 lines
14 KiB
C#
///
|
|
/// Copyright (c) 2021-2022 Sensus Slovensko a.s.
|
|
///
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.Linq;
|
|
using System.Windows.Forms;
|
|
using log4net;
|
|
using NHibernate;
|
|
using SharedDatabase;
|
|
using SharedDatabase.Entities;
|
|
using OrderManagement.Resources;
|
|
|
|
namespace OrderManagement
|
|
{
|
|
public partial class EditOrderDlg : Form
|
|
{
|
|
private static readonly ILog log = LogManager.GetLogger(typeof(EditOrderDlg));
|
|
|
|
ISessionFactory sessionFactory;
|
|
OrderInfo oriOrder;
|
|
IList<OrderInfo> listOfOrders;
|
|
bool isEnablePredefinedOrders;
|
|
bool editMode;
|
|
|
|
EditParametersCtrl editParametersCtrl;
|
|
|
|
public EditOrderDlg(ISessionFactory sessionFactory, OrderInfo order, IList<OrderInfo> listOfOrders, bool isEnablePredefinedOrders = false, bool editMode = false)
|
|
{
|
|
InitializeComponent();
|
|
|
|
this.sessionFactory = sessionFactory;
|
|
this.oriOrder = order;
|
|
this.listOfOrders = listOfOrders;
|
|
this.isEnablePredefinedOrders = isEnablePredefinedOrders;
|
|
this.editMode = editMode;
|
|
|
|
editParametersCtrl = new EditParametersCtrl(oriOrder.Clone());
|
|
editParametersCtrl.Dock = DockStyle.Fill;
|
|
editParametersCtrl.Unlock();
|
|
splitContainer1.Panel1.Controls.Add(editParametersCtrl);
|
|
|
|
Localize();
|
|
}
|
|
|
|
void Localize()
|
|
{
|
|
Text = Strings.Producton_order_properties;
|
|
okButton.Text = Strings.OK;
|
|
cancelButton.Text = Strings.Cancel;
|
|
}
|
|
|
|
private void okButton_Click(object sender, EventArgs e)
|
|
{
|
|
OrderInfo modifiedOrder = editParametersCtrl.ParamsProvider as OrderInfo;
|
|
|
|
long modifiedOrderNr;
|
|
if (!long.TryParse(modifiedOrder.POName, out modifiedOrderNr) ||
|
|
modifiedOrderNr <= 0 ||
|
|
(!isEnablePredefinedOrders && modifiedOrderNr <= OrderManagementDlg.MaxPredefinedOrderNr))
|
|
{
|
|
MessageBox.Show(string.Format(Strings.Order_number_must_be_larger_then_0, OrderManagementDlg.MaxPredefinedOrderNr));
|
|
return;
|
|
}
|
|
|
|
OrderInfo orderWithTheSameName = listOfOrders.FirstOrDefault(x => (x.POName == modifiedOrder.POName));
|
|
|
|
if (orderWithTheSameName != null && (!editMode || modifiedOrder.POName != oriOrder.POName))
|
|
{
|
|
MessageBox.Show(Strings.Order_with_the_same_ID_already_exists);
|
|
return;
|
|
}
|
|
|
|
if (IsConflict(modifiedOrder, listOfOrders, editMode ? oriOrder : null))
|
|
{
|
|
return;
|
|
}
|
|
|
|
Cursor.Current = Cursors.WaitCursor;
|
|
|
|
ITransaction transaction = null;
|
|
bool oriOrdermodified = false;
|
|
bool saved = false;
|
|
try
|
|
{
|
|
ISession session = sessionFactory.OpenSession();
|
|
transaction = session.BeginTransaction();
|
|
|
|
var list = (oriOrder.Id != 0)
|
|
? session.QueryOver<OrderInfo>().Where(x => x.Id == oriOrder.Id).List()
|
|
: new List<OrderInfo> { oriOrder };
|
|
|
|
if (list.Count != 1)
|
|
{
|
|
transaction.Rollback();
|
|
}
|
|
else if (list[0].Equals(oriOrder, true))
|
|
{
|
|
modifiedOrder.CopyContentTo(list[0], true);
|
|
session.SaveOrUpdate(list[0]);
|
|
transaction.Commit();
|
|
session.Flush();
|
|
list[0].CopyContentTo(oriOrder, false);
|
|
saved = true;
|
|
}
|
|
else
|
|
{
|
|
list[0].CopyContentTo(oriOrder, false);
|
|
transaction.Rollback();
|
|
oriOrdermodified = true;
|
|
}
|
|
}
|
|
catch (Exception exc)
|
|
{
|
|
if (transaction != null) transaction.Rollback();
|
|
log.ErrorFormat("Saving an order failed: {1}", exc.Message);
|
|
}
|
|
|
|
Cursor.Current = Cursors.Default;
|
|
|
|
if (saved)
|
|
{
|
|
DialogResult = DialogResult.OK;
|
|
}
|
|
else if (oriOrdermodified)
|
|
{
|
|
MessageBox.Show("Original order was modified by someone else,\r\ntry to adit this order once again");
|
|
DialogResult = DialogResult.OK;
|
|
}
|
|
else
|
|
{
|
|
MessageBox.Show("Saving the modified order to the database failed");
|
|
DialogResult = DialogResult.Cancel;
|
|
}
|
|
|
|
Close();
|
|
}
|
|
|
|
private void cancelButton_Click(object sender, EventArgs e)
|
|
{
|
|
DialogResult = DialogResult.Cancel;
|
|
Close();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Check for conflicts of serial numbers or radio addresses
|
|
/// </summary>
|
|
/// <param name="order">New or modified order to be checked</param>
|
|
/// <param name="listOfOrders">List of all orders</param>
|
|
/// <param name="orderToIgnore">Order to be ignered when doing check (original order in the edit mode)</param>
|
|
/// <returns>false = OK, true = conflict (MessageBox appears before returning true)</returns>
|
|
bool IsConflict(OrderInfo order, IList<OrderInfo> listOfOrders, OrderInfo orderToIgnore)
|
|
{
|
|
if (order.POName.Length == 7 && order.POName[0] == '3')
|
|
{
|
|
if (MessageBox.Show(string.Format("{0}\r\n{1}", Strings.It_is_not_recommended_that_orders_start_with_3,
|
|
Strings.Abort_creating_an_order_QM),
|
|
Strings.Warning,
|
|
MessageBoxButtons.YesNo,
|
|
MessageBoxIcon.Exclamation) == DialogResult.Yes)
|
|
{
|
|
return true;
|
|
}
|
|
}
|
|
|
|
int snLength = CodeLength(order);
|
|
Int64 snOffset;
|
|
string snStdPrefix = StandardPrefix(order, out snOffset);
|
|
string snStdSuffix = StandardSuffix(order);
|
|
Int64 snFrst = First(order, snOffset);
|
|
Int64 snLast = Last(order, snOffset);
|
|
|
|
int raLength = CodeLength(order, true);
|
|
Int64 raOffset;
|
|
string raStdPrefix = StandardPrefix(order, out raOffset, true);
|
|
string raStdSuffix = StandardSuffix(order, true);
|
|
Int64 raFrst = First(order, raOffset, true);
|
|
Int64 raLast = Last(order, raOffset, true);
|
|
|
|
foreach (var another in listOfOrders)
|
|
{
|
|
if (orderToIgnore != null && orderToIgnore == another) continue;
|
|
|
|
Int64 offset;
|
|
string anotherSnStdPrefix = StandardPrefix(another, out offset);
|
|
Int64 first2 = First(another, offset);
|
|
Int64 last2 = Last(another, offset);
|
|
if (snLength == CodeLength(another) &&
|
|
snStdPrefix == anotherSnStdPrefix &&
|
|
snStdSuffix == StandardSuffix(another) &&
|
|
((first2 <= snFrst && snFrst <= last2 ) ||
|
|
(first2 <= snLast && snLast <= last2 ) ||
|
|
(snFrst <= first2 && first2 <= snLast) ||
|
|
(snFrst <= last2 && last2 <= snLast)))
|
|
{
|
|
if (MessageBox.Show(string.Format("{0}\r\n{1}: s/n {2} .. {3}\r\n{4}: s/n {5} .. {6}\r\n{7}",
|
|
Strings.There_is_a_conflict,
|
|
order.POName,
|
|
order.SNPrefix + order.SNFirst.ToString(string.Format("D{0}", order.SNDigitsCount)) + snStdSuffix,
|
|
order.SNPrefix + (order.SNFirst + order.PiecesCount - 1).ToString(string.Format("D{0}", order.SNDigitsCount)) + snStdSuffix,
|
|
another.POName,
|
|
another.SNPrefix + another.SNFirst.ToString(string.Format("D{0}", another.SNDigitsCount)) + StandardSuffix(another),
|
|
another.SNPrefix + (another.SNFirst + another.PiecesCount - 1).ToString(string.Format("D{0}", another.SNDigitsCount)) + StandardSuffix(another),
|
|
Strings.Abort_creating_an_order_QM),
|
|
Strings.Warning,
|
|
MessageBoxButtons.YesNo,
|
|
MessageBoxIcon.Exclamation) == DialogResult.Yes)
|
|
{
|
|
return true;
|
|
}
|
|
}
|
|
|
|
string anotherRaStdPrefix = StandardPrefix(another, out offset, true);
|
|
first2 = First(another, offset, true);
|
|
last2 = Last(another, offset, true);
|
|
if (!string.IsNullOrEmpty(order.RAPrefix) &&
|
|
!string.IsNullOrEmpty(another.RAPrefix) &&
|
|
raLength == CodeLength(another, true) &&
|
|
raStdPrefix == anotherRaStdPrefix &&
|
|
raStdSuffix == StandardSuffix(another, true) &&
|
|
((first2 <= raFrst && raFrst <= last2 ) ||
|
|
(first2 <= raLast && raLast <= last2 ) ||
|
|
(raFrst <= first2 && first2 <= raLast) ||
|
|
(raFrst <= last2 && last2 <= raLast)))
|
|
{
|
|
if (MessageBox.Show(string.Format("{0}\r\n{1}: radio {2} .. {3}\r\n{4}: radio {5} .. {6}\r\n{7}",
|
|
Strings.There_is_a_conflict,
|
|
order.POName,
|
|
order.RAPrefix + order.RAFirst.ToString(Const.RAFormat) + snStdSuffix,
|
|
order.RAPrefix + (order.RAFirst + order.PiecesCount).ToString(Const.RAFormat) + snStdSuffix,
|
|
another.POName,
|
|
another.RAPrefix + another.RAFirst.ToString(Const.RAFormat) + StandardSuffix(another, true),
|
|
another.RAPrefix + (another.RAFirst + another.PiecesCount).ToString(Const.RAFormat) + StandardSuffix(another, true),
|
|
Strings.Abort_creating_an_order_QM),
|
|
Strings.Warning,
|
|
MessageBoxButtons.YesNo,
|
|
MessageBoxIcon.Exclamation) == DialogResult.Yes)
|
|
{
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
/// Prefix lenght + digits count + Suffix length
|
|
/// </summary>
|
|
/// <param name="order">Order</param>
|
|
/// <param name="isRadio">true = Radio address</param>
|
|
/// <returns>Complete S/N or RA length</returns>
|
|
int CodeLength(OrderInfo order, bool isRadio = false)
|
|
{
|
|
string prefix = isRadio ? order.RAPrefix : order.SNPrefix;
|
|
string suffix = isRadio ? order.RASuffix : order.SNSuffix;
|
|
int digitsCount = isRadio ? 9 : order.SNDigitsCount;
|
|
|
|
return (string.IsNullOrEmpty(prefix) ? 0 : prefix.Length) + digitsCount +
|
|
(string.IsNullOrEmpty(suffix) ? 0 : suffix.Length);
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
/// Standar prefix does not have digits at the end
|
|
/// </summary>
|
|
/// <param name="order">Order</param>
|
|
/// <param name="offset">Offset represented by digits at the end of prefix</param>
|
|
/// <param name="isRadio">true = Radio address</param>
|
|
/// <returns></returns>
|
|
string StandardPrefix(OrderInfo order, out Int64 offset, bool isRadio = false)
|
|
{
|
|
string prefix = isRadio ? order.RAPrefix : order.SNPrefix;
|
|
int digitsCount = isRadio ? 9 : order.SNDigitsCount;
|
|
|
|
if (string.IsNullOrEmpty(prefix))
|
|
{
|
|
offset = 0;
|
|
return string.Empty;
|
|
}
|
|
|
|
for (int i = prefix.Length - 1; i >= 0; i--)
|
|
{
|
|
if (!Char.IsDigit(prefix[i]))
|
|
{
|
|
offset = (i == prefix.Length - 1) ? 0 : Int64.Parse(prefix.Substring(i + 1)) * Convert.ToInt64(Math.Pow(10, digitsCount));
|
|
return prefix.Substring(0, i + 1);
|
|
}
|
|
}
|
|
|
|
offset = Int64.Parse(prefix) * Convert.ToInt64(Math.Pow(10, digitsCount));
|
|
return string.Empty;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Standar suffix is never null, null suffix is converted to string.Empty
|
|
/// </summary>
|
|
/// <param name="order">Order</param>
|
|
/// <param name="isRadio">true = Radio address</param>
|
|
/// <returns></returns>
|
|
string StandardSuffix(OrderInfo order, bool isRadio = false)
|
|
{
|
|
string suffix = isRadio ? order.RASuffix : order.SNSuffix;
|
|
return string.IsNullOrEmpty(suffix) ? string.Empty : suffix;
|
|
}
|
|
|
|
/// <summary>
|
|
/// First S/N or RA of an order extended with digits at the end of prefix
|
|
/// </summary>
|
|
/// <param name="order">Order</param>
|
|
/// <param name="offset">Offset represented by digits at the end of prefix</param>
|
|
/// <param name="isRadio">true = Radio address</param>
|
|
/// <returns>First extended S/N or RA in this order</returns>
|
|
Int64 First(OrderInfo order, Int64 offset, bool isRadio = false)
|
|
{
|
|
return offset + (isRadio ? order.RAFirst : order.SNFirst);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Last S/N or RA of an order extended with digits at the end of prefix
|
|
/// </summary>
|
|
/// <param name="order">Order</param>
|
|
/// <param name="offset">Offset represented by digits at the end of prefix</param>
|
|
/// <param name="isRadio">true = Radio address</param>
|
|
/// <returns>Last extended S/N or RA in this order</returns>
|
|
Int64 Last(OrderInfo order, Int64 offset, bool isRadio = false)
|
|
{
|
|
return First(order, offset, isRadio) + order.PiecesCount - 1;
|
|
}
|
|
}
|
|
}
|