Samuele E. Locatelli
1209 lines
38 KiB
C#
1209 lines
38 KiB
C#
using MapoDb;
|
|
using MapoSDK;
|
|
using SteamWare;
|
|
using System;
|
|
using System.Text;
|
|
using System.Web.UI;
|
|
using System.Web.UI.WebControls;
|
|
|
|
namespace MoonProTablet.WebUserControls
|
|
{
|
|
public partial class mod_ODL : System.Web.UI.UserControl
|
|
{
|
|
/// <summary>
|
|
/// registrato nuovo valore
|
|
/// </summary>
|
|
public event EventHandler eh_reqUpdate;
|
|
/// <summary>
|
|
/// Valore protected idxODL
|
|
/// </summary>
|
|
protected string _idxOdlMacc;
|
|
/// <summary>
|
|
/// Valore protected idxODL
|
|
/// </summary>
|
|
protected string _idxOdlAltraMacc;
|
|
/// <summary>
|
|
/// IdxODL sulla macchina
|
|
/// </summary>
|
|
public string idxOdlMacc
|
|
{
|
|
get
|
|
{
|
|
if (_idxOdlMacc == null)
|
|
{
|
|
_idxOdlMacc = DataLayer.currODL(idxMacchina, true);
|
|
}
|
|
return _idxOdlMacc;
|
|
}
|
|
set
|
|
{
|
|
_idxOdlMacc = value;
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// IdxODL su ALTRA macchina (se multi)
|
|
/// </summary>
|
|
public string idxOdlAltraMacc
|
|
{
|
|
get
|
|
{
|
|
if (_idxOdlAltraMacc == null)
|
|
{
|
|
_idxOdlAltraMacc = DataLayer.currODL(idxMaccAltraTav, true);
|
|
}
|
|
return _idxOdlAltraMacc;
|
|
}
|
|
set
|
|
{
|
|
_idxOdlAltraMacc = value;
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// Verifica se la macchina sia MULTI
|
|
/// </summary>
|
|
public bool isMulti
|
|
{
|
|
get
|
|
{
|
|
return DataLayer.isMulti(idxMacchina);
|
|
}
|
|
}
|
|
|
|
public bool maccInAttr
|
|
{
|
|
get
|
|
{
|
|
bool answ = false;
|
|
// controllo se la macchina è in attrezzaggio...
|
|
DS_applicazione.StatoMacchineRow rigaStato = null;
|
|
try
|
|
{
|
|
// se è multi controllo parent...
|
|
if (isMulti)
|
|
{
|
|
rigaStato = selData.mng.rigaStato(idxMaccParent);
|
|
}
|
|
else
|
|
{
|
|
rigaStato = selData.mng.rigaStato(idxMacchina);
|
|
}
|
|
answ = (rigaStato.IdxStato == 2);
|
|
}
|
|
catch (Exception exc)
|
|
{
|
|
logger.lg.scriviLog(string.Format("Eccezione in recupero dati rigaStato! {0}{1}", Environment.NewLine, exc), tipoLog.EXCEPTION);
|
|
}
|
|
return answ;
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// Verifica se la macchina NON abbia ODL (valido, > 0)
|
|
/// </summary>
|
|
public bool emptyOdlMacc
|
|
{
|
|
get
|
|
{
|
|
return (idxOdlMacc == "" || idxOdlMacc == "0");
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// Verifica se la macchina NON abbia ODL (valido, > 0)
|
|
/// </summary>
|
|
public bool emptyOdlAltraMacc
|
|
{
|
|
get
|
|
{
|
|
return (idxOdlAltraMacc == "" || idxOdlAltraMacc == "0");
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// Verifica visibilità btn split ODL su 2° tavola SE:
|
|
/// - sia un impianto MULTI (= con + tavole)
|
|
/// - sia già attrezzata la prima tavola
|
|
/// - in tab Congif: se sia abilitato lo split ODL sulla seconda tavola
|
|
/// - la macchina SIA ANCORA in attrezzaggio (2019.07.08) = 2
|
|
/// </summary>
|
|
protected bool showSplitOdlOnTavVal
|
|
{
|
|
get
|
|
{
|
|
bool answ = false;
|
|
// se è multi controllo
|
|
if (isMulti)
|
|
{
|
|
// verifico se NON HA ODL ma ce l'ha altra tavola...
|
|
if (emptyOdlMacc)
|
|
{
|
|
// ora verifico SE ALTRA TAVOLA ha ODL...
|
|
if (!emptyOdlAltraMacc)
|
|
{
|
|
// ora verifico SE E SOLO SE è ANCORA in attrezzaggio
|
|
if (maccInAttr)
|
|
{
|
|
answ = memLayer.ML.cdvb("showSplitOdlOnTav");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return answ;
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// Verifica visibilità btn riprendi ODL su 2° tavola SE:
|
|
/// - sia un impianto MULTI (= con + tavole)
|
|
/// - sia disattrezzata la tavola
|
|
/// - in tab congif: se sia abilitato la ripresa ODL sulla seconda tavola
|
|
/// - in tab config: sia il grace period
|
|
/// - NON SIANO passati i minuti indicati dalla chiusura
|
|
/// </summary>
|
|
protected bool showReopOdlTav
|
|
{
|
|
get
|
|
{
|
|
bool answ = false;
|
|
// se è multi controllo
|
|
if (isMulti)
|
|
{
|
|
// verifico se NON HA ODL...
|
|
if (emptyOdlMacc)
|
|
{
|
|
// verifico SE siamo nel gracePeriod
|
|
int gPeriod = memLayer.ML.cdvi("gPeriodReopenOdlTav");
|
|
DateTime adesso = DateTime.Now;
|
|
DateTime dtChiusura = DateTime.Now.AddHours(-1);
|
|
try
|
|
{
|
|
dtChiusura = DataLayer.obj.taODL.getLastByMacc(idxMacchina)[0].DataFine;
|
|
}
|
|
catch
|
|
{ }
|
|
|
|
// ora verifico SE E SOLO SE è ANCORA in attrezzaggio
|
|
if (maccInAttr)
|
|
{
|
|
// ora verifico SE ALTRA TAVOLA ha ODL...
|
|
if (dtChiusura.AddMinutes(gPeriod) > adesso)
|
|
{
|
|
answ = memLayer.ML.cdvb("showReopenOdlTav");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return answ;
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// Verifica se la tavola SIA in fase di attrezzaggio, ovvero SE:
|
|
/// - sia un impianto MULTI (= con + tavole)
|
|
/// - sia già attrezzata
|
|
/// </summary>
|
|
protected bool tavHasOdl
|
|
{
|
|
get
|
|
{
|
|
bool answ = false;
|
|
// se è multi controllo
|
|
if (isMulti)
|
|
{
|
|
answ = !emptyOdlMacc;
|
|
}
|
|
return answ;
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// Restituisce il codice IdxMacchina dell'altra tavola (se multi) altrimenti la stessa macchina...
|
|
/// </summary>
|
|
protected string idxMaccAltraTav
|
|
{
|
|
get
|
|
{
|
|
string answ = "";
|
|
try
|
|
{
|
|
// verifico se SIA una tavola (ha char "#")
|
|
int iSharp = idxMacchina.IndexOf('#');
|
|
if (iSharp > 0)
|
|
{
|
|
// ora verifico SE ALTRA TAVOLA ha ODL...
|
|
string nomeTav = idxMacchina.Substring(iSharp);
|
|
string altraTav = nomeTav.Substring(0, nomeTav.Length - 1);
|
|
altraTav += nomeTav.EndsWith("1") ? "2" : "1";
|
|
// sistemo nome
|
|
answ = idxMacchina.Replace(nomeTav, altraTav);
|
|
}
|
|
}
|
|
catch
|
|
{ }
|
|
return answ;
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// Restituisce il codice IdxMacchina dell'impianto PARENT (se multi) altrimenti la stessa macchina...
|
|
/// </summary>
|
|
protected string idxMaccParent
|
|
{
|
|
get
|
|
{
|
|
string answ = "";
|
|
// se è multi controllo
|
|
if (isMulti)
|
|
{
|
|
// verifico se SIA una tavola (ha char "#")
|
|
int iSharp = idxMacchina.IndexOf('#');
|
|
if (iSharp > 0)
|
|
{
|
|
// sistemo nome
|
|
answ = idxMacchina.Substring(0, iSharp);
|
|
}
|
|
}
|
|
return answ;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Verifica chiave chkCloseOdl in tab Config
|
|
/// </summary>
|
|
protected bool chkCloseOdlVal
|
|
{
|
|
get
|
|
{
|
|
return memLayer.ML.cdvb("chkCloseOdl");
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// Verifica chiave showChkCloseOdl in tab Config
|
|
/// </summary>
|
|
protected bool showChkCloseOdlVal
|
|
{
|
|
get
|
|
{
|
|
return memLayer.ML.cdvb("showChkCloseOdl");
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// Verifica chiave showOdlProvv in tab Config
|
|
/// </summary>
|
|
protected bool showOdlProvvVal
|
|
{
|
|
get
|
|
{
|
|
return memLayer.ML.cdvb("showOdlProvv");
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// stringa UID univoca
|
|
/// </summary>
|
|
public string uid
|
|
{
|
|
get
|
|
{
|
|
return this.UniqueID.Replace("$", "_").Replace("-", "_");
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// idx macchina selezionata
|
|
/// </summary>
|
|
public string idxMacchina
|
|
{
|
|
get
|
|
{
|
|
string answ = "";
|
|
try
|
|
{
|
|
answ = memLayer.ML.StringSessionObj(string.Format("idxMacchina-{0}", uid));
|
|
}
|
|
catch
|
|
{ }
|
|
return answ;
|
|
}
|
|
set
|
|
{
|
|
memLayer.ML.setSessionVal(string.Format("idxMacchina-{0}", uid), value);
|
|
hfIdxMacchina.Value = value;
|
|
cmp_newODL.idxMacchina = value;
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// classe MapoDB x uso locale
|
|
/// </summary>
|
|
protected MapoDb.MapoDb controllerMapo = new MapoDb.MapoDb();
|
|
/// <summary>
|
|
/// Determina se sia abilitato il controllo x editing
|
|
/// </summary>
|
|
public bool isEnabled
|
|
{
|
|
get
|
|
{
|
|
bool answ = false;
|
|
try
|
|
{
|
|
answ = memLayer.ML.BoolSessionObj(string.Format("isEnabled-{0}", uid));
|
|
}
|
|
catch
|
|
{ }
|
|
return answ;
|
|
}
|
|
set
|
|
{
|
|
memLayer.ML.setSessionVal(string.Format("isEnabled-{0}", uid), value);
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// codice odl selezionato
|
|
/// </summary>
|
|
public int idxODLSel
|
|
{
|
|
get
|
|
{
|
|
int answ = 0;
|
|
try
|
|
{
|
|
answ = Convert.ToInt32(ddlODL.SelectedValue);
|
|
}
|
|
catch
|
|
{ }
|
|
return answ;
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// Cod articolo dell'ODL selezionato
|
|
/// </summary>
|
|
public string CodArtSel
|
|
{
|
|
get
|
|
{
|
|
string CodArticolo = "";
|
|
try
|
|
{
|
|
CodArticolo = DataLayer.obj.taODL.getByIdx(idxODLSel, false)[0].CodArticolo;
|
|
}
|
|
catch
|
|
{ }
|
|
return CodArticolo;
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// avvio pagina
|
|
/// </summary>
|
|
/// <param name="sender"></param>
|
|
/// <param name="e"></param>
|
|
protected void Page_Load(object sender, EventArgs e)
|
|
{
|
|
if (!Page.IsPostBack)
|
|
{
|
|
// fix modo tempo...
|
|
if (memLayer.ML.cdvb("TAB_TC_MinSec"))
|
|
{
|
|
mod_tempoMSMC.modoTempo = timeMode.MS;
|
|
}
|
|
else
|
|
{
|
|
mod_tempoMSMC.modoTempo = timeMode.MC;
|
|
}
|
|
}
|
|
cmp_newODL.eh_newVal += Cmp_newODL_eh_newVal;
|
|
}
|
|
/// <summary>
|
|
/// Verifica (su tab config) se sia abilitata la gestione flusso RPO (Richieste - Promesse - ODL)
|
|
/// </summary>
|
|
protected bool enableRPO
|
|
{
|
|
get
|
|
{
|
|
return memLayer.ML.cdvb("enableRPO");
|
|
}
|
|
}
|
|
|
|
private void Cmp_newODL_eh_newVal(object sender, EventArgs e)
|
|
{
|
|
// creato nuovo ODL, faccio refresh ricaricando pagina!
|
|
Response.Redirect("~/ODL");
|
|
}
|
|
|
|
public void hideAll()
|
|
{
|
|
divDettOdl.Visible = false;
|
|
}
|
|
|
|
public void checkAll()
|
|
{
|
|
lblOut.Text = "";
|
|
checkBtnStatus();
|
|
chkCloseOdl.Checked = chkCloseOdlVal;
|
|
chkCloseOdl.Visible = showChkCloseOdlVal;
|
|
divOdlProvv.Visible = showOdlProvvVal;
|
|
divOpRiattr.Visible = (showSplitOdlOnTavVal || showReopOdlTav);
|
|
lbtSplitOdlSuTav.Visible = showSplitOdlOnTavVal;
|
|
lbtReopOdlSuTav.Visible = showReopOdlTav;
|
|
lbtFixEndSetup.Visible = !maccInAttr && memLayer.ML.CRB("OptEnableFixSetup");
|
|
}
|
|
/// <summary>
|
|
/// Sistema CSS x status enabled/disabled
|
|
/// </summary>
|
|
/// <param name="lbtn"></param>
|
|
protected void fixWCtrStatus(object lbtn)
|
|
{
|
|
// tolgo (eventuale) classe
|
|
try
|
|
{
|
|
((WebControl)lbtn).CssClass = ((WebControl)lbtn).CssClass.Replace("disabled", "");
|
|
// se richiesto metto disabled...
|
|
if (!((WebControl)lbtn).Enabled)
|
|
{
|
|
((WebControl)lbtn).CssClass += " disabled";
|
|
}
|
|
}
|
|
catch
|
|
{ }
|
|
}
|
|
|
|
/// <summary>
|
|
/// controlla stato bottoni abilitato
|
|
/// </summary>
|
|
private void checkBtnStatus()
|
|
{
|
|
// di default rendo abilitato / disabilitato tutto in base al valore "isEnabled"
|
|
lbtShowSplitODL.Enabled = isEnabled;
|
|
lbtSplitODL.Enabled = isEnabled;
|
|
chkCloseOdl.Enabled = isEnabled;
|
|
fixWCtrStatus(lbtShowSplitODL);
|
|
fixWCtrStatus(lbtSplitODL);
|
|
fixWCtrStatus(chkCloseOdl);
|
|
|
|
// condizioni booleane
|
|
bool inAttr = false;
|
|
bool currHasOdl = false;
|
|
// controllo se la macchina è in attrezzaggio...
|
|
DS_applicazione.StatoMacchineRow rigaStato = null;
|
|
try
|
|
{
|
|
// se è multi controllo parent...
|
|
if (isMulti)
|
|
{
|
|
rigaStato = selData.mng.rigaStato(idxMaccParent);
|
|
inAttr = (rigaStato.IdxStato == 2 && tavHasOdl);
|
|
}
|
|
else
|
|
{
|
|
rigaStato = selData.mng.rigaStato(idxMacchina);
|
|
inAttr = (rigaStato.IdxStato == 2);
|
|
}
|
|
}
|
|
catch (Exception exc)
|
|
{
|
|
logger.lg.scriviLog(string.Format("Eccezione in recupero dati rigaStato! {0}{1}", Environment.NewLine, exc), tipoLog.EXCEPTION);
|
|
}
|
|
try
|
|
{
|
|
currHasOdl = DataLayer.obj.taODL.getByMacchina(idxMacchina)[0].IdxODL != 0;
|
|
}
|
|
catch (Exception exc)
|
|
{
|
|
logger.lg.scriviLog(string.Format("Eccezione in recupero dati currHasOdl! {0}{1}", Environment.NewLine, exc), tipoLog.EXCEPTION);
|
|
}
|
|
// deve controllare abbia ODL o PROMESSE odl...
|
|
bool hasNewOdl = DataLayer.obj.taSelOdlFree.getUnused(idxMacchina, chkTutti.Checked).Rows.Count > 1;
|
|
// sistemo buttons!
|
|
lbtStartAttr.Enabled = (isEnabled && (!inAttr && hasNewOdl));
|
|
lbtStartProd.Enabled = (isEnabled && inAttr);
|
|
lbtEndProd.Enabled = (isEnabled && (!inAttr && currHasOdl));
|
|
ddlODL.Enabled = (isEnabled && (!inAttr && hasNewOdl));
|
|
odsODL.DataBind();
|
|
// sistemo anche come css..
|
|
fixWCtrStatus(lbtStartAttr);
|
|
fixWCtrStatus(lbtStartProd);
|
|
fixWCtrStatus(lbtEndProd);
|
|
fixWCtrStatus(ddlODL);
|
|
// sistemo show tempo/note attrezzaggio..
|
|
if (inAttr)
|
|
{
|
|
showNoteTC(true);
|
|
int idxOdl = 0;
|
|
try
|
|
{
|
|
idxOdl = DataLayer.obj.taODL.getByMacchina(idxMacchina)[0].IdxODL;
|
|
updateTempoTc(idxOdl, inAttr);
|
|
updateNoteTC(idxOdl);
|
|
}
|
|
catch (Exception exc)
|
|
{
|
|
logger.lg.scriviLog(string.Format("Eccezione in recupero dati ODL! {0}{1}", Environment.NewLine, exc), tipoLog.EXCEPTION);
|
|
}
|
|
}
|
|
|
|
// verifico se l'articolo corrente sia in revisione x mostrare conferma modifica revisione...
|
|
if (CodArtSel != "")
|
|
{
|
|
bool showWarn = false;
|
|
try
|
|
{
|
|
showWarn = DataLayer.obj.taAnagArt.getByCod(CodArtSel)[0].FlagIsNew;
|
|
}
|
|
catch (Exception exc)
|
|
{
|
|
logger.lg.scriviLog(string.Format("Eccezione in recupero dati showWarn! {0}{1}", Environment.NewLine, exc), tipoLog.EXCEPTION);
|
|
}
|
|
divWarningArt.Visible = showWarn;
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// processa evento richiesto
|
|
/// </summary>
|
|
/// <param name="idxMaccCurr"></param>
|
|
/// <param name="idxEvento"></param>
|
|
/// <param name="userMsg"></param>
|
|
/// <param name="idxODL"></param>
|
|
private void processaEvento(string idxMaccCurr, int idxEvento, string userMsg, int idxODL)
|
|
{
|
|
MapoDb.inputComando inCmd;
|
|
MapoDb.inputComando inCmd2;
|
|
DS_applicazione.StatoMacchineRow rigaStato = selData.mng.rigaStato(idxMaccCurr);
|
|
// ricavo codice articolo...
|
|
string CodArticolo = DataLayer.obj.taODL.getByIdx(idxODL, false)[0].CodArticolo;
|
|
// processo evento...
|
|
inCmd = controllerMapo.scriviRigaEventoBarcode(idxMaccCurr, idxEvento, CodArticolo, "", DataLayer.MatrOpr, rigaStato.pallet);
|
|
// se la macchina è MULTI (cod#tavola) e sonoa INIZIO/FINE attrezzaggio (idxEv <=2) oppure FINE PROD processo ANCHE per la macchina madre...
|
|
if (idxMaccCurr.IndexOf('#') > 0 && (idxEvento <= 2 || idxEvento == 7))
|
|
{
|
|
inCmd2 = controllerMapo.scriviRigaEventoBarcode(idxMaccParent, idxEvento, CodArticolo, "", DataLayer.MatrOpr, rigaStato.pallet);
|
|
}
|
|
// chiamo refresh MSE
|
|
DataLayer.obj.taMSE.forceRecalc(0, idxMaccCurr);
|
|
// invalido la cache di selData
|
|
selData.mng.invalidateCache();
|
|
lblOut.Text = userMsg;
|
|
// loggo USR MSG
|
|
logger.lg.scriviLog(userMsg, tipoLog.INFO);
|
|
checkBtnStatus();
|
|
}
|
|
/// <summary>
|
|
/// valore decimal del TC richiesto...
|
|
/// </summary>
|
|
protected decimal TCRichAttr
|
|
{
|
|
get
|
|
{
|
|
decimal answ = 0;
|
|
try
|
|
{
|
|
answ = mod_tempoMSMC.tempoMC;
|
|
}
|
|
catch
|
|
{ }
|
|
return answ;
|
|
}
|
|
set
|
|
{
|
|
mod_tempoMSMC.tempoMC = value;
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// valore INT di num Pz per Pallet...
|
|
/// </summary>
|
|
protected int PzPallet
|
|
{
|
|
get
|
|
{
|
|
int answ = 0;
|
|
try
|
|
{
|
|
answ = cmp_selPzPallet.pzPallet;
|
|
}
|
|
catch
|
|
{ }
|
|
return answ;
|
|
}
|
|
set
|
|
{
|
|
cmp_selPzPallet.pzPallet = value;
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// valore decimal del TC ASSEGNATO...
|
|
/// </summary>
|
|
protected decimal TCAssegnato(int idxODL)
|
|
{
|
|
decimal answ = 0;
|
|
try
|
|
{
|
|
if (enableRPO)
|
|
{
|
|
// leggo info da promessa...
|
|
var rigaProm = DataLayer.obj.taPODL.getByKey(idxODL)[0];
|
|
answ = rigaProm.TCAssegnato;
|
|
}
|
|
else
|
|
{
|
|
// leggo idxOdl da ultimo odl attivo x macchina
|
|
DS_ProdTempi.ODLRow rigaOdl = DataLayer.obj.taODL.getByIdx(idxODL, false)[0];
|
|
answ = rigaOdl.TCAssegnato;
|
|
}
|
|
}
|
|
catch
|
|
{ }
|
|
return answ;
|
|
}
|
|
/// <summary>
|
|
/// dichiara inizio attrezzaggio ODL indicato..
|
|
/// </summary>
|
|
/// <param name="sender"></param>
|
|
/// <param name="e"></param>
|
|
protected void lbtStartAttr_Click(object sender, EventArgs e)
|
|
{
|
|
/***************************************************
|
|
* * DA VALUTARE (x macchine tipo linea con + impianti... es valvital) SE
|
|
* - creare una gestione ALTERNATIVA sul server che preveda impianto LEADER e impianti follower (RIGIDAMENTE CONFIGURATI)
|
|
* - ogni volta che si fa setup LEADER --> si ripete su impianti FOLLOWER (eventi!!!)
|
|
* - viene fatto reset contapezzi sui follower (+ altre operazioni opzionali, ES imposstazione nome commessa, quantità, articolo...)
|
|
* - viene fatto reset + nuovo ODL (con stessi articoli e quantità) su follower, SENZA avere gestione x ODL di un codice esterno (quindi registra TUTTO ma NON RITORNERA' dati on avendo link verso esterno)
|
|
* - serve NUOVA TABELLA delle macchine LEADER | FOLLOWER (1:n) e gestione da MP/IO
|
|
*
|
|
***************************************************/
|
|
|
|
bool inAttr = false;
|
|
// se è multi mi chiedo se sia DAVVERO in attrezzaggio...
|
|
if (isMulti)
|
|
{
|
|
try
|
|
{
|
|
// controllo se NON SONO già in attrezzaggio...
|
|
DS_applicazione.StatoMacchineRow rigaStato = selData.mng.rigaStato(idxMaccParent);
|
|
inAttr = (rigaStato.IdxStato == 2);
|
|
}
|
|
catch
|
|
{ }
|
|
}
|
|
// proseguo
|
|
int idxODL_curr = 0;
|
|
confermaProdOdl(false);
|
|
if (idxODLSel > 0)
|
|
{
|
|
// se vedesse TCRich a zero lo reimposta a quello assegnato...
|
|
if (TCRichAttr == 0)
|
|
{
|
|
TCRichAttr = TCAssegnato(idxODLSel);
|
|
}
|
|
int idxODL = 0;
|
|
if (memLayer.ML.CRB("enableSplitODL"))
|
|
{
|
|
// splitto VECCHIO ODL (se è rimasto qualcosa da produrre e se ce ne è rimasto uno.......)
|
|
try
|
|
{
|
|
idxODL = DataLayer.obj.taODL.getByMacchina(idxMacchina)[0].IdxODL;
|
|
DataLayer.obj.taODL.splitODL(idxODL, DataLayer.MatrOpr, idxMacchina, TCAssegnato(idxODL), PzPallet, string.Format("inizio attrezzaggio, Sospensione ODL {0}, generato residuo con pari TCiclo: {1}", idxODL, TCAssegnato(idxODL)), false);
|
|
// se è multi processo ANCHE x altra tavola...
|
|
if (isMulti)
|
|
{
|
|
int _idxOdl = DataLayer.obj.taODL.getByMacchina(idxMaccAltraTav)[0].IdxODL;
|
|
DataLayer.obj.taODL.splitODL(_idxOdl, DataLayer.MatrOpr, idxMaccAltraTav, TCAssegnato(_idxOdl), PzPallet, string.Format("inizio attrezzaggio, Sospensione ODL {0}, generato residuo con pari TCiclo: {1}", _idxOdl, TCAssegnato(_idxOdl)), false);
|
|
}
|
|
}
|
|
catch
|
|
{ }
|
|
}
|
|
// 2018.07.24 verifico se devo lavorare come ODL classico o come RPO (Richiesta / Promessa / ODL)
|
|
if (enableRPO)
|
|
{
|
|
// creo nuovo ODL da promessa ed associo
|
|
DataLayer.obj.taODL.inizioSetupPromessa(idxODLSel, DataLayer.MatrOpr, idxMacchina, TCRichAttr, PzPallet, txtNote.Text);
|
|
// salvo ODL attrezzato
|
|
idxODL_curr = DataLayer.obj.taODL.getByMacchina(idxMacchina)[0].IdxODL;
|
|
}
|
|
// ODL classico
|
|
else
|
|
{
|
|
// avvio NUOVO ODL
|
|
DataLayer.obj.taODL.inizioSetup(idxODLSel, DataLayer.MatrOpr, idxMacchina, TCRichAttr, PzPallet, txtNote.Text);
|
|
// salvo ODL Current
|
|
idxODL_curr = idxODLSel;
|
|
}
|
|
// process evento
|
|
int idxEvento = 2; // !!!HARD CODED
|
|
string evText = "Registrato inizio attrezzaggio per ODL {0}";
|
|
StringBuilder sb = new StringBuilder();
|
|
sb.AppendLine(String.Format(evText, idxODL_curr));
|
|
processaEvento(idxMacchina, idxEvento, sb.ToString(), idxODL_curr);
|
|
// indico INIZIO SETUP su REDIS come EXE della macchina...
|
|
string ts = string.Format("{0:yyMMdd}T{0:HHmmss.fff}Z", DateTime.Now);
|
|
DataLayer.addTask4Machine(idxMacchina, taskType.startSetup, $"TS:{ts}|MATR:{DataLayer.MatrOpr}|ODL:{idxODL_curr}");
|
|
// se è multi CHIUDO ODL x altra tavola...
|
|
if (isMulti)
|
|
{
|
|
// se NON sono in attrezzaggio...
|
|
if (!inAttr)
|
|
{
|
|
int idxOdlAltra = 0;
|
|
try
|
|
{
|
|
var tabOdl = DataLayer.obj.taODL.getByMacchina(idxMaccAltraTav);
|
|
if (tabOdl.Rows.Count > 0)
|
|
{
|
|
idxOdlAltra = DataLayer.obj.taODL.getByMacchina(idxMaccAltraTav)[0].IdxODL;
|
|
}
|
|
}
|
|
catch (Exception exc)
|
|
{
|
|
logger.lg.scriviLog("Durante recupero idxOdlAltra " + exc.ToString(), tipoLog.EXCEPTION);
|
|
}
|
|
// procedo se ho ODL
|
|
if (idxOdlAltra > 0)
|
|
{
|
|
sb.AppendLine("---");
|
|
DataLayer.obj.taODL.fineProd(idxOdlAltra, idxMaccAltraTav);
|
|
evText = "Registrato inizio attrezzaggio per ODL {0} (setup seconda tavola)";
|
|
sb.AppendLine(String.Format(evText, idxOdlAltra));
|
|
processaEvento(idxMaccAltraTav, idxEvento, String.Format(evText, idxOdlAltra), idxOdlAltra);
|
|
}
|
|
lblOut.Text = sb.ToString().Replace("---", "<br/>");
|
|
}
|
|
// update buttons...
|
|
checkAll();
|
|
}
|
|
// resetto contapezzi redis...
|
|
DataLayer.saveCounter(idxMacchina, "0");
|
|
// imposto ODL su redis...
|
|
DataLayer.saveCurrODL(idxMacchina, idxODL_curr.ToString());
|
|
}
|
|
else
|
|
{
|
|
lblOut.Text = "Selezionare un ORDINE valido!";
|
|
}
|
|
// sollevo evento!
|
|
if (eh_reqUpdate != null)
|
|
{
|
|
eh_reqUpdate(this, new EventArgs());
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// inizio prod
|
|
/// </summary>
|
|
/// <param name="sender"></param>
|
|
/// <param name="e"></param>
|
|
protected void lbtStartProd_Click(object sender, EventArgs e)
|
|
{
|
|
confermaProdOdl(true);
|
|
// se vedesse TCRich a zero lo reimposta a quello assegnato...
|
|
if (TCRichAttr == 0)
|
|
{
|
|
TCRichAttr = TCAssegnato(idxODLSel);
|
|
}
|
|
// leggo idxOdl da ultimo odl attivo x macchina
|
|
int idxODL = DataLayer.obj.taODL.getByMacchina(idxMacchina)[0].IdxODL;
|
|
int idxEvento = 1; // !!!HARD CODED
|
|
// aggiorno (se necessario) note e tempo setup
|
|
DataLayer.obj.taODL.updateSetup(idxODL, DataLayer.MatrOpr, TCRichAttr, PzPallet, txtNote.Text);
|
|
// controllo se TC Assegnato != TCRichiesto allora invio email x verifiche...
|
|
DS_ProdTempi.ODLRow rigaOdl = DataLayer.obj.taODL.getByIdx(idxODL, false)[0];
|
|
if (rigaOdl.TCAssegnato != TCRichAttr)
|
|
{
|
|
// invio email!
|
|
DataLayer.obj.sendWarnTcChangeReq(memLayer.ML.CRS("_adminEmail"));
|
|
}
|
|
// processo chiusura setup
|
|
string evText = "Registrata inizio produzione per ODL {0}";
|
|
StringBuilder sb = new StringBuilder();
|
|
sb.AppendLine(String.Format(evText, idxODL));
|
|
processaEvento(idxMacchina, idxEvento, sb.ToString(), idxODL);
|
|
// indico INIZIO SETUP su REDIS come EXE della macchina...
|
|
string ts = string.Format("{0:yyMMdd}T{0:HHmmss.fff}Z", DateTime.Now);
|
|
//DataLayer.addTask4Machine(idxMacchina, "stopSetup", $"TS:{ts}|MATR:{DataLayer.MatrOpr}|ODL:{idxODL}");
|
|
DataLayer.addTask4Machine(idxMacchina, taskType.stopSetup, $"TS:{ts}|MATR:{DataLayer.MatrOpr}|ODL:{idxODL}");
|
|
// se è multi processo chiusura setup x altra tavola...
|
|
if (isMulti)
|
|
{
|
|
sb.AppendLine("---");
|
|
int idxOdlAltra = DataLayer.obj.taODL.getByMacchina(idxMaccAltraTav)[0].IdxODL;
|
|
sb.AppendLine(String.Format(evText, idxOdlAltra));
|
|
processaEvento(idxMaccAltraTav, idxEvento, String.Format(evText, idxOdlAltra), idxOdlAltra);
|
|
}
|
|
// riporto stringa
|
|
lblOut.Text = sb.ToString().Replace("---", "<br/>");
|
|
// nascondo note!
|
|
showNoteTC(false);
|
|
// update buttons...
|
|
checkAll();
|
|
// sollevo evento!
|
|
if (eh_reqUpdate != null)
|
|
{
|
|
eh_reqUpdate(this, new EventArgs());
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// fine prod
|
|
/// </summary>
|
|
/// <param name="sender"></param>
|
|
/// <param name="e"></param>
|
|
protected void lbtEndProd_Click(object sender, EventArgs e)
|
|
{
|
|
// leggo idxOdl da ultimo odl attivo x macchina
|
|
int idxODL = DataLayer.obj.taODL.getByMacchina(idxMacchina)[0].IdxODL;
|
|
int idxEvento = 7; // !!!HARD CODED
|
|
|
|
// confermo prod vecchio ODL
|
|
confermaProdOdl(false);
|
|
|
|
// se chk flaggato ovvero richiesta di chiudere ODL procedo come prima (chiudendo ODL senza averne altri...)
|
|
if (chkCloseOdl.Checked)
|
|
{
|
|
// aggiungo try/catch x capire se sia qui che si "impasta" in chiusura ODL
|
|
try
|
|
{
|
|
// processo x macchina selezionata
|
|
DataLayer.obj.taODL.fineProd(idxODL, idxMacchina);
|
|
string evText = "Registrata fine produzione per ODL {0}";
|
|
StringBuilder sb = new StringBuilder();
|
|
sb.AppendLine(String.Format(evText, idxODL));
|
|
processaEvento(idxMacchina, idxEvento, sb.ToString(), idxODL);
|
|
// se è multi processo ANCHE x altra tavola...
|
|
if (isMulti)
|
|
{
|
|
sb.AppendLine("---");
|
|
int idxOdlAltra = 0;
|
|
string _idxOdl = idxOdlAltraMacc;
|
|
int.TryParse(_idxOdl, out idxOdlAltra);
|
|
DataLayer.obj.taODL.fineProd(idxOdlAltra, idxMaccAltraTav);
|
|
sb.AppendLine(String.Format(evText, idxOdlAltra));
|
|
processaEvento(idxMaccAltraTav, idxEvento, String.Format(evText, idxOdlAltra), idxOdlAltra);
|
|
}
|
|
// riporto stringa
|
|
lblOut.Text = sb.ToString().Replace("---", "<br/>");
|
|
}
|
|
catch (Exception exc)
|
|
{
|
|
logger.lg.scriviLog(string.Format("Eccezione in operazione chiusura ODL! {0}{1}", Environment.NewLine, exc), tipoLog.EXCEPTION);
|
|
Response.Redirect("~/DettaglioMacchina.aspx");
|
|
}
|
|
}
|
|
// altrimenti split ODL x completare IN FUTURO la produzione...
|
|
else
|
|
{
|
|
try
|
|
{
|
|
// effettuo split su nuovo ODL
|
|
DataLayer.obj.taODL.splitODL(idxODL, DataLayer.MatrOpr, idxMacchina, TCAssegnato(idxODL), PzPallet, string.Format("Fine Produzione, Sospensione ODL {0}, generato residuo con pari TCiclo: {1}", idxODL, TCAssegnato(idxODL)), false);
|
|
// processo chiusura setup
|
|
processaEvento(idxMacchina, idxEvento, String.Format("Registrata fine produzione per ODL {0}, nuovo ODL per quantità residua", idxODL), idxODL);
|
|
|
|
// se è multi processo ANCHE x altra tavola...
|
|
if (isMulti)
|
|
{
|
|
int idxOdlAltra = 0;
|
|
string _idxOdl = idxOdlAltraMacc;
|
|
int.TryParse(_idxOdl, out idxOdlAltra);
|
|
// effettuo split su nuovo ODL
|
|
DataLayer.obj.taODL.splitODL(idxOdlAltra, DataLayer.MatrOpr, idxMaccAltraTav, TCAssegnato(idxOdlAltra), PzPallet, string.Format("Fine Produzione, Sospensione ODL {0}, generato residuo con pari TCiclo: {1}", idxOdlAltra, TCAssegnato(idxOdlAltra)), false);
|
|
// processo chiusura setup
|
|
processaEvento(idxMaccAltraTav, idxEvento, String.Format("Registrata fine produzione per ODL {0}, nuovo ODL per quantità residua", idxOdlAltra), idxOdlAltra);
|
|
}
|
|
// sistemo buttons!
|
|
bool splitOdl = false;
|
|
fixSplitBtn(splitOdl);
|
|
}
|
|
catch (Exception exc)
|
|
{
|
|
logger.lg.scriviLog(string.Format("Eccezione in operazione Chiusura + Split ODL su nuovo! {0}{1}", Environment.NewLine, exc), tipoLog.EXCEPTION);
|
|
Response.Redirect("~/DettaglioMacchina.aspx");
|
|
}
|
|
}
|
|
// resetto ODL su redis...
|
|
DataLayer.emptyCurrODL(idxMacchina);
|
|
// aggiorno visualizzazione
|
|
checkAll();
|
|
// sollevo evento!
|
|
if (eh_reqUpdate != null)
|
|
{
|
|
eh_reqUpdate(this, new EventArgs());
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// verifica se sia necessario confermare la prod dell'ODL precedente prima di chiudere e lo fa in automatico...
|
|
/// </summary>
|
|
/// <param name="confZero">boolean, true = deve confermare 0 pezzi (es. in setup)</param>
|
|
private void confermaProdOdl(bool confZero)
|
|
{
|
|
// 2016.11.17 NOTA: introdotti scarti, li confermiamo SEMPRE a zero se in setup, però da valutare SE a FINE ATTREZZAGGIO chiedere num pezzi e num scarti (saldo zero buoni) da inserire...
|
|
if (confZero)
|
|
{
|
|
// confermo produzione ZERO pezzi (in setup)
|
|
DataLayer.obj.confermaProdMacchina(idxMacchina, memLayer.ML.CRI("modoConfProd"), 0, 0, DateTime.Now);
|
|
}
|
|
else // se NON sono in setup verifico se ho pz da confermare
|
|
{
|
|
// recupero pz da confermare
|
|
DS_ProdTempi.stp_PzProd_getByMacchinaRow rigaProd = DataLayer.obj.taPzProd2conf.GetData(idxMacchina)[0];
|
|
if (rigaProd.pezziNonConfermati > 0)
|
|
{
|
|
DataLayer.obj.confermaProdMacchina(idxMacchina, memLayer.ML.CRI("modoConfProd"), rigaProd.pezziNonConfermati, 0, DateTime.Now);
|
|
}
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// mostra dati ed opzione x split ODL
|
|
/// </summary>
|
|
/// <param name="sender"></param>
|
|
/// <param name="e"></param>
|
|
protected void lbtShowSplitODL_Click(object sender, EventArgs e)
|
|
{
|
|
bool splitOdl = true;
|
|
fixSplitBtn(splitOdl);
|
|
// recupero current idx
|
|
int currODL = DataLayer.obj.taODL.getByMacchina(idxMacchina)[0].IdxODL;
|
|
updateTempoTc(currODL, true);
|
|
updateNoteTC(currODL);
|
|
}
|
|
/// <summary>
|
|
/// sistema buttons split
|
|
/// </summary>
|
|
/// <param name="splitOdl"></param>
|
|
private void fixSplitBtn(bool splitOdl)
|
|
{
|
|
lbtShowSplitODL.Visible = !splitOdl;
|
|
chkCloseOdl.Visible = !splitOdl;
|
|
lbtSplitODL.Visible = splitOdl;
|
|
showNoteTC(splitOdl);
|
|
ddlODL.Visible = !splitOdl;
|
|
chkTutti.Visible = !splitOdl;
|
|
lbtStartAttr.Visible = !splitOdl;
|
|
lbtStartProd.Visible = !splitOdl;
|
|
lbtEndProd.Visible = !splitOdl;
|
|
}
|
|
/// <summary>
|
|
/// split ODL con creazione nuovo ODL
|
|
/// </summary>
|
|
/// <param name="sender"></param>
|
|
/// <param name="e"></param>
|
|
protected void lbtSplitODL_Click(object sender, EventArgs e)
|
|
{
|
|
// chiamo stored che genera nuovo ODL, mette note e tempo, chiude vecchi e assegna nuovo...
|
|
int currODL = DataLayer.obj.taODL.getByMacchina(idxMacchina)[0].IdxODL;
|
|
int idxEvento = 1; // !!!HARD CODED
|
|
// controllo se TC è valorizzato..
|
|
if (TCRichAttr == 0)
|
|
{
|
|
mod_tempoMSMC.checkTC();
|
|
}
|
|
|
|
// confermo prod vecchio ODL
|
|
confermaProdOdl(false);
|
|
|
|
// effettuo split su nuovo ODL
|
|
DataLayer.obj.taODL.splitODL(currODL, DataLayer.MatrOpr, idxMacchina, TCRichAttr, PzPallet, txtNote.Text, true);
|
|
|
|
// resetto ODL su redis...
|
|
DataLayer.emptyCurrODL(idxMacchina);
|
|
|
|
// invio email!
|
|
DataLayer.obj.sendWarnTcChangeReq(memLayer.ML.CRS("_adminEmail"));
|
|
// processo chiusura setup
|
|
processaEvento(idxMacchina, idxEvento, String.Format("Registrato Riattrezzaggio ODL (old: {0})", currODL), currODL);
|
|
// sistemo buttons!
|
|
bool splitOdl = false;
|
|
fixSplitBtn(splitOdl);
|
|
|
|
// sollevo evento!
|
|
if (eh_reqUpdate != null)
|
|
{
|
|
eh_reqUpdate(this, new EventArgs());
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// selezionato un ODL mostro note/tempo da validare
|
|
/// </summary>
|
|
/// <param name="sender"></param>
|
|
/// <param name="e"></param>
|
|
protected void ddlODL_SelectedIndexChanged(object sender, EventArgs e)
|
|
{
|
|
checkDDL();
|
|
}
|
|
|
|
private void checkDDL()
|
|
{
|
|
if (ddlODL.SelectedIndex > 0)
|
|
{
|
|
showNoteTC(true);
|
|
updateTempoTc(idxODLSel, false);
|
|
updateNoteTC(idxODLSel);
|
|
}
|
|
else
|
|
{
|
|
showNoteTC(false);
|
|
}
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
/// mostra/nasconde note
|
|
/// </summary>
|
|
private void showNoteTC(bool show)
|
|
{
|
|
// mostra/nasconde note da compilare
|
|
divTempo.Visible = show;
|
|
divNote.Visible = show;
|
|
divPzPallet.Visible = show;
|
|
lbtStartAttr.Visible = show;
|
|
cmp_dettODL.idxODLSel = idxODLSel;
|
|
divDettOdl.Visible = show && idxODLSel > 0;
|
|
// se abilitato da config su DB mostro selezione del numPzPallet...
|
|
cmp_selPzPallet.enableSet = memLayer.ML.CRB("enableTabSetPzPallet");
|
|
|
|
}
|
|
/// <summary>
|
|
/// aggiorna note ODL
|
|
/// </summary>
|
|
/// <param name="idxOdl"></param>
|
|
private void updateNoteTC(int idxOdl)
|
|
{
|
|
string testo = "";
|
|
if (idxOdl > 0)
|
|
{
|
|
try
|
|
{
|
|
testo = DataLayer.obj.taODL.getByIdx(idxOdl, false)[0].Note;
|
|
}
|
|
catch
|
|
{ }
|
|
}
|
|
txtNote.Text = testo;
|
|
}
|
|
|
|
/// <summary>
|
|
/// update TC mostrato
|
|
/// </summary>
|
|
/// <param name="idxOdlPodl">idx dell'ODL / PODL</param>
|
|
/// <param name="inAttr"></param>
|
|
private void updateTempoTc(int idxOdlPodl, bool inAttr)
|
|
{
|
|
// riporta TC
|
|
decimal _TCRichAttr = 0;
|
|
int pzPallet = 1;
|
|
if (enableRPO && !inAttr)
|
|
{
|
|
var rigaProm = DataLayer.obj.taPODL.getByKey(idxOdlPodl)[0];
|
|
_TCRichAttr = rigaProm.TCAssegnato;
|
|
pzPallet = rigaProm.PzPallet;
|
|
}
|
|
else
|
|
{
|
|
DS_ProdTempi.ODLRow rigaOdl = DataLayer.obj.taODL.getByIdx(idxOdlPodl, false)[0];
|
|
if (rigaOdl.TCRichAttr > 0)
|
|
{
|
|
_TCRichAttr = rigaOdl.TCRichAttr;
|
|
}
|
|
else
|
|
{
|
|
_TCRichAttr = rigaOdl.TCAssegnato;
|
|
}
|
|
pzPallet = rigaOdl.PzPallet;
|
|
}
|
|
// aggiorno dati!
|
|
TCRichAttr = _TCRichAttr;
|
|
PzPallet = pzPallet;
|
|
}
|
|
|
|
protected void lbtConfNewRevProd_Click(object sender, EventArgs e)
|
|
{
|
|
// chiamo stored x allineare revProd a revUT
|
|
string CodArticolo = DataLayer.obj.taODL.getByIdx(idxODLSel, false)[0].CodArticolo;
|
|
DataLayer.obj.taAnagArt.setNewRev(CodArticolo);
|
|
checkBtnStatus();
|
|
}
|
|
/// <summary>
|
|
/// toggle visualizzazione creazioen ODL provvisorio
|
|
/// </summary>
|
|
/// <param name="sender"></param>
|
|
/// <param name="e"></param>
|
|
protected void lbtShowCreaOdlProvv_Click(object sender, EventArgs e)
|
|
{
|
|
cmp_newODL.Visible = !cmp_newODL.Visible;
|
|
}
|
|
/// <summary>
|
|
/// Testo x button creazione nuovo ODL
|
|
/// </summary>
|
|
public string lblCreaOdl
|
|
{
|
|
get
|
|
{
|
|
string answ = "CREAZIONE ODL PROVVISORIO";
|
|
if (cmp_newODL.Visible)
|
|
{
|
|
answ = "NASCONDI creazione ODL provvisorio";
|
|
}
|
|
return answ;
|
|
}
|
|
}
|
|
|
|
protected void chkTutti_CheckedChanged(object sender, EventArgs e)
|
|
{
|
|
checkBtnStatus();
|
|
}
|
|
/// <summary>
|
|
/// Effettua split ODL da ALTRA tavola su tav corrente
|
|
/// </summary>
|
|
/// <param name="sender"></param>
|
|
/// <param name="e"></param>
|
|
protected void lbtSplitOdlSuTav_Click(object sender, EventArgs e)
|
|
{
|
|
// chiamo stored x splittare ODL...
|
|
int idxOdlAltra = 0;
|
|
int.TryParse(idxOdlAltraMacc, out idxOdlAltra);
|
|
// se ho trovato...
|
|
if (idxOdlAltra > 0)
|
|
{
|
|
DataLayer.obj.taODL.dividiDaAltraTav(idxOdlAltra, DataLayer.MatrOpr, idxMacchina);
|
|
// messaggio utente
|
|
string evText = "Registrata inizio attrezzaggio da split ODL {0} (come da altra tavola)";
|
|
StringBuilder sb = new StringBuilder();
|
|
sb.AppendLine(String.Format(evText, idxOdlAltra));
|
|
lblOut.Text = sb.ToString();
|
|
}
|
|
// update button x setup da altra tavola...
|
|
checkAll();
|
|
// sollevo evento!
|
|
if (eh_reqUpdate != null)
|
|
{
|
|
eh_reqUpdate(this, new EventArgs());
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// Effettua ripresa ODL su tavola
|
|
/// </summary>
|
|
/// <param name="sender"></param>
|
|
/// <param name="e"></param>
|
|
protected void lbtReopOdlSuTav_Click(object sender, EventArgs e)
|
|
{
|
|
// chiamo stored x riprendere ODL (toglie data chiusura...)
|
|
DS_ProdTempi.ODLDataTable tabRes = DataLayer.obj.taODL.reopenGetLast(idxMacchina);
|
|
if (tabRes.Rows.Count > 0)
|
|
{
|
|
var riga = tabRes[0];
|
|
// messaggio utente
|
|
string evText = "Registrato riapertura ODL {0} | art {1}";
|
|
StringBuilder sb = new StringBuilder();
|
|
sb.AppendLine(String.Format(evText, riga.IdxODL, riga.CodArticolo));
|
|
lblOut.Text = sb.ToString();
|
|
}
|
|
// update buttons...
|
|
checkAll();
|
|
// sollevo evento!
|
|
if (eh_reqUpdate != null)
|
|
{
|
|
eh_reqUpdate(this, new EventArgs());
|
|
}
|
|
}
|
|
|
|
protected void txtSearchODL_TextChanged(object sender, EventArgs e)
|
|
{
|
|
odsODL.DataBind();
|
|
}
|
|
|
|
protected void lbtFixEndSetup_Click(object sender, EventArgs e)
|
|
{
|
|
string ts = string.Format("{0:yyMMdd}T{0:HHmmss.fff}Z", DateTime.Now);
|
|
string outData = $"TS:{ts}|MATR:{DataLayer.MatrOpr}|ODL:{idxOdlMacc}";
|
|
DataLayer.addTask4Machine(idxMacchina, taskType.fixStopSetup, outData);
|
|
outData = "Inserita richiesta invio Fix chiusura attrezzaggio " + outData;
|
|
lblOut.Text = outData;
|
|
}
|
|
}
|
|
} |