Samuele E. Locatelli
671 lines
21 KiB
C#
671 lines
21 KiB
C#
using MapoDb;
|
|
using SteamWare;
|
|
using System;
|
|
using System.Web.UI;
|
|
using System.Web.UI.WebControls;
|
|
|
|
namespace MoonProTablet.WebUserControls
|
|
{
|
|
public partial class mod_ODL : System.Web.UI.UserControl
|
|
{
|
|
/// <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)
|
|
{
|
|
checkAll();
|
|
// 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 checkAll()
|
|
{
|
|
lblOut.Text = "";
|
|
checkBtnStatus();
|
|
chkCloseOdl.Checked = memLayer.ML.cdvb("chkCloseOdl");
|
|
chkCloseOdl.Visible = memLayer.ML.cdvb("showChkCloseOdl");
|
|
divOdlProvv.Visible = memLayer.ML.cdvb("showOdlProvv");
|
|
}
|
|
/// <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
|
|
{
|
|
rigaStato = DataLayer.obj.taStatoMacchine.GetDataByIdxMacchina(idxMacchina)[0];
|
|
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);
|
|
// sistemo SOLO se non si trtta di un postback...
|
|
if (!Page.IsPostBack)
|
|
{
|
|
int idxOdl = 0;
|
|
try
|
|
{
|
|
idxOdl = DataLayer.obj.taODL.getByMacchina(idxMacchina)[0].IdxODL;
|
|
updateTempoTc(idxOdl);
|
|
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="idxEvento"></param>
|
|
/// <param name="userMsg"></param>
|
|
/// <param name="idxODL"></param>
|
|
private void processaEvento(int idxEvento, string userMsg, int idxODL)
|
|
{
|
|
MapoDb.inputComando inCmd;
|
|
MapoDb.inputComando inCmd2;
|
|
DS_applicazione.StatoMacchineRow rigaStato = DataLayer.obj.taStatoMacchine.GetDataByIdxMacchina(idxMacchina)[0];
|
|
// ricavo codice articolo...
|
|
string CodArticolo = DataLayer.obj.taODL.getByIdx(idxODL, false)[0].CodArticolo;
|
|
// processo evento...
|
|
inCmd = controllerMapo.scriviRigaEventoBarcode(idxMacchina, idxEvento, CodArticolo, "", rigaStato.MatrOpr, rigaStato.pallet);
|
|
// se la macchina è MULTI (cod#tavola) e sonoa INIZIO/FINE attrezzaggio (idxEv <=2) processo ANCHE per la macchina madre...
|
|
if (idxMacchina.IndexOf('#') > 0 && idxEvento <= 2)
|
|
{
|
|
string idxMacchinaParent = idxMacchina.Substring(0, idxMacchina.IndexOf('#'));
|
|
inCmd2 = controllerMapo.scriviRigaEventoBarcode(idxMacchinaParent, idxEvento, CodArticolo, "", rigaStato.MatrOpr, rigaStato.pallet);
|
|
}
|
|
// chiamo refresh MSE
|
|
DataLayer.obj.taMSE.forceRefreshMacchina(idxMacchina);
|
|
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 decimal del TC ASSEGNATO...
|
|
/// </summary>
|
|
protected decimal TCAssegnato(int idxODL)
|
|
{
|
|
decimal answ = 0;
|
|
|
|
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;
|
|
}
|
|
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)
|
|
{
|
|
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), 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, 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, txtNote.Text);
|
|
// salvo ODL Current
|
|
idxODL_curr = idxODLSel;
|
|
}
|
|
// process evento
|
|
int idxEvento = 2; // !!!HARD CODED
|
|
processaEvento(idxEvento, String.Format("Registrata inizio attrezzaggio per ODL {0}", idxODL_curr), idxODL_curr);
|
|
// resetto contapezzi redis...
|
|
DataLayer.saveCounter(idxMacchina, "0");
|
|
// imposto ODL su redis...
|
|
DataLayer.saveCurrODL(idxMacchina, idxODL_curr.ToString());
|
|
// ricarico...
|
|
Response.Redirect("~/ODL");
|
|
}
|
|
else
|
|
{
|
|
lblOut.Text = "Selezionare un ORDINE valido!";
|
|
}
|
|
}
|
|
/// <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, 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
|
|
processaEvento(idxEvento, String.Format("Registrata inizio produzione per ODL {0}", idxODL), idxODL);
|
|
|
|
// nascondo note!
|
|
showNoteTC(false);
|
|
}
|
|
/// <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
|
|
DataLayer.obj.taODL.fineProd(idxODL, idxMacchina);
|
|
processaEvento(idxEvento, String.Format("Registrata fine produzione per ODL {0}", idxODL), idxODL);
|
|
}
|
|
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), string.Format("Fine Produzione, Sospensione ODL {0}, generato residuo con pari TCiclo: {1}", idxODL, TCAssegnato(idxODL)), false);
|
|
|
|
// processo chiusura setup
|
|
processaEvento(idxEvento, String.Format("Registrata fine produzione per ODL {0}, nuovo ODL per quantità residua", idxODL), idxODL);
|
|
// 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);
|
|
// ricarico...
|
|
Response.Redirect("~/ODL.aspx");
|
|
}
|
|
/// <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);
|
|
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;
|
|
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, txtNote.Text, true);
|
|
|
|
// resetto ODL su redis...
|
|
DataLayer.emptyCurrODL(idxMacchina);
|
|
|
|
// invio email!
|
|
DataLayer.obj.sendWarnTcChangeReq(memLayer.ML.CRS("_adminEmail"));
|
|
// processo chiusura setup
|
|
processaEvento(idxEvento, String.Format("Registrato Riattrezzaggio ODL (old: {0})", currODL), currODL);
|
|
// sistemo buttons!
|
|
bool splitOdl = false;
|
|
fixSplitBtn(splitOdl);
|
|
}
|
|
/// <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);
|
|
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;
|
|
}
|
|
/// <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="idxOdl"></param>
|
|
private void updateTempoTc(int idxOdl)
|
|
{
|
|
// riporta TC
|
|
decimal TCRichAttr = 0;
|
|
if (enableRPO)
|
|
{
|
|
var rigaProm = DataLayer.obj.taPODL.getByKey(idxOdl)[0];
|
|
TCRichAttr = rigaProm.TCAssegnato;
|
|
}
|
|
else
|
|
{
|
|
DS_ProdTempi.ODLRow rigaOdl = DataLayer.obj.taODL.getByIdx(idxOdl, false)[0];
|
|
if (rigaOdl.TCRichAttr > 0)
|
|
{
|
|
TCRichAttr = rigaOdl.TCRichAttr;
|
|
}
|
|
else
|
|
{
|
|
TCRichAttr = rigaOdl.TCAssegnato;
|
|
}
|
|
}
|
|
// mostro!
|
|
mod_tempoMSMC.tempoMC = TCRichAttr;
|
|
}
|
|
|
|
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();
|
|
}
|
|
}
|
|
} |