Samuele Locatelli
1201 lines
46 KiB
C#
1201 lines
46 KiB
C#
using AppData;
|
|
using AppData.DS_AppTableAdapters;
|
|
using NKC_SDK;
|
|
using SteamWare;
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.Diagnostics;
|
|
using System.Linq;
|
|
using System.Threading.Tasks;
|
|
using System.Web.UI;
|
|
using System.Web.UI.WebControls;
|
|
|
|
namespace NKC_WF.WebUserControls
|
|
{
|
|
public partial class cmp_batchDetailSplit : BaseUserControl, IDisposable
|
|
{
|
|
#region Public Properties
|
|
|
|
public int BatchId
|
|
{
|
|
set
|
|
{
|
|
hfBatchId.Value = value.ToString();
|
|
if (BatchId > 0)
|
|
{
|
|
checkCreateDescendant();
|
|
doUpdate(true);
|
|
}
|
|
fixRatio();
|
|
}
|
|
get
|
|
{
|
|
int answ = 0;
|
|
int.TryParse(hfBatchId.Value, out answ);
|
|
return answ;
|
|
}
|
|
}
|
|
|
|
public bool enabIsChanged
|
|
{
|
|
get => codEnabled != codEnabledPrev;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Abilitazione azioni button-based
|
|
/// </summary>
|
|
public bool BtnEnabled
|
|
{
|
|
get
|
|
{
|
|
return chkActEnab.Checked;
|
|
}
|
|
set
|
|
{
|
|
chkActEnab.Checked = value;
|
|
}
|
|
}
|
|
|
|
public bool isSplitted
|
|
{
|
|
get
|
|
{
|
|
bool answ = false;
|
|
bool.TryParse(hfIsSplit.Value, out answ);
|
|
return answ;
|
|
}
|
|
set
|
|
{
|
|
hfIsSplit.Value = $"{value}";
|
|
}
|
|
}
|
|
|
|
#endregion Public Properties
|
|
|
|
#region Public Methods
|
|
|
|
public override void Dispose()
|
|
{
|
|
cmp_orderExtListNE01.eh_doRefresh -= Cmp_orderExtListNE01_eh_doRefresh;
|
|
cmp_orderExtListNE02.eh_doRefresh -= Cmp_orderExtListNE02_eh_doRefresh;
|
|
cmp_orderExtListNE03.eh_doRefresh -= Cmp_orderExtListNE03_eh_doRefresh;
|
|
base.Dispose();
|
|
}
|
|
|
|
public void doUpdate(bool doReset)
|
|
{
|
|
fixChildBatch();
|
|
fixRatio();
|
|
checkDisplayMode();
|
|
fixEnabled();
|
|
if (doReset)
|
|
{
|
|
raiseReset();
|
|
}
|
|
}
|
|
|
|
#endregion Public Methods
|
|
|
|
#region Protected Fields
|
|
|
|
protected double Ratio01 = 0;
|
|
protected double Ratio02 = 0;
|
|
protected double Ratio03 = 0;
|
|
|
|
#endregion Protected Fields
|
|
|
|
#region Protected Properties
|
|
|
|
protected bool BatchIsAncestor
|
|
{
|
|
get
|
|
{
|
|
return ComLib.BType(BatchId) == BatchType.Ancestor;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Status corrente del batch
|
|
/// </summary>
|
|
protected BatchStatus CurrBatchStatus
|
|
{
|
|
get
|
|
{
|
|
return ComLib.BStatus(BatchId);
|
|
}
|
|
}
|
|
|
|
protected double fullTime
|
|
{
|
|
get
|
|
{
|
|
double answ = 1;
|
|
if (!string.IsNullOrEmpty(hfFullTime.Value))
|
|
{
|
|
double.TryParse(hfFullTime.Value, out answ);
|
|
}
|
|
return answ;
|
|
}
|
|
set
|
|
{
|
|
hfFullTime.Value = $"{value}";
|
|
}
|
|
}
|
|
|
|
protected int numKitBatchAncestor
|
|
{
|
|
get
|
|
{
|
|
int answ = 0;
|
|
if (BatchIsAncestor)
|
|
{
|
|
DS_App.KitListDataTable tabNeVirt = ComLib.KitListByBatch(BatchId);
|
|
answ = tabNeVirt.Count();
|
|
}
|
|
return answ;
|
|
}
|
|
}
|
|
|
|
protected int numOrd01
|
|
{
|
|
get
|
|
{
|
|
int answ = 0;
|
|
DS_App.OrderListTreeDataTable tabNe01 = ComLib.OrdersExtByBatch(cmp_orderExtListNE01.BatchId);
|
|
answ = tabNe01.Count();
|
|
return answ;
|
|
}
|
|
}
|
|
|
|
protected int numOrd02
|
|
{
|
|
get
|
|
{
|
|
int answ = 0;
|
|
DS_App.OrderListTreeDataTable tabNe02 = ComLib.OrdersExtByBatch(cmp_orderExtListNE02.BatchId);
|
|
answ = tabNe02.Count();
|
|
return answ;
|
|
}
|
|
}
|
|
|
|
protected int numOrd03
|
|
{
|
|
get
|
|
{
|
|
int answ = 0;
|
|
DS_App.OrderListTreeDataTable tabNe03 = ComLib.OrdersExtByBatch(cmp_orderExtListNE03.BatchId);
|
|
answ = tabNe03.Count();
|
|
return answ;
|
|
}
|
|
}
|
|
|
|
protected int numOrdBatchAncestor
|
|
{
|
|
get
|
|
{
|
|
int answ = 0;
|
|
if (BatchIsAncestor)
|
|
{
|
|
DS_App.OrderListTreeDataTable tabNeVirt = ComLib.OrdersExtByBatch(BatchId);
|
|
answ = tabNeVirt.Count();
|
|
}
|
|
return answ;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Tabella dei batch Descendant di quello corrente
|
|
/// </summary>
|
|
protected DS_App.BatchListDataTable TabBatchDesc
|
|
{
|
|
get
|
|
{
|
|
return ComLib.BatchDescendant(BatchId);
|
|
}
|
|
}
|
|
|
|
protected DS_App.OrderListTreeDataTable TabOrders
|
|
{
|
|
get
|
|
{
|
|
// cerco in redis
|
|
return ComLib.OrdersExtByBatchTree(BatchId);
|
|
}
|
|
}
|
|
|
|
protected double totTime01
|
|
{
|
|
get
|
|
{
|
|
double answ = 0;
|
|
DS_App.OrderListTreeDataTable tabNe01 = ComLib.OrdersExtByBatch(cmp_orderExtListNE01.BatchId);
|
|
answ = tabNe01.Sum(x => x.EstProcTime);
|
|
return answ;
|
|
}
|
|
}
|
|
|
|
protected double totTime02
|
|
{
|
|
get
|
|
{
|
|
double answ = 0;
|
|
DS_App.OrderListTreeDataTable tabNe02 = ComLib.OrdersExtByBatch(cmp_orderExtListNE02.BatchId);
|
|
answ = tabNe02.Sum(x => x.EstProcTime);
|
|
return answ;
|
|
}
|
|
}
|
|
|
|
protected double totTime03
|
|
{
|
|
get
|
|
{
|
|
double answ = 0;
|
|
DS_App.OrderListTreeDataTable tabNe03 = ComLib.OrdersExtByBatch(cmp_orderExtListNE03.BatchId);
|
|
answ = tabNe03.Sum(x => x.EstProcTime);
|
|
return answ;
|
|
}
|
|
}
|
|
|
|
#endregion Protected Properties
|
|
|
|
#region Protected Methods
|
|
|
|
/// <summary>
|
|
/// Cerca il set con lo score migliore calcolando x subset della lista ordinata
|
|
/// </summary>
|
|
/// <param name="OrderedList">Lista ordinata oggetti (INT) + valore</param>
|
|
/// <param name="TargetVal">Valore desiderato (come SOMMA)</param>
|
|
/// <param name="maxDepth">Massima profondità ricorsione accettata (x evitare loop infinito)</param>
|
|
/// <returns></returns>
|
|
protected Dictionary<int, double> findLocalMin(Dictionary<int, double> OrderedList, double TargetVal, int maxDepth)
|
|
{
|
|
Dictionary<int, double> answ = new Dictionary<int, double>();
|
|
List<OrderSetSim> Candidates = new List<OrderSetSim>();
|
|
OrderSetSim CurrSimSet = new OrderSetSim();
|
|
// parte dal valore (singolo) più piccolo tra quelli maggiori del target... se c'è...
|
|
var OrdSup = OrderedList.Where(x => x.Value > TargetVal).OrderBy(x => x.Value);
|
|
if (OrdSup != null && OrdSup.Any())
|
|
{
|
|
var currOrder = OrdSup.FirstOrDefault();
|
|
CurrSimSet = new OrderSetSim();
|
|
CurrSimSet.TargetValue = TargetVal;
|
|
CurrSimSet.OrderSet.Add(currOrder.Key, currOrder.Value);
|
|
Candidates.Add(CurrSimSet);
|
|
}
|
|
// ora guardo gli elementi restanti.. se ci sono
|
|
var OrdInf = OrderedList.Where(x => x.Value <= TargetVal).OrderByDescending(x => x.Value).ToDictionary(t => t.Key, t => t.Value);
|
|
if (OrdInf != null && OrdInf.Any())
|
|
{
|
|
var currOrder = OrdInf.FirstOrDefault();
|
|
CurrSimSet = new OrderSetSim();
|
|
CurrSimSet.TargetValue = TargetVal;
|
|
CurrSimSet.OrderSet.Add(currOrder.Key, currOrder.Value);
|
|
Candidates.Add(CurrSimSet);
|
|
|
|
// prendo i restanti tranne il primo
|
|
OrdInf.Remove(currOrder.Key);
|
|
|
|
// guardo i successivi che NON superano + corrente...
|
|
Dictionary<int, double> TestOrderSetMinDelta = findStepMin(OrdInf, TargetVal - currOrder.Value);
|
|
TestOrderSetMinDelta.Add(currOrder.Key, currOrder.Value);
|
|
// verifico se migliorativo...
|
|
if (TestOrderSetMinDelta.Count > 0)
|
|
{
|
|
OrderSetSim CurrSet = new OrderSetSim();
|
|
CurrSet.TargetValue = TargetVal;// - currOrder.Value;
|
|
CurrSet.OrderSet = TestOrderSetMinDelta;
|
|
Candidates.Add(CurrSet);
|
|
}
|
|
|
|
// solo successivi che non superano
|
|
Dictionary<int, double> TestOrderSetMin = findStepMin(OrdInf, TargetVal);
|
|
// verifico se migliorativo...
|
|
if (TestOrderSetMin.Count > 0)
|
|
{
|
|
OrderSetSim CurrSet = new OrderSetSim();
|
|
CurrSet.TargetValue = TargetVal;// - currOrder.Value;
|
|
CurrSet.OrderSet = TestOrderSetMin;
|
|
Candidates.Add(CurrSet);
|
|
}
|
|
|
|
// se posso fare ricorsioni
|
|
if (maxDepth > 0)
|
|
{
|
|
maxDepth--;
|
|
|
|
// se rimane qualcosa...
|
|
if (OrdInf != null && OrdInf.Any())
|
|
{
|
|
// calcolo il minimo locale nei 2 casi, da soli
|
|
Dictionary<int, double> TestOrderSet01 = findLocalMin(OrdInf, TargetVal, maxDepth);
|
|
if (TestOrderSet01.Count > 0)
|
|
{
|
|
OrderSetSim CurrSet = new OrderSetSim();
|
|
CurrSet.TargetValue = TargetVal;
|
|
CurrSet.OrderSet = TestOrderSet01;
|
|
Candidates.Add(CurrSet);
|
|
}
|
|
// ...e con il primo valore...
|
|
Dictionary<int, double> TestOrderSet02 = findLocalMin(OrdInf, TargetVal - currOrder.Value, maxDepth);
|
|
TestOrderSet02.Add(currOrder.Key, currOrder.Value);
|
|
// verifico se migliorativo...
|
|
if (TestOrderSet02.Count > 0)
|
|
{
|
|
OrderSetSim CurrSet = new OrderSetSim();
|
|
CurrSet.TargetValue = TargetVal - currOrder.Value;
|
|
CurrSet.OrderSet = TestOrderSet02;
|
|
Candidates.Add(CurrSet);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
// cerco il minimo...
|
|
if (Candidates != null && Candidates.Count > 0)
|
|
{
|
|
answ = Candidates.OrderBy(x => x.IndexScore).FirstOrDefault().OrderSet;
|
|
}
|
|
// calcolo il minimo e lo restituisco...
|
|
return answ;
|
|
}
|
|
|
|
/// <summary> Cerca il set della lista ordinata <= target val </summary> <param
|
|
/// name="OrderedList">Lista ordinata oggetti (INT) + valore</param> <param
|
|
/// name="TargetVal">Valore desiderato (come SOMMA)</param> <returns></returns>
|
|
protected Dictionary<int, double> findStepMin(Dictionary<int, double> OrderedList, double TargetVal)
|
|
{
|
|
double CurrVal = 0;
|
|
Dictionary<int, double> answ = new Dictionary<int, double>();
|
|
foreach (var item in OrderedList)
|
|
{
|
|
if (item.Value <= (TargetVal - CurrVal))
|
|
{
|
|
CurrVal += item.Value;
|
|
answ.Add(item.Key, item.Value);
|
|
}
|
|
}
|
|
// restituisco set minore...
|
|
return answ;
|
|
}
|
|
|
|
protected void lbtBalance_Click(object sender, EventArgs e)
|
|
{
|
|
divError.Visible = false;
|
|
codEnabledPrev = codEnabled;
|
|
lblWarnChange.Visible = enabIsChanged;
|
|
// imposto la % secondo numero di abilitati...
|
|
Ratio01 = enable01 ? (double)(100 / numEnabled) / 100 : 0;
|
|
Ratio02 = enable02 ? (double)(100 / numEnabled) / 100 : 0;
|
|
Ratio03 = enable03 ? (double)(100 / numEnabled) / 100 : 0;
|
|
Log.Instance.Info($"Rebalance requested (click) | numEnabled: {numEnabled} | R01: {Ratio01:P1} | R02: {Ratio02:P1} | R03: {Ratio03:P1}");
|
|
bool fatto = RebalanceOrder();
|
|
|
|
// 2024.12.13 eseguo riassegnazione kit a macchine come OLT...
|
|
if (BatchIsAncestor)
|
|
{
|
|
// effettuo VERA ri-assegnazione ordini/kit a nuovi batch
|
|
DLMan.taOLT.setBatchSplit(BatchId, true);
|
|
}
|
|
|
|
// svuoto cache redis per i calcoli...
|
|
ComLib.OrdersExtResetCache();
|
|
|
|
doUpdate(true);
|
|
lbtBalance.Focus();
|
|
string message = fatto ? "Balance done" : "Balance task error!";
|
|
Log.Instance.Info(message);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Sposta l'ordine + piccolo dalla macchina selezionata dal command argument nell'altra attiva
|
|
/// </summary>
|
|
/// <param name="sender"></param>
|
|
/// <param name="e"></param>
|
|
protected void lbtOrdAdd_Click(object sender, EventArgs e)
|
|
{
|
|
string CodMac = ((LinkButton)sender).CommandArgument;
|
|
moveOrderByCodMac(CodMac, true);
|
|
codEnabledPrev = codEnabled;
|
|
lblWarnChange.Visible = enabIsChanged;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Sposta TUTTI gli ordini nalla macchina selezionata nell'altra attiva
|
|
/// </summary>
|
|
/// <param name="sender"></param>
|
|
/// <param name="e"></param>
|
|
protected void lbtOrdAddAll_Click(object sender, EventArgs e)
|
|
{
|
|
string CodMac = ((LinkButton)sender).CommandArgument;
|
|
moveAllOrderFromMac(CodMac, true);
|
|
codEnabledPrev = codEnabled;
|
|
lblWarnChange.Visible = enabIsChanged;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Sposta l'ordine + piccolo dalla macchina selezionata dal command argument nell'altra attiva
|
|
/// </summary>
|
|
/// <param name="sender"></param>
|
|
/// <param name="e"></param>
|
|
protected void lbtOrdRem_Click(object sender, EventArgs e)
|
|
{
|
|
string CodMac = ((LinkButton)sender).CommandArgument;
|
|
moveOrderByCodMac(CodMac, false);
|
|
codEnabledPrev = codEnabled;
|
|
lblWarnChange.Visible = enabIsChanged;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Sposta TUTTI gli ordini dalla macchina selezionata nell'altra attiva
|
|
/// </summary>
|
|
/// <param name="sender"></param>
|
|
/// <param name="e"></param>
|
|
protected void lbtOrdRemAll_Click(object sender, EventArgs e)
|
|
{
|
|
string CodMac = ((LinkButton)sender).CommandArgument;
|
|
moveAllOrderFromMac(CodMac, false);
|
|
codEnabledPrev = codEnabled;
|
|
lblWarnChange.Visible = enabIsChanged;
|
|
}
|
|
|
|
protected void lbtToggle01_Click(object sender, EventArgs e)
|
|
{
|
|
// controllo che ce ne sia ALMENO un altro attivo
|
|
if (enable01 && numEnabled > 1 || !enable01)
|
|
{
|
|
enable01 = !enable01;
|
|
checkDisplayMode();
|
|
fixEnabled();
|
|
}
|
|
lbtToggle01.Focus();
|
|
}
|
|
|
|
protected void lbtToggle02_Click(object sender, EventArgs e)
|
|
{
|
|
// controllo che ce ne sia ALMENO un altro attivo
|
|
if (enable02 && numEnabled > 1 || !enable02)
|
|
{
|
|
enable02 = !enable02;
|
|
checkDisplayMode();
|
|
fixEnabled();
|
|
}
|
|
lbtToggle02.Focus();
|
|
}
|
|
|
|
protected void lbtToggle03_Click(object sender, EventArgs e)
|
|
{
|
|
// controllo che ce ne sia ALMENO un altro attivo
|
|
if (enable03 && numEnabled > 1 || !enable03)
|
|
{
|
|
enable03 = !enable03;
|
|
checkDisplayMode();
|
|
fixEnabled();
|
|
}
|
|
lbtToggle03.Focus();
|
|
}
|
|
|
|
protected void Page_Load(object sender, EventArgs e)
|
|
{
|
|
if (!Page.IsPostBack)
|
|
{
|
|
// verifica visualizzazione
|
|
toggleAll(true);
|
|
codEnabledPrev = codEnabled;
|
|
fixChildBatch();
|
|
fixRatio();
|
|
checkDisplayMode();
|
|
fixEnabled();
|
|
divError.Visible = false;
|
|
// 2024.12.13: controllo che NON ci siano ordini o kit sul batch ancestor
|
|
lblSplitRequest.Visible = (numKitBatchAncestor + numOrdBatchAncestor) > 0;
|
|
}
|
|
cmp_orderExtListNE01.eh_doRefresh += Cmp_orderExtListNE01_eh_doRefresh;
|
|
cmp_orderExtListNE02.eh_doRefresh += Cmp_orderExtListNE02_eh_doRefresh;
|
|
cmp_orderExtListNE03.eh_doRefresh += Cmp_orderExtListNE03_eh_doRefresh;
|
|
}
|
|
|
|
#endregion Protected Methods
|
|
|
|
#region Private Properties
|
|
|
|
private int codEnabled
|
|
{
|
|
get
|
|
{
|
|
int answ = 0;
|
|
answ += enable01 ? 100 : 0;
|
|
answ += enable02 ? 10 : 0;
|
|
answ += enable03 ? 1 : 0;
|
|
return answ;
|
|
}
|
|
}
|
|
|
|
private int codEnabledPrev
|
|
{
|
|
get
|
|
{
|
|
int answ = 0;
|
|
int.TryParse(hfCodEnabPrev.Value, out answ);
|
|
return answ;
|
|
}
|
|
set
|
|
{
|
|
hfCodEnabPrev.Value = $"{value}";
|
|
}
|
|
}
|
|
|
|
private bool enable01
|
|
{
|
|
get
|
|
{
|
|
bool answ = true;
|
|
bool.TryParse(hfEnabled01.Value, out answ);
|
|
return answ;
|
|
}
|
|
set
|
|
{
|
|
hfEnabled01.Value = $"{value}";
|
|
}
|
|
}
|
|
|
|
private bool enable02
|
|
{
|
|
get
|
|
{
|
|
bool answ = false;
|
|
bool.TryParse(hfEnabled02.Value, out answ);
|
|
return answ;
|
|
}
|
|
set
|
|
{
|
|
hfEnabled02.Value = $"{value}";
|
|
}
|
|
}
|
|
|
|
private bool enable03
|
|
{
|
|
get
|
|
{
|
|
bool answ = false;
|
|
bool.TryParse(hfEnabled03.Value, out answ);
|
|
return answ;
|
|
}
|
|
set
|
|
{
|
|
hfEnabled03.Value = $"{value}";
|
|
}
|
|
}
|
|
|
|
private bool movEnabled
|
|
{
|
|
get
|
|
{
|
|
return numEnabled == 2;
|
|
}
|
|
}
|
|
|
|
private int numEnabled
|
|
{
|
|
get
|
|
{
|
|
int answ = 0;
|
|
answ += enable01 ? 1 : 0;
|
|
answ += enable02 ? 1 : 0;
|
|
answ += enable03 ? 1 : 0;
|
|
return answ;
|
|
}
|
|
}
|
|
|
|
#endregion Private Properties
|
|
|
|
#region Private Methods
|
|
|
|
private void checkCreateDescendant()
|
|
{
|
|
// se ho un batchId...
|
|
if (BatchId != 0)
|
|
{
|
|
// verifico se ho descendant
|
|
if (TabBatchDesc.Rows.Count == 0)
|
|
{
|
|
// altrimenti creo...
|
|
DLMan.taBL.makeDescendantByKey(BatchId, PlaceCod);
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// verifico modalità display (editing solo se PRIMA di lanciare nesting...)
|
|
/// </summary>
|
|
private void checkDisplayMode()
|
|
{
|
|
var splitEnab = BtnEnabled && (BatchIsAncestor && CurrBatchStatus <= BatchStatus.EstimationDone && numEnabled > 0);
|
|
// se non suddiviso --> indico rosso!
|
|
double tmpTime = totTime01 + totTime02 + totTime03;
|
|
string baseCssClass = "btn btn-success btn-block";
|
|
if (tmpTime < 0.1)
|
|
{
|
|
// imposto colore btn ROSSO...
|
|
baseCssClass = "btn btn-danger btn-block";
|
|
isSplitted = false;
|
|
}
|
|
else
|
|
{
|
|
isSplitted = true;
|
|
}
|
|
lbtBalance.CssClass = splitEnab ? baseCssClass : baseCssClass + " disabled";
|
|
cmp_orderExtListNE01.Visible = splitEnab;
|
|
cmp_orderExtListNE02.Visible = splitEnab;
|
|
cmp_orderExtListNE03.Visible = splitEnab;
|
|
cmp_batchDetailSplitInfoNE01.Visible = !splitEnab;
|
|
cmp_batchDetailSplitInfoNE02.Visible = !splitEnab;
|
|
cmp_batchDetailSplitInfoNE03.Visible = !splitEnab;
|
|
// controlo il batch sia ancestor e NON abbia ordini associati...
|
|
if (BatchIsAncestor)
|
|
{
|
|
// 2024.12.13: controllo che NON ci siano ordini o kit sul batch ancestor
|
|
bool hasErrors = (numKitBatchAncestor + numOrdBatchAncestor) > 0;
|
|
lblSplitRequest.Visible = hasErrors;
|
|
if (hasErrors)
|
|
{
|
|
lbtBalance.CssClass = "btn btn-danger btn-block";
|
|
isSplitted = false;
|
|
}
|
|
}
|
|
}
|
|
|
|
private void Cmp_orderExtListNE01_eh_doRefresh(object sender, EventArgs e)
|
|
{
|
|
// sposto ordine in altro set, calcolandolo
|
|
int batchId = enable02 ? cmp_orderExtListNE02.BatchId : cmp_orderExtListNE03.BatchId;
|
|
int origBatchId = cmp_orderExtListNE01.BatchId;
|
|
int origOrdId = cmp_orderExtListNE01.SelOrderId;
|
|
moveOrderById(batchId, origBatchId, origOrdId);
|
|
}
|
|
|
|
private void Cmp_orderExtListNE02_eh_doRefresh(object sender, EventArgs e)
|
|
{
|
|
// sposto ordine in altro set, calcolandolo
|
|
int batchId = enable01 ? cmp_orderExtListNE01.BatchId : cmp_orderExtListNE03.BatchId;
|
|
int origBatchId = cmp_orderExtListNE02.BatchId;
|
|
int origOrdId = cmp_orderExtListNE02.SelOrderId;
|
|
moveOrderById(batchId, origBatchId, origOrdId);
|
|
}
|
|
|
|
private void Cmp_orderExtListNE03_eh_doRefresh(object sender, EventArgs e)
|
|
{
|
|
// sposto ordine in altro set, calcolandolo
|
|
int batchId = enable01 ? cmp_orderExtListNE01.BatchId : cmp_orderExtListNE02.BatchId;
|
|
int origBatchId = cmp_orderExtListNE03.BatchId;
|
|
int origOrdId = cmp_orderExtListNE03.SelOrderId;
|
|
moveOrderById(batchId, origBatchId, origOrdId);
|
|
}
|
|
|
|
private void fixChildBatch()
|
|
{
|
|
// sistemo dati ordini
|
|
DS_App.BatchListDataTable TabBatch = TabBatchDesc;
|
|
if (TabBatch != null && TabBatch.Count > 0)
|
|
{
|
|
cmp_orderExtListNE01.BatchId = TabBatch.Rows.Count > 0 ? TabBatch[0].BatchID : 0;
|
|
cmp_orderExtListNE02.BatchId = TabBatch.Rows.Count > 1 ? TabBatch[1].BatchID : 0;
|
|
cmp_orderExtListNE03.BatchId = TabBatch.Rows.Count > 2 ? TabBatch[2].BatchID : 0;
|
|
cmp_orderExtListNE01.doUpdate();
|
|
cmp_orderExtListNE02.doUpdate();
|
|
cmp_orderExtListNE03.doUpdate();
|
|
try
|
|
{
|
|
cmp_batchDetailSplitInfoNE01.BatchId = cmp_orderExtListNE01.BatchId;
|
|
cmp_batchDetailSplitInfoNE02.BatchId = cmp_orderExtListNE02.BatchId;
|
|
cmp_batchDetailSplitInfoNE03.BatchId = cmp_orderExtListNE03.BatchId;
|
|
}
|
|
catch (Exception exc)
|
|
{
|
|
Log.Instance.Error($"Error during fixChildBatch{Environment.NewLine}{exc}");
|
|
}
|
|
}
|
|
}
|
|
|
|
private void fixEnabled()
|
|
{
|
|
lbtToggle01.Enabled = BtnEnabled;
|
|
lbtToggle02.Enabled = BtnEnabled;
|
|
lbtToggle03.Enabled = BtnEnabled;
|
|
lblWarnChange.Visible = enabIsChanged;
|
|
string secCss = BtnEnabled ? "btn btn-sm btn-secondary" : "btn btn-sm btn-secondary disabled";
|
|
lbtToggle01.CssClass = BtnEnabled && enable01 ? "btn btn-sm btn-primary" : secCss;
|
|
lbtToggle02.CssClass = BtnEnabled && enable02 ? "btn btn-sm btn-primary" : secCss;
|
|
lbtToggle03.CssClass = BtnEnabled && enable03 ? "btn btn-sm btn-primary" : secCss;
|
|
lbtOrdAdd01.CssClass = BtnEnabled && movEnabled && enable01 ? "btn btn-success px-3" : "btn btn-secondary px-3 disabled";
|
|
lbtOrdAdd02.CssClass = BtnEnabled && movEnabled && enable02 ? "btn btn-success px-3" : "btn btn-secondary px-3 disabled";
|
|
lbtOrdAdd03.CssClass = BtnEnabled && movEnabled && enable03 ? "btn btn-success px-3" : "btn btn-secondary px-3 disabled";
|
|
lbtOrdRem01.CssClass = BtnEnabled && movEnabled && enable01 ? "btn btn-danger px-3" : "btn btn-secondary px-3 disabled";
|
|
lbtOrdRem02.CssClass = BtnEnabled && movEnabled && enable02 ? "btn btn-danger px-3" : "btn btn-secondary px-3 disabled";
|
|
lbtOrdRem03.CssClass = BtnEnabled && movEnabled && enable03 ? "btn btn-danger px-3" : "btn btn-secondary px-3 disabled";
|
|
lbtOrdRemAll01.CssClass = BtnEnabled && movEnabled && enable01 ? "btn btn-primary" : "btn btn-secondary disabled";
|
|
lbtOrdRemAll02.CssClass = BtnEnabled && movEnabled && enable02 ? "btn btn-primary" : "btn btn-secondary disabled";
|
|
lbtOrdRemAll03.CssClass = BtnEnabled && movEnabled && enable03 ? "btn btn-primary" : "btn btn-secondary disabled";
|
|
lbtOrdAddAll01.CssClass = BtnEnabled && movEnabled && enable01 ? "btn btn-primary" : "btn btn-secondary disabled";
|
|
lbtOrdAddAll02.CssClass = BtnEnabled && movEnabled && enable02 ? "btn btn-primary" : "btn btn-secondary disabled";
|
|
lbtOrdAddAll03.CssClass = BtnEnabled && movEnabled && enable03 ? "btn btn-primary" : "btn btn-secondary disabled";
|
|
cmp_orderExtListNE01.enableMove = BtnEnabled && enable01 && movEnabled;
|
|
cmp_orderExtListNE02.enableMove = BtnEnabled && enable02 && movEnabled;
|
|
cmp_orderExtListNE03.enableMove = BtnEnabled && enable03 && movEnabled;
|
|
divHeadNe01.Attributes.Remove("class");
|
|
divHeadNe02.Attributes.Remove("class");
|
|
divHeadNe03.Attributes.Remove("class");
|
|
divHeadNe01.Attributes.Add("class", BtnEnabled && enable01 ? "card-header bg-dark text-light py-1" : "card-header py-1");
|
|
divHeadNe02.Attributes.Add("class", BtnEnabled && enable02 ? "card-header bg-dark text-light py-1" : "card-header py-1");
|
|
divHeadNe03.Attributes.Add("class", BtnEnabled && enable03 ? "card-header bg-dark text-light py-1" : "card-header py-1");
|
|
}
|
|
|
|
private void fixRatio()
|
|
{
|
|
// calcolo tempi....
|
|
double tmpTime = totTime01 + totTime02 + totTime03;
|
|
fullTime = tmpTime > 0 ? tmpTime : 1;
|
|
// sistemazione ratio calcolate...
|
|
Ratio01 = totTime01 / fullTime;
|
|
Ratio02 = totTime02 / fullTime;
|
|
// ratio 3 è complemento a 100...
|
|
Ratio03 = 1 - (Ratio01 + Ratio02);
|
|
// sistemo etichette...
|
|
lblTime01.Text = $"{totTime01:N1} min";
|
|
lblTime02.Text = $"{totTime02:N1} min";
|
|
lblTime03.Text = $"{totTime03:N1} min";
|
|
lblNumOrd01.Text = $"#{numOrd01} ord";
|
|
lblNumOrd02.Text = $"#{numOrd02} ord";
|
|
lblNumOrd03.Text = $"#{numOrd03} ord";
|
|
// sistemo campi testo...
|
|
lblRat01.Text = $"{Ratio01:P1}";
|
|
lblRat02.Text = $"{Ratio02:P1}";
|
|
lblRat03.Text = $"{Ratio03:P1}";
|
|
}
|
|
|
|
/// <summary>
|
|
/// Spostamento di tutti gli ordini tra batch
|
|
/// </summary>
|
|
/// <param name="CodMac">Cod macchina selezionata x azione (orig)</param>
|
|
/// <param name="addOrd">True = aggiunge a macchina selezionata, false = toglie</param>
|
|
private void moveAllOrderFromMac(string CodMac, bool addOrd)
|
|
{
|
|
int batchOrigId = 0;
|
|
int batchDestId = 0;
|
|
DS_App.OrderListTreeRow ord2move = null;
|
|
// recupero ordini della macchina
|
|
switch (CodMac)
|
|
{
|
|
case "NE01":
|
|
batchOrigId = cmp_orderExtListNE01.BatchId;
|
|
batchDestId = enable02 ? cmp_orderExtListNE02.BatchId : cmp_orderExtListNE03.BatchId;
|
|
break;
|
|
|
|
case "NE02":
|
|
batchOrigId = cmp_orderExtListNE02.BatchId;
|
|
batchDestId = enable01 ? cmp_orderExtListNE01.BatchId : cmp_orderExtListNE03.BatchId;
|
|
break;
|
|
|
|
case "NE03":
|
|
batchOrigId = cmp_orderExtListNE03.BatchId;
|
|
batchDestId = enable01 ? cmp_orderExtListNE01.BatchId : cmp_orderExtListNE02.BatchId;
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
if (batchOrigId > 0)
|
|
{
|
|
DS_App.OrderListTreeDataTable tabOLT = new DS_App.OrderListTreeDataTable();
|
|
// prendo ordine in base ad add/remove...
|
|
if (addOrd)
|
|
{
|
|
tabOLT = ComLib.OrdersExtByBatch(batchDestId);
|
|
}
|
|
else
|
|
{
|
|
// recupero la tab da cui partire in base ad add/remove...
|
|
tabOLT = ComLib.OrdersExtByBatch(batchOrigId);
|
|
}
|
|
// ciclo x tutti gli ordini
|
|
foreach (var ordine in tabOLT)
|
|
{
|
|
// sposto!
|
|
if (addOrd)
|
|
{
|
|
DLMan.taOLT.updateBatch(batchDestId, ordine.OrdID, batchOrigId);
|
|
}
|
|
else
|
|
{
|
|
DLMan.taOLT.updateBatch(batchOrigId, ordine.OrdID, batchDestId);
|
|
}
|
|
}
|
|
// 2024.12.13 eseguo riassegnazione kit a macchine come OLT...
|
|
if (BatchIsAncestor)
|
|
{
|
|
// effettuo VERA ri-assegnazione ordini/kit a nuovi batch
|
|
DLMan.taOLT.setBatchSplit(BatchId, true);
|
|
}
|
|
// resetto batch ordini...
|
|
ComLib.OrdersExtResetCache();
|
|
// ricalcolo
|
|
fixChildBatch();
|
|
fixRatio();
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Spostamento ordine tra batch
|
|
/// </summary>
|
|
/// <param name="CodMac">Cod macchina selezionata x azione (orig)</param>
|
|
/// <param name="addOrd">True = aggiunge a macchina selezionata, false = toglie</param>
|
|
private void moveOrderByCodMac(string CodMac, bool addOrd)
|
|
{
|
|
int batchOrigId = 0;
|
|
int batchDestId = 0;
|
|
int ordId = 0;
|
|
DS_App.OrderListTreeRow ord2move = null;
|
|
// recupero ordini della macchina
|
|
switch (CodMac)
|
|
{
|
|
case "NE01":
|
|
batchOrigId = cmp_orderExtListNE01.BatchId;
|
|
batchDestId = enable02 ? cmp_orderExtListNE02.BatchId : cmp_orderExtListNE03.BatchId;
|
|
break;
|
|
|
|
case "NE02":
|
|
batchOrigId = cmp_orderExtListNE02.BatchId;
|
|
batchDestId = enable01 ? cmp_orderExtListNE01.BatchId : cmp_orderExtListNE03.BatchId;
|
|
break;
|
|
|
|
case "NE03":
|
|
batchOrigId = cmp_orderExtListNE03.BatchId;
|
|
batchDestId = enable01 ? cmp_orderExtListNE01.BatchId : cmp_orderExtListNE02.BatchId;
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
if (batchOrigId > 0)
|
|
{
|
|
DS_App.OrderListTreeDataTable tabOLT = new DS_App.OrderListTreeDataTable();
|
|
// prendo ordine in base ad add/remove...
|
|
if (addOrd)
|
|
{
|
|
tabOLT = ComLib.OrdersExtByBatch(batchDestId);
|
|
}
|
|
else
|
|
{
|
|
// recupero la tab da cui partire in base ad add/remove...
|
|
tabOLT = ComLib.OrdersExtByBatch(batchOrigId);
|
|
}
|
|
ord2move = tabOLT.OrderBy(x => x.EstProcTime).FirstOrDefault();
|
|
if (ord2move != null)
|
|
{
|
|
ordId = ord2move.OrdID;
|
|
}
|
|
// sposto!
|
|
if (addOrd)
|
|
{
|
|
DLMan.taOLT.updateBatch(batchDestId, ordId, batchOrigId);
|
|
}
|
|
else
|
|
{
|
|
DLMan.taOLT.updateBatch(batchOrigId, ordId, batchDestId);
|
|
}
|
|
// 2024.12.13 eseguo riassegnazione kit a macchine come OLT...
|
|
if (BatchIsAncestor)
|
|
{
|
|
// effettuo VERA ri-assegnazione ordini/kit a nuovi batch
|
|
DLMan.taOLT.setBatchSplit(BatchId, true);
|
|
}
|
|
codEnabledPrev = codEnabled;
|
|
lblWarnChange.Visible = enabIsChanged;
|
|
// resetto batch ordini...
|
|
ComLib.OrdersExtResetCache();
|
|
// ricalcolo
|
|
fixChildBatch();
|
|
fixRatio();
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Effettua spostamento ordine passando ID specifici batch src, ordine, batch dest...
|
|
/// </summary>
|
|
/// <param name="batchId"></param>
|
|
/// <param name="origBatchId"></param>
|
|
/// <param name="origOrdId"></param>
|
|
private void moveOrderById(int batchId, int origBatchId, int origOrdId)
|
|
{
|
|
DLMan.taOLT.updateBatch(origBatchId, origOrdId, batchId);
|
|
// 2024.12.13 eseguo riassegnazione kit a macchine come OLT...
|
|
if (BatchIsAncestor)
|
|
{
|
|
// effettuo VERA ri-assegnazione ordini/kit a nuovi batch
|
|
DLMan.taOLT.setBatchSplit(BatchId, true);
|
|
}
|
|
codEnabledPrev = codEnabled;
|
|
lblWarnChange.Visible = enabIsChanged;
|
|
// resetto batch ordini...
|
|
ComLib.OrdersExtResetCache();
|
|
fixChildBatch();
|
|
fixRatio();
|
|
}
|
|
|
|
/// <summary>
|
|
/// effettua ribilanciamento ordini partendo da elenco completo e poi assegnando a impianti
|
|
/// </summary>
|
|
private bool RebalanceOrder()
|
|
{
|
|
// imposto variabili x calcoli...
|
|
bool answ = false;
|
|
bool directAssign = false;
|
|
int maxDepth = memLayer.ML.CRI("maxDepthRebalance");
|
|
OrderSetSim FullSet = new OrderSetSim();
|
|
OrderSetSim StartSet = new OrderSetSim();
|
|
OrderSetSim SetNe01 = new OrderSetSim();
|
|
OrderSetSim SetNe02 = new OrderSetSim();
|
|
OrderSetSim SetNe03 = new OrderSetSim();
|
|
// creo liste x i valori da processare...
|
|
Dictionary<int, double> RawList = new Dictionary<int, double>();
|
|
Dictionary<int, double> OrderedList = new Dictionary<int, double>();
|
|
// avvio cronometro
|
|
Log.Instance.Trace("Rebalance | S01");
|
|
Stopwatch stopWatch = new Stopwatch();
|
|
stopWatch.Start();
|
|
// copio la tabella...
|
|
List<DS_App.OrderListTreeRow> listOrders = new List<DS_App.OrderListTreeRow>();
|
|
foreach (var item in TabOrders)
|
|
{
|
|
listOrders.Add(item);
|
|
}
|
|
foreach (var item in TabOrders)
|
|
{
|
|
RawList.Add(item.OrdID, item.EstProcTime);
|
|
}
|
|
int numOrdOrig = listOrders.Count;
|
|
Log.Instance.Trace($"Rebalance | S02 | listOrders.count: {numOrdOrig}");
|
|
// ordino la lista x processing successivo
|
|
OrderedList = RawList.OrderBy(x => x.Value).ToDictionary(t => t.Key, t => t.Value);
|
|
// inizio immaginando di usare TUTTI gli ordini
|
|
FullSet.OrderSet = OrderedList;
|
|
// calcolo i valori target iniziali
|
|
SetNe01.TargetValue = enable01 ? FullSet.ActualValue * Ratio01 : 0;
|
|
SetNe02.TargetValue = enable02 ? FullSet.ActualValue * Ratio02 : 0;
|
|
SetNe03.TargetValue = enable03 ? FullSet.ActualValue * Ratio03 : 0;
|
|
Log.Instance.Trace($"Rebalance | S03 | T01: {SetNe01.TargetValue} | T02: {SetNe02.TargetValue} | T03: {SetNe03.TargetValue}");
|
|
// salvo i set su cui lavorare, SE ho + ordini che macchine prendo i + lunghi x assegnaz. deterministica
|
|
int num2proc = numEnabled;
|
|
Log.Instance.Trace($"Rebalance | S04 | numEnabled: {numEnabled}");
|
|
if (OrderedList.Count > num2proc)
|
|
{
|
|
directAssign = true;
|
|
StartSet.OrderSet = OrderedList.OrderByDescending(x => x.Value).Take(num2proc).ToDictionary(t => t.Key, t => t.Value);
|
|
// tolgo ordini lunghi tra quelli da processare
|
|
foreach (var ordTaken in StartSet.OrderSet)
|
|
{
|
|
OrderedList.Remove(ordTaken.Key);
|
|
}
|
|
//OrderedList = OrderedList.OrderBy(x => x.Value).Take(OrderedList.Count - num2proc).ToDictionary(t => t.Key, t => t.Value);
|
|
// imposto nuovi target secondo sia abilitato
|
|
int idx = 0;
|
|
SetNe01.TargetValue -= enable01 ? StartSet.OrderSet.Skip(idx++).FirstOrDefault().Value : 0;
|
|
SetNe02.TargetValue -= enable02 ? StartSet.OrderSet.Skip(idx++).FirstOrDefault().Value : 0;
|
|
SetNe03.TargetValue -= enable03 ? StartSet.OrderSet.Skip(idx++).FirstOrDefault().Value : 0;
|
|
Log.Instance.Trace($"Rebalance | S05a | Target after direct assign | T01: {SetNe01.TargetValue} | T02: {SetNe02.TargetValue} | T03: {SetNe03.TargetValue}");
|
|
}
|
|
else
|
|
{
|
|
Log.Instance.Trace($"Rebalance | S05b | no direct assign | OrderedList.Count: {OrderedList.Count} | num2proc: {num2proc}");
|
|
}
|
|
|
|
// ciclo x riempire il + primo...SE manca ...
|
|
if (SetNe01.TargetValue > 0)
|
|
{
|
|
SetNe01.OrderSet = findLocalMin(OrderedList, SetNe01.TargetValue, maxDepth);
|
|
Log.Instance.Trace($"Rebalance | S06 | NE01 partial | SetNe01.ActualValue: {SetNe01.ActualValue}");
|
|
}
|
|
// calcolo il restante per differenza...
|
|
var ordRemain = OrderedList;
|
|
foreach (var item in SetNe01.OrderSet)
|
|
{
|
|
ordRemain.Remove(item.Key);
|
|
}
|
|
if (SetNe02.TargetValue > 0)
|
|
{
|
|
SetNe02.OrderSet = findLocalMin(ordRemain, SetNe02.TargetValue, maxDepth);
|
|
Log.Instance.Trace($"Rebalance | S07 | NE02 partial | SetNe02.ActualValue: {SetNe02.ActualValue}");
|
|
}
|
|
// l'ultimo è la differenza
|
|
if (SetNe03.TargetValue > 0)
|
|
{
|
|
SetNe03.OrderSet = ordRemain;
|
|
foreach (var item in SetNe02.OrderSet)
|
|
{
|
|
SetNe03.OrderSet.Remove(item.Key);
|
|
}
|
|
Log.Instance.Trace($"Rebalance | S08 | NE03 partial | SetNe03.ActualValue: {SetNe03.ActualValue}");
|
|
}
|
|
else
|
|
{
|
|
// riporto ai precedenti
|
|
if (enable02)
|
|
{
|
|
foreach (var item in ordRemain)
|
|
{
|
|
if (!SetNe02.OrderSet.ContainsKey(item.Key))
|
|
{
|
|
SetNe02.OrderSet.Add(item.Key, item.Value);
|
|
}
|
|
}
|
|
Log.Instance.Trace($"Rebalance | S09 | NE02 done | SetNe02.ActualValue: {SetNe02.ActualValue}");
|
|
}
|
|
else if (enable01)
|
|
{
|
|
foreach (var item in ordRemain)
|
|
{
|
|
if (!SetNe01.OrderSet.ContainsKey(item.Key))
|
|
{
|
|
SetNe01.OrderSet.Add(item.Key, item.Value);
|
|
}
|
|
}
|
|
Log.Instance.Trace($"Rebalance | S10 | NE01 done | SetNe01.ActualValue: {SetNe01.ActualValue}");
|
|
}
|
|
}
|
|
// se directAssign --> reinserisco i 3 ordini grandi
|
|
try
|
|
{
|
|
if (directAssign)
|
|
{
|
|
int idx = 0;
|
|
if (enable01)
|
|
{
|
|
var firstOrder01 = StartSet.OrderSet.Skip(idx++).FirstOrDefault();
|
|
SetNe01.OrderSet.Add(firstOrder01.Key, firstOrder01.Value);
|
|
Log.Instance.Trace($"Rebalance | S11 | NE01 done | SetNe01.ActualValue: {SetNe01.ActualValue} | SetNe01.OrderSet.Count: {SetNe01.OrderSet.Count}");
|
|
}
|
|
else
|
|
{
|
|
Log.Instance.Trace("enable01 == false");
|
|
}
|
|
if (enable02)
|
|
{
|
|
var firstOrder02 = StartSet.OrderSet.Skip(idx++).FirstOrDefault();
|
|
SetNe02.OrderSet.Add(firstOrder02.Key, firstOrder02.Value);
|
|
Log.Instance.Trace($"Rebalance | S12 | NE02 done | SetNe02.ActualValue: {SetNe02.ActualValue} | SetNe02.OrderSet.Count: {SetNe02.OrderSet.Count}");
|
|
}
|
|
else
|
|
{
|
|
Log.Instance.Trace("enable02 == false");
|
|
}
|
|
if (enable03)
|
|
{
|
|
var firstOrder03 = StartSet.OrderSet.Skip(idx++).FirstOrDefault();
|
|
SetNe03.OrderSet.Add(firstOrder03.Key, firstOrder03.Value);
|
|
Log.Instance.Trace($"Rebalance | S13 | NE03 done | SetNe03.ActualValue: {SetNe03.ActualValue} | SetNe03.OrderSet.Count: {SetNe03.OrderSet.Count}");
|
|
}
|
|
else
|
|
{
|
|
Log.Instance.Trace("enable03 == false");
|
|
}
|
|
}
|
|
}
|
|
catch (Exception exc)
|
|
{
|
|
Log.Instance.Error($"Exception durante rebalance 01:{Environment.NewLine}{exc}");
|
|
}
|
|
|
|
// 2024.09.20: controllo che il numero ordini torni o LO SEGNALO come errore...
|
|
int numAssigned = SetNe01.OrderSet.Count + SetNe02.OrderSet.Count + SetNe03.OrderSet.Count;
|
|
if (numAssigned != numOrdOrig)
|
|
{
|
|
divError.Visible = true;
|
|
Log.Instance.Error($"Error during rebalance | numOrdOrig: {numOrdOrig} | numAssigned: {numAssigned}");
|
|
lblError.Text = traduci("ERR_Rebalance01");
|
|
lblErrorDetail.Text = $"{traduci("ERR_Rebalance02")} | # Orig: {numOrdOrig} | # Assigned: {numAssigned}";
|
|
}
|
|
else
|
|
{
|
|
divError.Visible = false;
|
|
// check sul num di spostamenti1
|
|
int numMove = 0;
|
|
int numOk = 0;
|
|
Log.Instance.Trace("Rebalance | Starting final stage (DB modifications)");
|
|
try
|
|
{
|
|
// riorganizzo tabOrders...
|
|
foreach (var orderItem in TabOrders)
|
|
{
|
|
if (SetNe01.OrderSet.ContainsKey(orderItem.OrdID))
|
|
{
|
|
if (orderItem.BatchID != cmp_orderExtListNE01.BatchId)
|
|
{
|
|
DLMan.taOLT.updateBatch(orderItem.BatchID, orderItem.OrdID, cmp_orderExtListNE01.BatchId);
|
|
numMove++;
|
|
}
|
|
else
|
|
{
|
|
numOk++;
|
|
}
|
|
}
|
|
if (SetNe02.OrderSet.ContainsKey(orderItem.OrdID))
|
|
{
|
|
if (orderItem.BatchID != cmp_orderExtListNE02.BatchId)
|
|
{
|
|
DLMan.taOLT.updateBatch(orderItem.BatchID, orderItem.OrdID, cmp_orderExtListNE02.BatchId);
|
|
numMove++;
|
|
}
|
|
else
|
|
{
|
|
numOk++;
|
|
}
|
|
}
|
|
if (SetNe03.OrderSet.ContainsKey(orderItem.OrdID))
|
|
{
|
|
if (orderItem.BatchID != cmp_orderExtListNE03.BatchId)
|
|
{
|
|
DLMan.taOLT.updateBatch(orderItem.BatchID, orderItem.OrdID, cmp_orderExtListNE03.BatchId);
|
|
numMove++;
|
|
}
|
|
else
|
|
{
|
|
numOk++;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
catch (Exception exc)
|
|
{
|
|
Log.Instance.Error($"Exception durante rebalance 02:{Environment.NewLine}{exc}");
|
|
}
|
|
answ = listOrders.Count > 0;
|
|
Log.Instance.Trace($"Final check | S14 | answ: {answ} | listOrders.Count: {listOrders.Count} | numMove: {numMove} | numOk: {numOk}");
|
|
// salvo tempo calcolo
|
|
stopWatch.Stop();
|
|
var elapsTime = stopWatch.Elapsed;
|
|
Log.Instance.Info($"Rebalance executed | R01: {Ratio01:P1}/{SetNe01.ActualValue / FullSet.ActualValue:P1} | R02: {Ratio02:P1}/{SetNe02.ActualValue / FullSet.ActualValue:P1} | R03: {Ratio03:P1}/{SetNe03.ActualValue / FullSet.ActualValue:P1} | maxDepth: {maxDepth} | elapsed ms: {elapsTime.TotalMilliseconds:N1}");
|
|
// resetto batch ordini...
|
|
ComLib.OrdersExtResetCache();
|
|
}
|
|
cmp_orderExtListNE01.doUpdate();
|
|
cmp_orderExtListNE02.doUpdate();
|
|
cmp_orderExtListNE03.doUpdate();
|
|
return answ;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Toggle generale pulsanti
|
|
/// </summary>
|
|
/// <param name="enable"></param>
|
|
private void toggleAll(bool enable)
|
|
{
|
|
// solo in caso di true...
|
|
if (enable)
|
|
{
|
|
enable01 = enable;
|
|
enable02 = enable;
|
|
enable03 = enable;
|
|
}
|
|
}
|
|
|
|
#endregion Private Methods
|
|
}
|
|
} |