Samuele Locatelli
716 lines
25 KiB
C#
716 lines
25 KiB
C#
using AppData;
|
|
using Newtonsoft.Json;
|
|
using SteamWare;
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.Diagnostics;
|
|
using System.Text.RegularExpressions;
|
|
using System.Web.UI;
|
|
|
|
namespace C_TRACK
|
|
{
|
|
public partial class barcode : BasePage
|
|
{
|
|
/// <summary>
|
|
/// idxRec della fase attiva
|
|
/// </summary>
|
|
public int idxRecCurr
|
|
{
|
|
get
|
|
{
|
|
return memLayer.ML.IntSessionObj("idxRecCurr");
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// Qta della fase attiva
|
|
/// </summary>
|
|
public int QtaFaseCurr
|
|
{
|
|
get
|
|
{
|
|
return memLayer.ML.IntSessionObj("QtaFaseCurr");
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// Codice TASK corrente
|
|
/// </summary>
|
|
public string CurrNumTask
|
|
{
|
|
get
|
|
{
|
|
return memLayer.ML.StringSessionObj("CurrNumTask");
|
|
}
|
|
set
|
|
{
|
|
memLayer.ML.setSessionVal("CurrNumTask", value);
|
|
// cerco articolo e lo salvo...
|
|
string CurrCodArt = "";
|
|
try
|
|
{
|
|
CurrCodArt = DLMan.taTL.getByKey(value)[0].CodArt;
|
|
}
|
|
catch
|
|
{ }
|
|
memLayer.ML.setSessionVal("CurrCodArt", CurrCodArt);
|
|
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// Codice TAG corrente
|
|
/// </summary>
|
|
public string CurrCodTag
|
|
{
|
|
get
|
|
{
|
|
// se è visibile il modulo restituisco val selezionato altrimenti vuoto...
|
|
return mod_selTag.Visible ? mod_selTag.CodTag : "";
|
|
}
|
|
set
|
|
{
|
|
mod_selTag.CodTag = value;
|
|
}
|
|
}
|
|
protected void Page_Load(object sender, EventArgs e)
|
|
{
|
|
// Crea stopwatch.
|
|
Stopwatch stopwatch = new Stopwatch();
|
|
// Avvio...
|
|
stopwatch.Start();
|
|
checkVisib();
|
|
if (!Page.IsPostBack)
|
|
{
|
|
traduciObj();
|
|
numDD = memLayer.ML.CRI("numDD");
|
|
cacheValSec = memLayer.ML.CRI("cacheValSec");
|
|
divReload.Visible = devicesAuthProxy.stObj.userHasRight("CT_userStart");
|
|
setTipoTaskSel();
|
|
}
|
|
checkRequisiti();
|
|
// effettuo load valori...
|
|
setupComandiBarcode();
|
|
setupValoriBarcode();
|
|
// a seconda di pagina singola o multi determino come procedere con comani / dati grezzi...
|
|
if (mUtils.postIsMulti)
|
|
{
|
|
// gestiosco segnali "grezzi"
|
|
mod_barcode1.eh_dataRead += Mod_barcode_eh_dataRead;
|
|
mod_postMulti.eh_reqUpdate += Mod_postMulti_eh_reqUpdate;
|
|
// SE fosse un reset ESEGUO comando!!!
|
|
if (mod_barcode1.comandoRegistrato.prevCmdIn == mUtils.reCmdResetOper)
|
|
{
|
|
eseguiComando();
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// registro eventi
|
|
mod_barcode1.eh_comandoRegistrato += new EventHandler(Mod_barcode_eh_comandoRegistrato);
|
|
mod_btnComandi1.eh_clickComando += new EventHandler(mod_btnComandi1_eh_clickComando);
|
|
}
|
|
mod_selTask.eh_dataSel += Mod_selTask_eh_dataSel;
|
|
// registro
|
|
stopwatch.Stop();
|
|
lastUpdDuration = stopwatch.Elapsed;
|
|
}
|
|
|
|
private void Mod_postMulti_eh_reqUpdate(object sender, EventArgs e)
|
|
{
|
|
setTipoTaskSel();
|
|
// aggiorna eleco task...
|
|
mod_taskRec.doUpdate();
|
|
}
|
|
|
|
private void setTipoTaskSel()
|
|
{
|
|
// in base al tipo di postazione è per user o per post multi
|
|
if (mUtils.postIsMulti)
|
|
{
|
|
mod_taskRec.tipoSelezione = WebUserControls.selType.byPostMulti;
|
|
}
|
|
else
|
|
{
|
|
mod_taskRec.tipoSelezione = WebUserControls.selType.byUser;
|
|
}
|
|
}
|
|
|
|
private void Mod_selTask_eh_dataSel(object sender, EventArgs e)
|
|
{
|
|
// selezione commessa --> chiamo metodo caricamento comandi in modulo barcode...
|
|
mod_barcode1.loadBtnClickComando();
|
|
// refresh master...
|
|
((WebMasterPages.Bootstrap)this.Master).doUpdate();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Verifica visibilità componenti bcode e selettore...
|
|
/// </summary>
|
|
private void checkVisib()
|
|
{
|
|
mod_barcode1.Visible = mUtils.OptUseBCode;
|
|
mod_selTask.Visible = mUtils.OptUseSelTask;
|
|
// per i tags NON DEVE essere una post multi e DEVE esserci una comemssa...
|
|
mod_selTag.Visible = mUtils.OptUseSelTag && !mUtils.postIsMulti && CurrNumTask != "";
|
|
// se ho in pancia la selezione di un opzione ed è visibile tag --> seleziono!
|
|
if (mUtils.OptBCodePrepDo && mod_selTag.Visible)
|
|
{
|
|
// SE HO in memoria...
|
|
if (mUtils.optValueBC != "")
|
|
{
|
|
try
|
|
{
|
|
// seleziono
|
|
mod_selTag.PrevCodTag = mUtils.optValueBC;
|
|
}
|
|
catch
|
|
{ }
|
|
//...e tolgo valore preselezione
|
|
mUtils.optValueBC = "";
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Verifica i requisiti (operatore e postazione) per operare
|
|
/// </summary>
|
|
private void checkRequisiti()
|
|
{
|
|
mod_btnComandi1.Visible = (mUtils.CodOpr != "" && mUtils.CodPost != "");
|
|
// ora controllo SE SIA una postazione multi e di conseguenza imposto div relativi...
|
|
showMulti = mUtils.postIsMulti;
|
|
}
|
|
|
|
protected bool showMulti
|
|
{
|
|
set
|
|
{
|
|
divMulti.Visible = value;
|
|
mod_postMulti.Visible = value;
|
|
divMain.Attributes.Remove("class");
|
|
divMain.Attributes.Add("class", value ? "col-12 col-xl-9" : "col-12");
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Numero comandi ammessi caricati
|
|
/// </summary>
|
|
public int nComandi
|
|
{
|
|
get
|
|
{
|
|
return comandiAmmessiBCode.Count;
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// Numero record BCode caricati
|
|
/// </summary>
|
|
public int nBCodeRec
|
|
{
|
|
get
|
|
{
|
|
return valoriAmmessiBCode.Count;
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// Memorizzo durata ultimo update (lettura record...) come timespan
|
|
/// </summary>
|
|
public TimeSpan lastUpdDuration
|
|
{
|
|
get
|
|
{
|
|
return (TimeSpan)memLayer.ML.objSessionObj("lastUpdDuration");
|
|
}
|
|
set
|
|
{
|
|
memLayer.ML.setSessionVal("lastUpdDuration", value);
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// inviato un comando dai link buttons
|
|
/// </summary>
|
|
/// <param name="sender"></param>
|
|
/// <param name="e"></param>
|
|
void mod_btnComandi1_eh_clickComando(object sender, EventArgs e)
|
|
{
|
|
// chiamo metodo caricamento comandi in modulo barcode...
|
|
mod_barcode1.loadBtnClickComando();
|
|
}
|
|
|
|
private void traduciObj()
|
|
{
|
|
}
|
|
/// <summary>
|
|
/// imposta/recupera valore num gg da rileggere...
|
|
/// </summary>
|
|
public int numDD
|
|
{
|
|
get
|
|
{
|
|
int answ = 85;
|
|
try
|
|
{
|
|
answ = Convert.ToInt32(txtNumDD.Text.Trim());
|
|
}
|
|
catch
|
|
{ }
|
|
return answ;
|
|
}
|
|
set
|
|
{
|
|
txtNumDD.Text = value.ToString();
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// logLevel impostato...
|
|
/// </summary>
|
|
public int logLevel
|
|
{
|
|
get
|
|
{
|
|
int answ = 1;
|
|
try
|
|
{
|
|
answ = memLayer.ML.CRI("_logLevel");
|
|
}
|
|
catch
|
|
{ }
|
|
return answ;
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// imposta/recupera valore num sec validità cache...
|
|
/// </summary>
|
|
public int cacheValSec
|
|
{
|
|
get
|
|
{
|
|
int answ = 55;
|
|
try
|
|
{
|
|
answ = Convert.ToInt32(txtCacheSec.Text.Trim());
|
|
}
|
|
catch
|
|
{ }
|
|
|
|
return answ;
|
|
}
|
|
set
|
|
{
|
|
txtCacheSec.Text = value.ToString();
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// Variabile x controllo scadenza valori in cache
|
|
/// </summary>
|
|
protected DateTime lastDataRefresh
|
|
{
|
|
get
|
|
{
|
|
DateTime answ = DateTime.Now.AddDays(-1);
|
|
try
|
|
{
|
|
answ = Convert.ToDateTime(memLayer.ML.objCacheObj("lastBCodeDataRead"));
|
|
}
|
|
catch
|
|
{ }
|
|
return answ;
|
|
}
|
|
set
|
|
{
|
|
// registro che i valori in cache sono scaduti...
|
|
memLayer.ML.setCacheVal("lastBCodeDataRead", value);
|
|
if (logLevel > 5)
|
|
{
|
|
logger.lg.scriviLog("impostata validita cache");
|
|
}
|
|
}
|
|
}
|
|
protected bool cacheValida
|
|
{
|
|
get
|
|
{
|
|
bool answ = false;
|
|
try
|
|
{
|
|
if (DateTime.Now.Subtract(lastDataRefresh).TotalSeconds < cacheValSec)
|
|
{
|
|
answ = true;
|
|
}
|
|
}
|
|
catch
|
|
{ }
|
|
return answ;
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// Elenco (da cache) dei valori ammessi x BCode
|
|
/// </summary>
|
|
protected Dictionary<string, string> valoriAmmessiBCode
|
|
{
|
|
get
|
|
{
|
|
Dictionary<string, string> answ = new Dictionary<string, string>();
|
|
bool valIncache = memLayer.ML.isInCacheObject("valoriAmmessiBCode");
|
|
if (valIncache && cacheValida)
|
|
{
|
|
answ = JsonConvert.DeserializeObject<Dictionary<string, string>>(memLayer.ML.objCacheObj("valoriAmmessiBCode").ToString());
|
|
}
|
|
return answ;
|
|
}
|
|
set
|
|
{
|
|
string serVal = JsonConvert.SerializeObject(value);
|
|
memLayer.ML.setCacheVal("valoriAmmessiBCode", serVal);
|
|
lastDataRefresh = DateTime.Now;
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// Elenco (da cache) dei comandi ammessi x BCode
|
|
/// </summary>
|
|
protected Dictionary<string, string> comandiAmmessiBCode
|
|
{
|
|
get
|
|
{
|
|
Dictionary<string, string> answ = new Dictionary<string, string>();
|
|
if (memLayer.ML.isInCacheObject("comandiAmmessiBCode"))
|
|
{
|
|
try
|
|
{
|
|
answ = JsonConvert.DeserializeObject<Dictionary<string, string>>(memLayer.ML.objCacheObj("comandiAmmessiBCode").ToString());
|
|
}
|
|
catch
|
|
{
|
|
answ = new Dictionary<string, string>();
|
|
}
|
|
}
|
|
return answ;
|
|
}
|
|
set
|
|
{
|
|
string serVal = JsonConvert.SerializeObject(value);
|
|
memLayer.ML.setCacheVal("comandiAmmessiBCode", serVal);
|
|
lastDataRefresh = DateTime.Now;
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// effettuo il setup dei valori ammessi x il barcode...
|
|
/// </summary>
|
|
private void setupValoriBarcode()
|
|
{
|
|
if (valoriAmmessiBCode.Count > 0)
|
|
{
|
|
// assegno valori al barcode...
|
|
mod_barcode1.tabValori = valoriAmmessiBCode;
|
|
if (logLevel > 5)
|
|
{
|
|
logger.lg.scriviLog("Letti da cache VALORI Barcode", tipoLog.INFO);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// Crea stopwatch.
|
|
Stopwatch stopwatch = new Stopwatch();
|
|
// Avvio...
|
|
stopwatch.Start();
|
|
// carico dati!
|
|
if (logLevel > 5)
|
|
{
|
|
logger.lg.scriviLog("Inizio setup valori Barcode", tipoLog.INFO);
|
|
}
|
|
|
|
Dictionary<string, string> valori = new Dictionary<string, string>();
|
|
|
|
// aggiungo i COD OPERATORE
|
|
var tabOpr = DLMan.taAO.GetData();
|
|
foreach (var rigaOpr in tabOpr)
|
|
{
|
|
valori.Add(rigaOpr.CodOpr, string.Format("{0} {1}", rigaOpr.Cognome, rigaOpr.Nome));
|
|
}
|
|
if (logLevel > 5)
|
|
{
|
|
logger.lg.scriviLog("Caricato OPERATORI per Barcode", tipoLog.INFO);
|
|
}
|
|
|
|
// aggiungo le POSTAZIONI
|
|
var tabPost = DLMan.taAP.GetData();
|
|
foreach (var rigaPost in tabPost)
|
|
{
|
|
valori.Add(rigaPost.CodPost, rigaPost.Descrizione);
|
|
}
|
|
if (logLevel > 5)
|
|
{
|
|
logger.lg.scriviLog("Caricato POSTAZIONI per Barcode", tipoLog.INFO);
|
|
}
|
|
// aggiungo le commesse...
|
|
var tabTask = DLMan.taTL.getLastNumDD(numDD);
|
|
foreach (var rigaTask in tabTask)
|
|
{
|
|
valori.Add(rigaTask.NumTask, string.Format("Comm. {0} | Art. {1} | Qta {2}", rigaTask.NumTask, rigaTask.CodArt, rigaTask.QtaRic));
|
|
}
|
|
if (logLevel > 5)
|
|
{
|
|
logger.lg.scriviLog("Caricato TaskList per Barcode", tipoLog.INFO);
|
|
}
|
|
// assegno valori al barcode...
|
|
mod_barcode1.tabValori = valori;
|
|
valoriAmmessiBCode = valori;
|
|
lastDataRefresh = DateTime.Now;
|
|
logger.lg.scriviLog("Letti da DB VALORI Barcode", tipoLog.INFO);
|
|
stopwatch.Start();
|
|
lastUpdDuration = stopwatch.Elapsed;
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// carico da tab i comandi ammessi per il barcode...
|
|
/// </summary>
|
|
private void setupComandiBarcode()
|
|
{
|
|
if (comandiAmmessiBCode.Count > 0)
|
|
{
|
|
// assegno valori al barcode...
|
|
mod_barcode1.comandiAmmessi = comandiAmmessiBCode;
|
|
if (logLevel > 5)
|
|
{
|
|
logger.lg.scriviLog("Letti da cache COMANDI Barcode", tipoLog.INFO);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
Dictionary<string, string> comandi = new Dictionary<string, string>();
|
|
|
|
// !!!FARE!!! togliere...
|
|
var tabCmd = DLMan.taTE2S.getByMappa("E_BC");
|
|
foreach (var rigaCmd in tabCmd)
|
|
{
|
|
comandi.Add(rigaCmd.CodEvento.ToUpper(), devicesAuthProxy.stObj.traduci(rigaCmd.text2show));
|
|
}
|
|
|
|
|
|
var tabFasi = DLMan.taAF.GetData();
|
|
foreach (var rigaFase in tabFasi)
|
|
{
|
|
comandi.Add(rigaFase.CodFase, rigaFase.DescrFase);
|
|
}
|
|
|
|
// impongo i comandi al barcode...
|
|
mod_barcode1.comandiAmmessi = comandi;
|
|
comandiAmmessiBCode = comandi;
|
|
logger.lg.scriviLog("Letti da DB COMANDI Barcode", tipoLog.INFO);
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// il barcode ha registrato un evento...
|
|
/// </summary>
|
|
/// <param name="sender"></param>
|
|
/// <param name="e"></param>
|
|
void Mod_barcode_eh_dataRead(object sender, EventArgs e)
|
|
{
|
|
// passo il processing al modulo postMulti...
|
|
mod_postMulti.processInput(mod_barcode1.rawInput);
|
|
}
|
|
/// <summary>
|
|
/// il barcode ha registrato un evento...
|
|
/// </summary>
|
|
/// <param name="sender"></param>
|
|
/// <param name="e"></param>
|
|
void Mod_barcode_eh_comandoRegistrato(object sender, EventArgs e)
|
|
{
|
|
switch (stateMachine.st.azioneComando(mod_barcode1.comandoRegistrato))
|
|
{
|
|
case tipoAzione.annulla:
|
|
mod_barcode1.resetMe();
|
|
break;
|
|
case tipoAzione.conferma:
|
|
// se input completo eseguo...
|
|
if (mod_barcode1.comandoRegistrato.currCmdIn != "" && mod_barcode1.comandoRegistrato.valore != "")
|
|
{
|
|
eseguiComando();
|
|
}
|
|
else // altrimenti warning... e rimetto valori precedenti
|
|
{
|
|
mod_barcode1.txtRich2show = user_std.UtSn.Traduci("codObjUnknown");
|
|
mod_barcode1.comandoRegistrato.currCmdIn = mod_barcode1.comandoRegistrato.prevCmdIn;
|
|
mod_barcode1.comandoRegistrato.descrComando = mod_barcode1.comandoRegistrato.descrComandoPrev;
|
|
mod_barcode1.txtInput2show = mod_barcode1.comandoRegistrato.descrComandoPrev;
|
|
}
|
|
break;
|
|
case tipoAzione.esegui:
|
|
// se ho auto conferma eseguo!
|
|
if (memLayer.ML.CRB("autoConfCmd"))
|
|
{
|
|
mod_barcode1.comandoRegistrato.prevCmdIn = mod_barcode1.comandoRegistrato.currCmdIn;
|
|
mod_barcode1.comandoRegistrato.currCmdIn = "ok";
|
|
eseguiComando();
|
|
}
|
|
else
|
|
{
|
|
if (mod_barcode1.comandoRegistrato.valore != "")
|
|
{
|
|
mod_barcode1.txtRich2show = user_std.UtSn.Traduci("pleaseConfirm");
|
|
}
|
|
else
|
|
{
|
|
mod_barcode1.txtRich2show = user_std.UtSn.Traduci("codObjUnknown");
|
|
}
|
|
}
|
|
break;
|
|
case tipoAzione.noAct:
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
mod_btnComandi1.updateBtn();
|
|
}
|
|
/// <summary>
|
|
/// eseguo il comando
|
|
/// </summary>
|
|
private void eseguiComando()
|
|
{
|
|
// in primis: sono in esecuzione, x cui il comando è valido...
|
|
string msg2show = "";
|
|
Match testNumTask = Regex.Match(mod_barcode1.comandoRegistrato.valore, mUtils.reNumTask);
|
|
Match testOper = Regex.Match(mod_barcode1.comandoRegistrato.valore, mUtils.reCodOper);
|
|
Match testPost = Regex.Match(mod_barcode1.comandoRegistrato.valore, mUtils.reCodPost);
|
|
|
|
// verifico se cmd setup utente...
|
|
if (mod_barcode1.comandoRegistrato.prevCmdIn == mUtils.reCmdResetOper)
|
|
{
|
|
// rimuovo OPR da POST occupate
|
|
DLMan.taAP.resetOpr(mUtils.CodOpr);
|
|
// rimuovo OPR da sessione
|
|
mUtils.CodOpr = "";
|
|
// rimuovo post corrente...
|
|
mUtils.CodPost = "";
|
|
// rimuovo MULTI
|
|
mUtils.postIsMulti = false;
|
|
// rimuovo COMMESSA
|
|
CurrNumTask = "";
|
|
// rimuovo eventuale val opzionale
|
|
mUtils.optValueBC = "";
|
|
// torno a pagina base...
|
|
Response.Redirect("~/barcode");
|
|
}
|
|
else if (mod_barcode1.comandoRegistrato.prevCmdIn == mUtils.reCmdResetNumTask)
|
|
{
|
|
// rimuovo COMMESSA
|
|
CurrNumTask = "";
|
|
// rimuovo eventuale val opzionale
|
|
mUtils.optValueBC = "";
|
|
// torno a pagina base...
|
|
Response.Redirect("~/barcode");
|
|
}
|
|
//else if (mod_barcode1.comandoRegistrato.valore.Contains("OPR."))
|
|
else if (testOper.Success)
|
|
{
|
|
// imposto operatore
|
|
mUtils.CodOpr = mod_barcode1.comandoRegistrato.valore;
|
|
// SE HO postazione...
|
|
if (mUtils.CodPost != "")
|
|
{
|
|
// ...e SE la postazione è libera associo e registro
|
|
var tabPost = DLMan.taAP.getByKey(mUtils.CodPost);
|
|
if (tabPost.Rows.Count == 1)
|
|
{
|
|
var rigaPost = tabPost[0];
|
|
if (rigaPost.CodOpr == mUtils.CodOpr || rigaPost.CodOpr == "")
|
|
{
|
|
DLMan.taAP.setOpr(mUtils.CodPost, mUtils.CodOpr);
|
|
}
|
|
else
|
|
{
|
|
// tolgo postazione (è occupata...)
|
|
mUtils.CodPost = "";
|
|
}
|
|
}
|
|
}
|
|
Response.Redirect("~/barcode");
|
|
}
|
|
else if (testPost.Success)
|
|
{
|
|
// SE HO operatore ...
|
|
if (mUtils.CodOpr != "")
|
|
{
|
|
// ...e SE la postazione è libera o c'è lui associo e registro
|
|
var tabPost = DLMan.taAP.getByKey(mod_barcode1.comandoRegistrato.valore);
|
|
if (tabPost.Rows.Count == 1)
|
|
{
|
|
var rigaPost = tabPost[0];
|
|
if (rigaPost.CodOpr == mUtils.CodOpr || rigaPost.CodOpr == "")
|
|
{
|
|
mUtils.CodPost = mod_barcode1.comandoRegistrato.valore;
|
|
DLMan.taAP.setOpr(mUtils.CodPost, mUtils.CodOpr);
|
|
// svuoto vallori
|
|
}
|
|
}
|
|
}
|
|
Response.Redirect("~/barcode");
|
|
}
|
|
else if (testNumTask.Success)
|
|
{
|
|
CurrNumTask = mod_barcode1.comandoRegistrato.valore;
|
|
Response.Redirect("~/barcode");
|
|
}
|
|
else if (mod_barcode1.comandoRegistrato.prevCmdIn == mUtils.reCmdPause)
|
|
{
|
|
// registro chiusura con qta 0 (pausa)
|
|
DLMan.taTR.updateQuery(idxRecCurr, DateTime.Now, 0);
|
|
Response.Redirect("~/barcode");
|
|
}
|
|
else if (mod_barcode1.comandoRegistrato.prevCmdIn == mUtils.reCmdClose)
|
|
{
|
|
// registro chiusura con la qta indicata
|
|
DLMan.taTR.updateQuery(idxRecCurr, DateTime.Now, QtaFaseCurr);
|
|
Response.Redirect("~/barcode");
|
|
}
|
|
else if (DLMan.taAF.getByKey(mod_barcode1.comandoRegistrato.prevCmdIn).Rows.Count > 0)
|
|
{
|
|
// se è un comando di fase --> registro INIZIO!
|
|
DLMan.taTR.insertQuery(mUtils.CodOpr, mUtils.CodPost, CurrNumTask, CurrCodTag, mod_barcode1.comandoRegistrato.prevCmdIn, DateTime.Now);
|
|
// controllo se sia fase di CHIUSURA DEFINITIVA registro con INIZIO e FINE insieme e CHIUDO commessa...
|
|
var rigaFase = DLMan.taAF.getByKey(mod_barcode1.comandoRegistrato.prevCmdIn)[0];
|
|
if (rigaFase.CloseTask)
|
|
{
|
|
// chiudo direttamente SIA fase che il TASK principale...
|
|
DLMan.taTL.updateClose(CurrNumTask, true);
|
|
// se è abilitato PODL indico chiuso anche li... IdxOdl = -10
|
|
|
|
// tolgo comm corrente...
|
|
CurrNumTask = "";
|
|
// rimuovo eventuale val opzionale
|
|
mUtils.optValueBC = "";
|
|
}
|
|
Response.Redirect("~/barcode");
|
|
}
|
|
// reset e mostro output...
|
|
mod_barcode1.resetMe();
|
|
if (msg2show != "")
|
|
{
|
|
mod_barcode1.txtInput2show = msg2show;
|
|
}
|
|
}
|
|
|
|
protected void btnReload_Click(object sender, EventArgs e)
|
|
{
|
|
resetCache();
|
|
}
|
|
|
|
private void resetCache()
|
|
{
|
|
// resetto tutto!
|
|
comandiAmmessiBCode = new Dictionary<string, string>();
|
|
valoriAmmessiBCode = new Dictionary<string, string>();
|
|
lastDataRefresh = DateTime.Now.AddDays(-1);
|
|
}
|
|
|
|
protected void txtCacheSec_TextChanged(object sender, EventArgs e)
|
|
{
|
|
resetCache();
|
|
}
|
|
|
|
protected void txtNumDD_TextChanged(object sender, EventArgs e)
|
|
{
|
|
resetCache();
|
|
}
|
|
}
|
|
}
|
|
|