Samuele E. Locatelli
1468 lines
44 KiB
C#
1468 lines
44 KiB
C#
using SteamWare;
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.Data;
|
|
using System.Linq;
|
|
|
|
namespace GMW_data
|
|
{
|
|
public class UserControlBCodeMan : GMW_data.UserControl
|
|
{
|
|
/// <summary>
|
|
/// Oggetto locale gestione classe datamatrix...
|
|
/// </summary>
|
|
protected DataMatrix DataMatrix_mgr = new DataMatrix();
|
|
#region Conf stili css
|
|
|
|
/// <summary>
|
|
/// stile css comando OK
|
|
/// </summary>
|
|
public string cssOk = "stileComandoOk";
|
|
/// <summary>
|
|
/// stile css comando KO
|
|
/// </summary>
|
|
public string cssErr = "stileComandoKo";
|
|
/// <summary>
|
|
/// stile css comando ND
|
|
/// </summary>
|
|
public string cssWait = "stileComandoND";
|
|
/// <summary>
|
|
/// stile css comando ATTESA
|
|
/// </summary>
|
|
public string cssAtt = "stileAttesa";
|
|
/// <summary>
|
|
/// stile css comando warning
|
|
/// </summary>
|
|
public string cssWarn = "stileComandoWarn";
|
|
/// <summary>
|
|
/// stile css comando ADD
|
|
/// </summary>
|
|
public string cssAdd = "stileComandoAdd";
|
|
|
|
#endregion
|
|
|
|
|
|
#region area base comune (variabili, valori eventi - stati - tipi - posizioni)
|
|
|
|
/// <summary>
|
|
/// Abilitato/disabilitato BCode particolare
|
|
/// </summary>
|
|
public bool enableBCodeParticolare = true;
|
|
/// <summary>
|
|
/// flusso associato al controllo
|
|
/// </summary>
|
|
public string flusso = "";
|
|
/// <summary>
|
|
/// flusso PRECEDENTE (ancestor) associato al controllo
|
|
/// </summary>
|
|
public string flussoAnc = "";
|
|
/// <summary>
|
|
/// flusso associato (hard coded) a temporaneo
|
|
/// </summary>
|
|
public string flussoTemp = "";
|
|
/// <summary>
|
|
/// stato associato all'UDC da CREARE
|
|
/// </summary>
|
|
public string statoUDC = "";
|
|
/// <summary>
|
|
/// stato associato all'UDC da accettare
|
|
/// </summary>
|
|
public string statoUDC_pre = "";
|
|
/// <summary>
|
|
/// tipo di evento associato alla creazione dell'UDC
|
|
/// </summary>
|
|
public string eventoUDC = "";
|
|
/// <summary>
|
|
/// tipo di evento associato alla modifica qta dell'UDC
|
|
/// </summary>
|
|
public string eventoUDC_qta = "";
|
|
/// <summary>
|
|
/// codice evento dell'UDC temporaneo (IN) che si crea
|
|
/// </summary>
|
|
public string eventoUDC_temp = "";
|
|
/// <summary>
|
|
/// attributo per TRATTAMENTO termico
|
|
/// </summary>
|
|
public string attrNumTra = "";
|
|
/// <summary>
|
|
/// flusso associato al TRATTAMENTO termico
|
|
/// </summary>
|
|
public string flusso_TR = "";
|
|
/// <summary>
|
|
/// nome var in sessione x IdxCella
|
|
/// </summary>
|
|
public string sVarIdxCella = "";
|
|
/// <summary>
|
|
/// dati x verifica CodSoggetto / matricola
|
|
/// </summary>
|
|
public string preCodSogg = memLayer.ML.cdv("prefCodSogg");
|
|
/// <summary>
|
|
/// Qta Imballo standard
|
|
/// </summary>
|
|
public int QtaImballoStd = memLayer.ML.cdvi("QtaImballoFiniti");
|
|
/// <summary>
|
|
/// codImballo standard
|
|
/// </summary>
|
|
public string CodImballoStd = memLayer.ML.cdv("CodImballoFiniti");
|
|
/// <summary>
|
|
/// Codice linea non utilizzabile ("00" finale = Select...)
|
|
/// </summary>
|
|
public string codLineaKo = "";
|
|
/// <summary>
|
|
/// Tipo UDC della linea x gestione messaggio (es log, ristampa, ...)
|
|
/// </summary>
|
|
public string tipoUdcLinea = "";
|
|
/// <summary>
|
|
/// IdxPosizione x UDC in ingresso
|
|
/// </summary>
|
|
public int IdxPosizioneIn = 0;
|
|
/// <summary>
|
|
/// IdxPosizione x UDC in uscita
|
|
/// </summary>
|
|
public int IdxPosizioneOut = 0;
|
|
/// <summary>
|
|
/// NOME IdxPosizione x UDC in uscita al momento della creazione
|
|
/// </summary>
|
|
public string IdxPosizioneOutTempName = "";
|
|
/// <summary>
|
|
/// IdxPosizione x UDC in uscita al momento della creazione
|
|
/// </summary>
|
|
public int IdxPosizioneOutTemp = 0;
|
|
/// <summary>
|
|
/// Cartellino da stampare/ristampare
|
|
/// </summary>
|
|
public tipoCartellino tipoCartCurr = tipoCartellino.cartND;
|
|
|
|
#endregion
|
|
|
|
|
|
#region area base comune (metodi generali)
|
|
|
|
/// <summary>
|
|
/// livello di log richiesto (web.config)
|
|
/// </summary>
|
|
public int logLevel
|
|
{
|
|
get
|
|
{
|
|
int answ = 0;
|
|
try
|
|
{
|
|
answ = memLayer.ML.CRI("_logLevel");
|
|
}
|
|
catch
|
|
{ }
|
|
return answ;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Impostazione variabili specifiche
|
|
/// </summary>
|
|
public virtual void setupVariabili()
|
|
{
|
|
}
|
|
/// <summary>
|
|
/// caricamento pagina
|
|
/// </summary>
|
|
/// <param name="sender"></param>
|
|
/// <param name="e"></param>
|
|
public virtual void Page_Load(object sender, EventArgs e)
|
|
{
|
|
setupVariabili();
|
|
if (!Page.IsPostBack)
|
|
{
|
|
Postazione.messaggiText = "";
|
|
Postazione.warningText = "";
|
|
qta = 0;
|
|
// imposto destAL
|
|
destAL = AlByCella;
|
|
traduciObj();
|
|
idxCella = Postazione.currIdxCella;
|
|
checkNumKeyIn();
|
|
setVisibility();
|
|
}
|
|
doChecks();
|
|
}
|
|
/// <summary>
|
|
/// sistema modalità input
|
|
/// </summary>
|
|
public virtual void setVisibility()
|
|
{ }
|
|
/// <summary>
|
|
/// IDX cella associata alla linea corrente
|
|
/// </summary>
|
|
public virtual int idxCella
|
|
{
|
|
get
|
|
{
|
|
int answ = 0;
|
|
if (memLayer.ML.isInSessionObject(sVarIdxCella))
|
|
{
|
|
answ = memLayer.ML.IntSessionObj(sVarIdxCella);
|
|
}
|
|
return answ;
|
|
}
|
|
set
|
|
{
|
|
memLayer.ML.setSessionVal(sVarIdxCella, value);
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// Codice AL associato alla cella corrente...
|
|
/// </summary>
|
|
public virtual string AlByCella
|
|
{
|
|
get
|
|
{
|
|
string answ = "";
|
|
try
|
|
{
|
|
answ = string.Format("ALF00{0}", Postazione.currCodCella);
|
|
// controllo se esista AL sennò lo creo...
|
|
if (MagClass.magazzino.taEA.getByAL(answ).Rows.Count == 0)
|
|
{
|
|
MagClass.magazzino.taEA.Insert(answ, true, DateTime.Now, MagClass.magazzino.CodSoggCurrUser, "", "", "", 0);
|
|
}
|
|
}
|
|
catch
|
|
{ }
|
|
return answ;
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// Codice AL sulla linea...
|
|
/// </summary>
|
|
public string currAL
|
|
{
|
|
get
|
|
{
|
|
string answ = "";
|
|
try
|
|
{
|
|
answ = MagClass.magazzino.taAL.getByKey(Postazione.currCodLinea)[0].CurrVal;
|
|
}
|
|
catch
|
|
{ }
|
|
return answ;
|
|
}
|
|
set
|
|
{
|
|
MagClass.magazzino.taAL.updateCurrVal(Postazione.currCodLinea, value);
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// Formato Datamatrix della linea selezionata
|
|
/// </summary>
|
|
public string FormatoDtmxLinea
|
|
{
|
|
get
|
|
{
|
|
string answ = "";
|
|
try
|
|
{
|
|
answ = MagClass.magazzino.taAL.getByKey(Postazione.currCodLinea)[0].FormatoDtmx;
|
|
}
|
|
catch
|
|
{ }
|
|
return answ;
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// Formato Datamatrix dell'ultimo Datamatrix letto (come barcode)
|
|
/// </summary>
|
|
public string FormatoDtmxBarcode
|
|
{
|
|
get
|
|
{
|
|
return FormatoDtmxDecod(barcodeIn);
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// decodifica formato Datamatrix
|
|
/// </summary>
|
|
public string FormatoDtmxDecod(string datamatrix)
|
|
{
|
|
string answ = "";
|
|
try
|
|
{
|
|
answ = DataMatrix_mgr.taVerifica.GetData(datamatrix)[0].FormatoDtmx;
|
|
}
|
|
catch
|
|
{ }
|
|
return answ;
|
|
}
|
|
/// <summary>
|
|
/// Formato Datamatrix da particolare (tab TrascDatamatrix)
|
|
/// </summary>
|
|
public string FormatoDtmxPartic(string Particolare)
|
|
{
|
|
string answ = "";
|
|
try
|
|
{
|
|
answ = DataMatrix_mgr.taTDtmx.getByParticolare(Particolare)[0].FormatoDtmx;
|
|
}
|
|
catch
|
|
{ }
|
|
return answ;
|
|
}
|
|
/// <summary>
|
|
/// codice particolare da datamatrix
|
|
/// </summary>
|
|
/// <param name="byTable">boolean:
|
|
/// true = utilizza lookUp su tabella dati acquisiti
|
|
/// false = prova a decodificare (da formato Dtmx linea)</param>
|
|
/// <returns></returns>
|
|
protected string partByDtmx(bool byTable)
|
|
{
|
|
string answ = "";
|
|
if (byTable)
|
|
{
|
|
answ = DataMatrix_mgr.taDtxAcquisiti.getByKey(barcodeIn)[0].Particolare;
|
|
}
|
|
else
|
|
{
|
|
answ = DataMatrix_mgr.taDecode.GetData(barcodeIn, FormatoDtmxLinea)[0].Particolare;
|
|
}
|
|
return answ;
|
|
}
|
|
|
|
/// richiesta (ri)stampa UDC
|
|
/// </summary>
|
|
/// <param name="sender"></param>
|
|
/// <param name="e"></param>
|
|
public virtual void ristampa()
|
|
{
|
|
ristampaUdc(tipoUdcLinea, udcReq);
|
|
}
|
|
/// <summary>
|
|
/// Richiesta (ri)stampa UDC
|
|
/// </summary>
|
|
/// <param name="tipoUdc">Tipo Udc (x messaggio log/SAO)</param>
|
|
/// <param name="udcReq">Codice UDC</param>
|
|
public virtual void ristampaUdc(string tipoUdc, string udcReq)
|
|
{
|
|
bool fatto = false;
|
|
// registro ri-stampa UDC
|
|
DateTime adesso = DateTime.Now;
|
|
// calcolo particolare...
|
|
DS_magazzino.ElencoCartelliniRow rigaUDC;
|
|
string particolare = "";
|
|
try
|
|
{
|
|
rigaUDC = MagClass.magazzino.taCartellini.getByUdc(udcReq)[0];
|
|
particolare = rigaUDC.Particolare;
|
|
fatto = MagClass.magazzino.ristampaUdc(udcReq, Postazione.printer, Request.UserHostName);
|
|
}
|
|
catch
|
|
{
|
|
logger.lg.scriviLog(string.Format("Errore recupero particolare UDC {0} ({1})", udcReq, tipoUdc), tipoLog.EXCEPTION);
|
|
}
|
|
if (fatto) MagClass.magazzino.taSAO.insertQuery(adesso, MagClass.magazzino.CodSoggCurrUser, Postazione.name, Postazione.IP, udcReq, particolare, "stampaUDC", string.Format("Ri-Stampato UDC {0} ({1}) su linea {2}", udcReq, tipoUdc, Postazione.currCodLinea));
|
|
raiseEvent(ucEvType.ReqUpdateParent);
|
|
}
|
|
/// <summary>
|
|
/// udc da stampare
|
|
/// </summary>
|
|
public virtual string udcReq
|
|
{
|
|
get
|
|
{
|
|
return memLayer.ML.StringSessionObj("udcSelSAO");
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// indica il codice articolo correntemente selezionato
|
|
/// </summary>
|
|
public virtual string currParticolare
|
|
{
|
|
get
|
|
{
|
|
return memLayer.ML.StringSessionObj(string.Format("currParticolare_{0}", uid));
|
|
}
|
|
set
|
|
{
|
|
memLayer.ML.setSessionVal(string.Format("currParticolare_{0}", uid), value, memLayer.ML.confReadBool("keepParticolareSel"));
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// Codice AL in carico
|
|
/// </summary>
|
|
public virtual string sourceAL
|
|
{
|
|
get
|
|
{
|
|
return "";
|
|
}
|
|
set
|
|
{ }
|
|
}
|
|
/// <summary>
|
|
/// Codice AL target
|
|
/// </summary>
|
|
public virtual string destAL
|
|
{
|
|
get
|
|
{
|
|
return "";
|
|
}
|
|
set
|
|
{ }
|
|
}
|
|
/// <summary>
|
|
/// indica il codice articolo "originale" in caso di trascodifica GRZ/GRZ o GRZ/LVT o LVT/LVT
|
|
/// </summary>
|
|
public virtual string origParticolare
|
|
{
|
|
get
|
|
{
|
|
return memLayer.ML.StringSessionObj(string.Format("origParticolare_{0}", uid));
|
|
}
|
|
set
|
|
{
|
|
memLayer.ML.setSessionVal(string.Format("origParticolare_{0}", uid), value, memLayer.ML.confReadBool("keepParticolareSel"));
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// indica UDC correntemente selezionato
|
|
/// </summary>
|
|
public virtual string currUDC
|
|
{
|
|
get
|
|
{
|
|
return memLayer.ML.StringSessionObj(string.Format("UDC_{0}", uid));
|
|
}
|
|
set
|
|
{
|
|
memLayer.ML.setSessionVal(string.Format("UDC_{0}", uid), value, memLayer.ML.confReadBool("keepParticolareSel"));
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// Recupera descrizione e disegno dato un particolare
|
|
/// </summary>
|
|
/// <param name="CodParticolare"></param>
|
|
/// <param name="descr"></param>
|
|
/// <param name="disegno"></param>
|
|
public virtual void getDescrDisegnoParticolare(string CodParticolare, ref string descr, ref string disegno)
|
|
{
|
|
try
|
|
{
|
|
DS_magazzino.AnagParticolariRow riga = MagClass.magazzino.taAnagPart.likeSearch(CodParticolare, CodCs)[0];
|
|
descr = riga.DescParticolare;
|
|
disegno = string.Format("( {0} )", riga.DisegnoGrezzo);
|
|
}
|
|
catch
|
|
{ }
|
|
}
|
|
/// <summary>
|
|
/// effettua controlli visibilità
|
|
/// </summary>
|
|
public virtual void doChecks()
|
|
{
|
|
checkBarcode();
|
|
checkStampa();
|
|
checkParticolare();
|
|
}
|
|
/// <summary>
|
|
/// controllo l'abilitazione alla stampa UDC:
|
|
/// - particolare ok
|
|
/// - qta > 0
|
|
/// - udc da consumo totale/parziale
|
|
/// altrimenti disabilito btn stampa
|
|
/// </summary>
|
|
public virtual void checkStampa()
|
|
{ }
|
|
/// <summary>
|
|
/// controlla particolare selezionato
|
|
/// </summary>
|
|
public virtual void checkParticolare()
|
|
{ }
|
|
/// <summary>
|
|
/// valore barcode
|
|
/// </summary>
|
|
public virtual string barcodeIn
|
|
{
|
|
get
|
|
{
|
|
return "";
|
|
}
|
|
set
|
|
{ }
|
|
}
|
|
/// <summary>
|
|
/// valore barcode
|
|
/// </summary>
|
|
public virtual DateTime lastCall
|
|
{
|
|
get
|
|
{
|
|
DateTime answ = DateTime.Now.AddHours(-1);
|
|
try
|
|
{
|
|
if (memLayer.ML.isInSessionObject(string.Format("lastCall_", uid)))
|
|
{
|
|
answ = memLayer.ML.DateTimeSessionObj(string.Format("lastCall_", uid));
|
|
}
|
|
}
|
|
catch
|
|
{ }
|
|
return answ;
|
|
}
|
|
set
|
|
{
|
|
memLayer.ML.setSessionVal(string.Format("lastCall_", uid), value);
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// valore barcode
|
|
/// </summary>
|
|
public virtual string lastBarcodeIn
|
|
{
|
|
|
|
get
|
|
{
|
|
return memLayer.ML.StringSessionObj(string.Format("lastBarcode_{0}", uid));
|
|
}
|
|
set
|
|
{
|
|
memLayer.ML.setSessionVal(string.Format("lastBarcode_{0}", uid), value, false);
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// verifico se ci sia in sessione un input da NumKeyb e nel caso lo metto in barcodeIn e processo...
|
|
/// </summary>
|
|
public virtual void checkNumKeyIn()
|
|
{
|
|
if (memLayer.ML.isInSessionObject("numKeyIn"))
|
|
{
|
|
barcodeIn = memLayer.ML.StringSessionObj("numKeyIn");
|
|
// svuoto valore in sessione...
|
|
memLayer.ML.emptySessionVal("numKeyIn");
|
|
// controllo barcode...
|
|
checkBarcode();
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// cod imballo dell'ultimo UDC del particolare generato
|
|
/// </summary>
|
|
public virtual string lastCodImb
|
|
{
|
|
get
|
|
{
|
|
string answ = "";
|
|
try
|
|
{
|
|
answ = MagClass.magazzino.taCartellini.getLastByParticolareStato(CodCs, currParticolare, statoUDC, false)[0].CodImballo;
|
|
}
|
|
catch
|
|
{
|
|
answ = CodImballoStd;
|
|
}
|
|
return answ;
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// num pezzi dell'ultimo UDC del particolare generato
|
|
/// </summary>
|
|
public virtual int pezziUdc
|
|
{
|
|
get
|
|
{
|
|
int answ = 0;
|
|
try
|
|
{
|
|
answ = (int)MagClass.magazzino.taCartellini.getLastByParticolareStato(CodCs, currParticolare, statoUDC, false)[0].Qta;
|
|
}
|
|
catch
|
|
{
|
|
answ = QtaImballoStd;
|
|
}
|
|
return answ;
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// qta pezzi TOTALE
|
|
/// </summary>
|
|
public virtual int qta
|
|
{
|
|
get
|
|
{
|
|
return 0;
|
|
}
|
|
set
|
|
{ }
|
|
}
|
|
/// <summary>
|
|
/// Note Utente
|
|
/// </summary>
|
|
public virtual string campoNote
|
|
{
|
|
get
|
|
{
|
|
return "";
|
|
}
|
|
set
|
|
{ }
|
|
}
|
|
/// <summary>
|
|
/// Imballo selezionato
|
|
/// </summary>
|
|
public virtual string imballoSel
|
|
{
|
|
get
|
|
{
|
|
return "";
|
|
}
|
|
set
|
|
{ }
|
|
}
|
|
/// <summary>
|
|
/// Metodo aggiornamento qta
|
|
/// </summary>
|
|
public virtual void aggiornaQta()
|
|
{
|
|
MagClass.magazzino.taCartellini.updateQty(currUDC, MagClass.magazzino.CodSoggCurrUser, "U", eventoUDC_qta, qta);
|
|
currUDC = "";
|
|
currParticolare = "";
|
|
}
|
|
/// <summary>
|
|
/// effettua reset dati
|
|
/// </summary>
|
|
public virtual void doResetData()
|
|
{
|
|
// resetto i dati QtaTot e particolare...
|
|
qta = 0;
|
|
currParticolare = "";
|
|
doChecks();
|
|
}
|
|
/// <summary>
|
|
/// verifica se attivo filtro company e imposta ods di conseguenza...
|
|
/// </summary>
|
|
public virtual void checkFixOds()
|
|
{
|
|
}
|
|
/// <summary>
|
|
/// aggiorna tabella + focus a barcode
|
|
/// </summary>
|
|
public virtual void doUpdate()
|
|
{
|
|
idxCella = Postazione.currIdxCella;
|
|
destAL = AlByCella;
|
|
setVisibility();
|
|
checkStampa();
|
|
// altri step in versione specifica
|
|
}
|
|
/// <summary>
|
|
/// imposto i dati dal particolare corrente
|
|
/// </summary>
|
|
public virtual void impostaParticolare()
|
|
{
|
|
// controllo esista il particolare scansionato
|
|
if (DataProxy.obj.taAnagParticolari.getByParticolare(currParticolare).Rows.Count == 0)
|
|
{
|
|
currParticolare = "";
|
|
Postazione.messaggiText += " - codice particolare non valido / non trovato in RILPRO.";
|
|
Postazione.CssClass = cssErr;
|
|
}
|
|
else
|
|
{
|
|
Postazione.messaggiText += " - impostato particolare!";
|
|
Postazione.CssClass = cssOk;
|
|
}
|
|
// leggo la qta dell'ultimo UDC del particolare, SE C'E', e la imposto...
|
|
if (pezziUdc > 0)
|
|
{
|
|
qta = pezziUdc;
|
|
}
|
|
else // rimette default
|
|
{
|
|
qta = memLayer.ML.cdvi("QtaImballoFiniti");
|
|
}
|
|
selezionaImballo();
|
|
}
|
|
/// <summary>
|
|
/// metodo stub selezione imballo
|
|
/// </summary>
|
|
public virtual void selezionaImballo()
|
|
{
|
|
try
|
|
{
|
|
if (lastCodImb != "")
|
|
{
|
|
if (!trySetImballo(lastCodImb))
|
|
{
|
|
// preseleziono
|
|
imballoSel = CodImballoStd;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// preseleziono
|
|
imballoSel = CodImballoStd;
|
|
}
|
|
}
|
|
catch
|
|
{ }
|
|
}
|
|
/// <summary>
|
|
/// determina se sia possibile cancellare un record, se qta > 0
|
|
/// </summary>
|
|
/// <param name="_qta"></param>
|
|
/// <returns></returns>
|
|
public virtual bool canDelete(object _qta)
|
|
{
|
|
bool answ = false;
|
|
try
|
|
{
|
|
answ = Convert.ToInt32(_qta) == 0;
|
|
}
|
|
catch
|
|
{ }
|
|
return answ;
|
|
}
|
|
/// <summary>
|
|
/// fornisce in output la corretta classe css x icona
|
|
/// </summary>
|
|
/// <param name="qta"></param>
|
|
/// <returns></returns>
|
|
public virtual string cssGlyphByQty(object _qta)
|
|
{
|
|
string answ = "fa fa-pencil";
|
|
int qtaUDC = 0;
|
|
try
|
|
{
|
|
qtaUDC = Convert.ToInt32(_qta);
|
|
}
|
|
catch { }
|
|
if (qtaUDC > 0)
|
|
{
|
|
answ = "fa fa-print";
|
|
}
|
|
return answ;
|
|
}
|
|
/// <summary>
|
|
/// calcola il codice imballo da ultimo oppure da DB/webconfig
|
|
/// </summary>
|
|
/// <param name="confBaseVal"></param>
|
|
/// <returns></returns>
|
|
public virtual string codImballo(string confBaseVal)
|
|
{
|
|
string answ = "";
|
|
// cerco se c'è un imballo x particolare corrente...
|
|
if (currParticolare != "")
|
|
{
|
|
answ = lastCodImb;
|
|
}
|
|
else
|
|
{
|
|
answ = memLayer.ML.cdv(confBaseVal);
|
|
}
|
|
return answ;
|
|
}
|
|
/// <summary>
|
|
/// effettua consumo UDC
|
|
/// </summary>
|
|
/// <param name="oldUdc"></param>
|
|
public virtual void consumaUdc(string oldUdc)
|
|
{
|
|
// se UDC è NON vuoto ed esiste
|
|
if (oldUdc != "" && MagClass.magazzino.checkUDC(oldUdc))
|
|
{
|
|
// se è consumabile (IdxPosizione > 0)...
|
|
if (MagClass.magazzino.udcMpIsConsumabile(oldUdc))
|
|
{
|
|
// consumo UDC
|
|
MagClass.magazzino.scaricaUdcMpWip(oldUdc, Request.UserHostName);
|
|
}
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// effettua refresh (su db) del blocco postazione
|
|
/// </summary>
|
|
/// <param name="codLinea"></param>
|
|
public virtual void refreshBloccoPost(string codLinea)
|
|
{
|
|
// resetto usi linee precedenti..
|
|
MagClass.magazzino.taAL.resetPost(Postazione.name);
|
|
// se la linea non è "base" = "Sel linea", finisce x "0"
|
|
if (codLinea.Substring(codLinea.Length - 1) != "0")
|
|
{
|
|
// salvo su DB che sto occupando linea...
|
|
MagClass.magazzino.taAL.updatePost(codLinea, Postazione.name);
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
|
|
#region area metodi interazione controlli
|
|
|
|
/// <summary>
|
|
/// update Qty x UDC selezionato...
|
|
/// </summary>
|
|
/// <param name="sender"></param>
|
|
/// <param name="e"></param>
|
|
public virtual void lbtUpdQty_Click(object sender, EventArgs e)
|
|
{
|
|
aggiornaQta();
|
|
}
|
|
/// <summary>
|
|
/// Imposta ultima quantità rilevata
|
|
/// </summary>
|
|
/// <param name="sender"></param>
|
|
/// <param name="e"></param>
|
|
public virtual void lbtSetLastQty_Click(object sender, EventArgs e)
|
|
{
|
|
// indico ultima qta
|
|
qta = pezziUdc;
|
|
// salvo!!!
|
|
aggiornaQta();
|
|
}
|
|
/// <summary>
|
|
/// reset della selezione
|
|
/// </summary>
|
|
/// <param name="sender"></param>
|
|
/// <param name="e"></param>
|
|
public virtual void btnReset_Click(object sender, EventArgs e)
|
|
{
|
|
qta = 0;
|
|
currUDC = "";
|
|
currParticolare = "";
|
|
setVisibility();
|
|
doUpdate();
|
|
}
|
|
/// <summary>
|
|
/// evento cambio qta
|
|
/// </summary>
|
|
/// <param name="sender"></param>
|
|
/// <param name="e"></param>
|
|
public virtual void txtQta_TextChanged(object sender, EventArgs e)
|
|
{
|
|
aggiornaQta();
|
|
}
|
|
|
|
public virtual void grView_PageIndexChanged(object sender, EventArgs e)
|
|
{
|
|
// fix dell'ODS
|
|
checkFixOds();
|
|
}
|
|
public virtual void grViewSource_PageIndexChanged(object sender, EventArgs e)
|
|
{
|
|
// fix dell'ODS
|
|
checkFixOds();
|
|
}
|
|
|
|
public virtual void grView_Sorted(object sender, EventArgs e)
|
|
{
|
|
// fix dell'ODS
|
|
checkFixOds();
|
|
}
|
|
/// <summary>
|
|
/// aggiorno ods al binding..
|
|
/// </summary>
|
|
/// <param name="sender"></param>
|
|
/// <param name="e"></param>
|
|
public virtual void ods_DataBinding(object sender, EventArgs e)
|
|
{
|
|
// fix dell'ODS
|
|
checkFixOds();
|
|
}
|
|
/// <summary>
|
|
/// svuoto le note
|
|
/// </summary>
|
|
/// <param name="sender"></param>
|
|
/// <param name="e"></param>
|
|
public virtual void btnEmptyNote_Click(object sender, EventArgs e)
|
|
{
|
|
campoNote = "";
|
|
Postazione.messaggiText = traduci("AttesaBCode");
|
|
Postazione.warningText = "";
|
|
Postazione.CssClass = cssAtt;
|
|
// raise dell'evento
|
|
raiseEvent(ucEvType.ReqUpdateParent);
|
|
}
|
|
/// <summary>
|
|
/// preseleziono (se possibile) imballo...
|
|
/// </summary>
|
|
/// <param name="sender"></param>
|
|
/// <param name="e"></param>
|
|
public virtual void ddlImballi_DataBound(object sender, EventArgs e)
|
|
{
|
|
if (!Page.IsPostBack)
|
|
{
|
|
selezionaImballo();
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// sistemazione labels, traduzioni e valori default oggetti
|
|
/// </summary>
|
|
public virtual void traduciObj()
|
|
{
|
|
// txtBox
|
|
qta = memLayer.ML.cdvi("QtaImballoFiniti");
|
|
}
|
|
|
|
/// <summary>
|
|
/// controlla se ci sia un barcode
|
|
/// </summary>
|
|
public virtual void checkBarcode()
|
|
{
|
|
if (barcodeIn != "")
|
|
{
|
|
Postazione.messaggiText = string.Format("Barcode digitato: {0}", barcodeIn);
|
|
Postazione.warningText = "";
|
|
switch (MagClass.tipoBCode_L3(barcodeIn))
|
|
{
|
|
case tipoCodiceBarcode.Comando:
|
|
if (barcodeIn == memLayer.ML.cdv("cmdReset"))
|
|
{
|
|
currParticolare = "";
|
|
Response.Redirect(PagCorrente);
|
|
}
|
|
break;
|
|
case tipoCodiceBarcode.Imballo:
|
|
trySetImballo(barcodeIn);
|
|
break;
|
|
case tipoCodiceBarcode.Particolare:
|
|
if (enableBCodeParticolare)
|
|
{
|
|
// imposto il particolare corrente
|
|
currParticolare = barcodeIn;
|
|
origParticolare = barcodeIn;
|
|
impostaParticolare();
|
|
}
|
|
else
|
|
{
|
|
Postazione.messaggiText += traduci("ErrBcd_PartDisabled");
|
|
Postazione.CssClass = cssWait;
|
|
}
|
|
break;
|
|
case tipoCodiceBarcode.UDC:
|
|
processBCodeUdc();
|
|
// update
|
|
doUpdate();
|
|
break;
|
|
case tipoCodiceBarcode.Operatore:
|
|
// calcolo matricola utente
|
|
int MatrUtente = -1;
|
|
string preCodSogg = memLayer.ML.cdv("prefCodSogg");
|
|
if (barcodeIn.StartsWith(preCodSogg))
|
|
{
|
|
MatrUtente = DataProxy.obj.taTrascSogg.getByKey(barcodeIn, 0)[0].CodMatricola;
|
|
}
|
|
else
|
|
{
|
|
MatrUtente = Convert.ToInt32(barcodeIn);
|
|
}
|
|
if (MatrUtente >= 0)
|
|
{
|
|
// salvo in sessione operatore con AUTH
|
|
OpAuth.startOpAuth(MatrUtente);
|
|
// mostro che ho autorizzato...
|
|
Postazione.messaggiText += traduci("userAuthRec");
|
|
Postazione.CssClass = cssOk;
|
|
Response.Redirect(user_std.pagCorrente);
|
|
}
|
|
else
|
|
{
|
|
Postazione.messaggiText += " - codice <b>non riconosciuto</b>!";
|
|
Postazione.CssClass = cssWait;
|
|
}
|
|
break;
|
|
default:
|
|
// cerco se sia "0" = reset utente...
|
|
if (barcodeIn == memLayer.ML.CRS("resetCodSogg"))
|
|
{
|
|
// salvo in sessione operatore con AUTH
|
|
OpAuth.stopAuth();
|
|
// mostro che ho autorizzato...
|
|
Postazione.messaggiText += traduci("userAuthRem");
|
|
Postazione.CssClass = cssOk;
|
|
Response.Redirect(user_std.pagCorrente);
|
|
}
|
|
Postazione.messaggiText += " - codice <b>non riconosciuto</b>!";
|
|
Postazione.CssClass = cssWait;
|
|
break;
|
|
}
|
|
barcodeIn = "";
|
|
lastBarcodeIn = "-";
|
|
}
|
|
else
|
|
{
|
|
if (string.IsNullOrEmpty(lastBarcodeIn))
|
|
{
|
|
Postazione.messaggiText = traduci("AttesaBCode");
|
|
Postazione.warningText = "";
|
|
Postazione.CssClass = cssAtt;
|
|
}
|
|
lastBarcodeIn = "";
|
|
}
|
|
doUpdate();
|
|
}
|
|
/// <summary>
|
|
/// Pre-processing di un barcode tipo UDC
|
|
/// </summary>
|
|
public virtual void processBCodeUdc()
|
|
{
|
|
// se linea non selezionata ERRORE!!!
|
|
if (Postazione.currCodLinea == codLineaKo)
|
|
{
|
|
Postazione.messaggiText += " - Attenzione, IMPOSTARE LINEA!";
|
|
Postazione.CssClass = cssErr;
|
|
}
|
|
else
|
|
{
|
|
// procedo solo se UDC esistente
|
|
if (MagClass.magazzino.checkUDC(barcodeIn))
|
|
{
|
|
// controllo se NON ci siano NC "pending"
|
|
if (MagClass.magazzino.checkUDC_NC(barcodeIn) != checkUdcNc.HasNc)
|
|
{
|
|
string tipoLinea = "";
|
|
if (Postazione.currNomeLinea.IndexOf("GRZ") >= 0)
|
|
{
|
|
tipoLinea = "GRZ";
|
|
}
|
|
else if (Postazione.currNomeLinea.IndexOf("LVT") >= 0)
|
|
{
|
|
tipoLinea = "LVT";
|
|
}
|
|
else if (Postazione.currNomeLinea.IndexOf("FSC") >= 0)
|
|
{
|
|
tipoLinea = "FSC";
|
|
}
|
|
else if (Postazione.currNomeLinea.IndexOf("LM - ") >= 0)
|
|
{
|
|
tipoLinea = "LM";
|
|
}
|
|
else if (Postazione.currNomeLinea.IndexOf("LS - ") >= 0)
|
|
{
|
|
tipoLinea = "LS";
|
|
}
|
|
else
|
|
{
|
|
tipoLinea = "ND";
|
|
}
|
|
/********************************************************************
|
|
* procedo per UDC in ingresso:
|
|
* - deve essere di tipo IN
|
|
* - se NON c'è UDC in AL dest a pari particolare LO CREO
|
|
* - se c'era già UDC per lo stesso particolare --> consumo (il vecchio)
|
|
* - associo UDC letto ad UDC in AL dest a pari particolare
|
|
*
|
|
********************************************************************/
|
|
|
|
// controllo IdxPosizione dell'UDC e confronto con posizione in webconfig x trattati (pre lavorazioni meccaniche)
|
|
int IdxPosizione = DataProxy.obj.taCartellini.stp_getByUdc(barcodeIn)[0].IdxPosizione;
|
|
if (IdxPosizione == IdxPosizioneIn)
|
|
{
|
|
// calcolo nuovo particolare
|
|
origParticolare = DataProxy.obj.taCartellini.stp_getByUdc(barcodeIn)[0].Particolare;
|
|
|
|
// verifico che il particolare NON SIA in veto...
|
|
if (checkPartVetoByLinea(origParticolare))
|
|
{
|
|
Postazione.messaggiText += $" - Attenzione, PARTICOLARE {origParticolare} NON ATTIVATO / NON PERMESSO sulla LINEA!";
|
|
Postazione.CssClass = "stileComandoKo";
|
|
}
|
|
else
|
|
{
|
|
// chiamo sempre stored x recuperare GRZ da GRZ (solo alcuni) o LVT da GRZ o LVT da LVT (supercubati)
|
|
// calcolo particolare OUT da Distinta Base
|
|
string partOut = "";
|
|
MagClass.magazzino.taPartIO.particolareLVTFromGRZ(tipoLinea, origParticolare, CodCs, ref partOut);
|
|
currParticolare = partOut;
|
|
// continuo controlli
|
|
if (currParticolare != "")
|
|
{
|
|
|
|
int idxCellaCurr = 0;
|
|
try
|
|
{
|
|
idxCellaCurr = MagClass.magazzino.taPosUdcCorr.getByUDC(barcodeIn)[0].IdxCella;
|
|
}
|
|
catch
|
|
{ }
|
|
string codBloccoCurr = "";
|
|
int idxBlocco = 0;
|
|
try
|
|
{
|
|
idxBlocco = MagClass.magazzino.taCelle.getByIdxCella(idxCellaCurr)[0].IdxBlocco;
|
|
codBloccoCurr = MagClass.magazzino.taBlocchi.getByIdx(idxBlocco)[0].CodBlocco;
|
|
}
|
|
catch
|
|
{ }
|
|
// 2015.01.12 controllo UDC non già su altre postazioni...
|
|
if (codBloccoCurr == Postazione.currCodBlocco && idxCellaCurr != Postazione.currIdxCella)
|
|
{
|
|
Postazione.messaggiText += " - Attenzione, UDC già caricato su ALTRA LINEA!";
|
|
Postazione.CssClass = cssErr;
|
|
}
|
|
else
|
|
{
|
|
processUdcInOut(idxCellaCurr, false, true);
|
|
}
|
|
}
|
|
else // non trovo part LVT
|
|
{
|
|
Postazione.messaggiText += traduci("ERR-LVT-001");
|
|
Postazione.CssClass = cssErr;
|
|
}
|
|
}
|
|
}
|
|
// controllo SE PER CASO ci fosse NC e ci sia stata deroga, cambio MSG...
|
|
if (MagClass.magazzino.checkUDC_NC(barcodeIn) == checkUdcNc.ChkDis_HasNc)
|
|
{
|
|
Postazione.CssClass = cssErr;
|
|
Postazione.messaggiText += string.Format("<br />{0}", traduci("ERR-NC-001"));
|
|
// recupero l'NC associata...
|
|
Postazione.warningText += string.Format("<br />{0}", MagClass.magazzino.getDescrNc2Udc(barcodeIn));
|
|
}
|
|
}
|
|
else
|
|
{
|
|
Postazione.CssClass = cssErr;
|
|
Postazione.messaggiText += string.Format("<br />{0}", traduci("ERR-NC-001"));
|
|
// recupero l'NC associata...
|
|
Postazione.warningText += string.Format("<br />{0}", MagClass.magazzino.getDescrNc2Udc(barcodeIn));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// Processa UDC nuovo (eventualmente creando) e vecchio (eventualmente consumando)
|
|
/// </summary>
|
|
/// <param name="idxCellaCurr"></param>
|
|
/// <param name="forceMove">Forza lo spostamento a idxCella corrente...</param>
|
|
/// <param name="createUdcOut">indica se si debba creare UDC in uscita se mancasse...</param>
|
|
/// <returns></returns>
|
|
public virtual void processUdcInOut(int idxCellaCurr, bool forceMove, bool createUdcOut)
|
|
{
|
|
verificaAssociaUdcParentChild(barcodeIn, forceMove, createUdcOut);
|
|
// controllo se UDC non sia già stato spostato in posizione... dsMagazzino, posizUdcCorrente, getByUdc
|
|
if (idxCellaCurr == Postazione.currIdxCella)
|
|
{
|
|
Postazione.messaggiText += " - Attenzione, UDC già caricato!";
|
|
Postazione.CssClass = cssErr;
|
|
}
|
|
else
|
|
{
|
|
// verifico per eventuale consumo vecchio UDC... cerco nella posizione
|
|
DS_magazzino.v_UdcDetailDataTable tabUdcDet = null;
|
|
try
|
|
{
|
|
// cerco nella posizione
|
|
tabUdcDet = MagClass.magazzino.taDettUDC.getUdcDetailByIdxCella(idxCella);
|
|
}
|
|
catch
|
|
{ }
|
|
// carico UDC letto in cella...
|
|
DateTime adesso = DateTime.Now;
|
|
string noteTrim = Postazione.currNomeLinea;
|
|
// cerco se NON ci sia l'UDC letto...
|
|
if (tabUdcDet.Select(string.Format("UDC = '{0}'", barcodeIn)).Length == 0)
|
|
{
|
|
processUdcOut(tabUdcDet, adesso, noteTrim);
|
|
}
|
|
Postazione.CssClass = cssOk;
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// verifica se ci sia udcDest, se necessario crea ed associa a parent, e restituisce udcDest
|
|
/// </summary>
|
|
/// <param name="udcParent">UDC Parent</param>
|
|
/// <param name="forceMove">Forza lo spostamento a idxCella corrente...</param>
|
|
/// <param name="createUdcOut">indica se si debba creare UDC in uscita se mancasse...</param>
|
|
/// <returns></returns>
|
|
public string verificaAssociaUdcParentChild(string udcParent, bool forceMove, bool createUdcOut)
|
|
{
|
|
// controllo SE esista già UDC in AL dest... altrimenti CREO!!!
|
|
string udcDest = checkCreaUDC(forceMove, createUdcOut);
|
|
if (udcDest != "")
|
|
{
|
|
// verifico che NON SIA GIA' associato...
|
|
bool udcGiaAssociato = false;
|
|
try
|
|
{
|
|
udcGiaAssociato = MagClass.magazzino.checkAssociazioneUdcParent(udcDest, udcParent);
|
|
}
|
|
catch
|
|
{ }
|
|
if (!udcGiaAssociato)
|
|
{
|
|
// associo UDC con quello di destinazione SE NECESSARIO
|
|
MagClass.magazzino.associaUdcParent(udcDest, udcParent, true);
|
|
}
|
|
}
|
|
return udcDest;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Processing del vecchio UDC (eventualmente consumando)
|
|
/// </summary>
|
|
/// <param name="tabUdcDet"></param>
|
|
/// <param name="adesso"></param>
|
|
/// <param name="noteTrim"></param>
|
|
public virtual void processUdcOut(DS_magazzino.v_UdcDetailDataTable tabUdcDet, DateTime adesso, string noteTrim)
|
|
{
|
|
string oldUdc = "";
|
|
try
|
|
{
|
|
oldUdc = ((DS_magazzino.v_UdcDetailRow)tabUdcDet.Select(string.Format("Particolare = '{0}' AND IdxPosizione = {1}", origParticolare, IdxPosizioneIn))[0]).UDC;
|
|
}
|
|
catch
|
|
{ }
|
|
// se trovo un altro UDC dello stesso particolare...
|
|
if (oldUdc != "")
|
|
{
|
|
// consumo UDC
|
|
consumaUdc(oldUdc);
|
|
}
|
|
// se ho cod cella sposto UDC in nuova posizione!
|
|
MagClass.magazzino.spostaUDC(CodCs, barcodeIn, Postazione.currIdxCella, memLayer.ML.CRB("spostaUdcResettaLdp"), Request.UserHostName);
|
|
// registro spostamento UDC
|
|
MagClass.magazzino.taSAO.insertQuery(adesso, MagClass.magazzino.CodSoggCurrUser, Postazione.name, Postazione.IP, barcodeIn, currParticolare, "spostaUDC", string.Format("Caricato UDC {3} su linea {2}, qta: {0} {1} ", qta, noteTrim, Postazione.currCodLinea, tipoUdcLinea));
|
|
}
|
|
|
|
/// <summary>
|
|
/// segnaposto gestione creazione opzionale UDC
|
|
/// </summary>
|
|
/// <param name="forceMove">Forza lo spostamento a idxCella corrente...</param>
|
|
/// <param name="createUdcOut">indica se si debba creare UDC in uscita se mancasse...</param>
|
|
public virtual string checkCreaUDC(bool forceMove, bool createUdcOut)
|
|
{
|
|
string udcDest = "";
|
|
bool checkDone = true;
|
|
DateTime adesso = DateTime.Now;
|
|
MagClass geMag = new MagClass();
|
|
// verifico se ho già quel particolare tra quelli dell'AL...
|
|
try
|
|
{
|
|
DS_magazzino.ElencoCartelliniDataTable tabCart;
|
|
if (memLayer.ML.CRB("disable_singleton"))
|
|
{
|
|
tabCart = geMag.taCartellini.getByParticolareAL(currParticolare, destAL);
|
|
}
|
|
else
|
|
{
|
|
tabCart = MagClass.magazzino.taCartellini.getByParticolareAL(currParticolare, destAL);
|
|
}
|
|
if (tabCart.Rows.Count > 0)
|
|
{
|
|
udcDest = tabCart[0].UDC;
|
|
}
|
|
}
|
|
catch (Exception exc)
|
|
{
|
|
checkDone = false;
|
|
logger.lg.scriviLog(string.Format("Errore in ricerca UDC DEST x UDC temp {2}: {0}{1}", Environment.NewLine, exc, tipoUdcLinea));
|
|
udcDest = "";
|
|
}
|
|
if (createUdcOut && checkDone)
|
|
{
|
|
if (string.IsNullOrEmpty(udcDest))
|
|
{
|
|
try
|
|
{
|
|
// creo nuovo UDC FI... in posizione TEMP e con un evento differente...
|
|
if (memLayer.ML.CRB("disable_singleton"))
|
|
{
|
|
udcDest = geMag.creaUdc(flusso, "", currParticolare, "", "", "", "", "", 0, lastCodImb, "U", MagClass.magazzino.CodSoggCurrUser, qta, 0, 0, adesso, 0, statoUDC, IdxPosizioneOutTemp, IdxPosizioneOutTempName, eventoUDC, "", "", adesso.Year, Request.UserHostName);
|
|
// associo UDC a AL...
|
|
geMag.taAL2UDC.Insert(destAL, udcDest, adesso, MagClass.magazzino.CodSoggCurrUser);
|
|
}
|
|
else
|
|
{
|
|
udcDest = MagClass.magazzino.creaUdc(flusso, "", currParticolare, "", "", "", "", "", 0, lastCodImb, "U", MagClass.magazzino.CodSoggCurrUser, qta, 0, 0, adesso, 0, statoUDC, IdxPosizioneOutTemp, IdxPosizioneOutTempName, eventoUDC, "", "", adesso.Year, Request.UserHostName);
|
|
// associo UDC a AL...
|
|
MagClass.magazzino.taAL2UDC.Insert(destAL, udcDest, adesso, MagClass.magazzino.CodSoggCurrUser);
|
|
}
|
|
if (forceMove)
|
|
{
|
|
if (memLayer.ML.CRB("disable_singleton"))
|
|
{
|
|
// se UDC NON in cella corrente lo sposto in nuova posizione!
|
|
geMag.spostaUDC(CodCs, udcDest, Postazione.currIdxCella, memLayer.ML.CRB("spostaUdcResettaLdp"), Request.UserHostName);
|
|
}
|
|
else
|
|
{
|
|
// se UDC NON in cella corrente lo sposto in nuova posizione!
|
|
MagClass.magazzino.spostaUDC(CodCs, udcDest, Postazione.currIdxCella, memLayer.ML.CRB("spostaUdcResettaLdp"), Request.UserHostName);
|
|
}
|
|
}
|
|
}
|
|
catch (Exception exc)
|
|
{
|
|
logger.lg.scriviLog(string.Format("Errore in creazione UDC temp {2}: {0}{1}", Environment.NewLine, exc, tipoUdcLinea));
|
|
}
|
|
}
|
|
if (udcDest != "")
|
|
{
|
|
Postazione.CssClass = cssAtt;
|
|
Postazione.warningText = "";
|
|
Postazione.messaggiText = traduci("partAdded");
|
|
}
|
|
else
|
|
{
|
|
Postazione.CssClass = cssErr;
|
|
Postazione.warningText = traduci("ErroreUdcDest");
|
|
}
|
|
}
|
|
return udcDest;
|
|
}
|
|
/// <summary>
|
|
/// tenta di impostare l'imballo al valore indicato altrimenti mostra errore
|
|
/// </summary>
|
|
/// <param name="valore"></param>
|
|
public virtual bool trySetImballo(string valore)
|
|
{
|
|
bool fatto = false;
|
|
// cerco di selezionare!
|
|
try
|
|
{
|
|
imballoSel = valore;
|
|
fatto = true;
|
|
}
|
|
catch
|
|
{
|
|
Postazione.warningText = traduci("ERR-IMB-001");
|
|
Postazione.CssClass = cssErr;
|
|
}
|
|
return fatto;
|
|
}
|
|
/// <summary>
|
|
/// segnaposto gestione button stampa
|
|
/// <param name="sender"></param>
|
|
/// <param name="e"></param>
|
|
public virtual void btnStampa_Click(object sender, EventArgs e)
|
|
{
|
|
bool needsRedirect = false;
|
|
string[] stringSeparators = new string[] { "#" };
|
|
// verifico postazione x procedere...
|
|
if (Postazione.printer != "n.d.")
|
|
{
|
|
// verifico auth utente OPPURE se NON sia richiesta...
|
|
if (OpAuth.isAuth || !OpAuth.opAuthReq)
|
|
{
|
|
DateTime adesso = DateTime.Now;
|
|
// effettuo controlli che cod_soggetto, cod particolare e destAL siano disponibili...
|
|
if (MagClass.magazzino.CodSoggCurrUser != "" && currParticolare != "" && destAL != "ALF00")
|
|
{
|
|
string codImballo = "";
|
|
try
|
|
{
|
|
codImballo = imballoSel;
|
|
}
|
|
catch
|
|
{
|
|
codImballo = CodImballoStd;
|
|
}
|
|
// se NON HA selezionato prendo default...
|
|
if (string.IsNullOrEmpty(codImballo) || codImballo == "-")
|
|
{
|
|
codImballo = CodImballoStd;
|
|
}
|
|
string noteCompl = string.Format("{0}{1}{2}", Postazione.currNomeLinea, Environment.NewLine, campoNote);
|
|
try
|
|
{
|
|
// aggiorno note e posizione da temp a definitivo x UDC...
|
|
MagClass.magazzino.updateNotePosizioneDataImballoUDC(currUDC, noteCompl, IdxPosizioneOut, DateTime.Now, codImballo);
|
|
if (OpAuth.isAuth)
|
|
{
|
|
// salvo attributo dell'OpAuth...
|
|
MagClass.magazzino.taAtt2UDC.Insert(currUDC, memLayer.ML.CRS("attrOpAuth"), OpAuth.currAuth.CodSoggetto, DateTime.Now, MagClass.magazzino.CodSoggCurrUser);
|
|
// consumo una auth...
|
|
OpAuth.currAuth.remAuth--;
|
|
if (OpAuth.currAuth.remAuth == 0)
|
|
{
|
|
OpAuth.stopAuth();
|
|
needsRedirect = true;
|
|
}
|
|
}
|
|
}
|
|
catch (Exception exc)
|
|
{
|
|
httpLog(string.Format("Errore creazione UDC {0}:{1}{2}", tipoUdcLinea, Environment.NewLine, exc), tipoLog.EXCEPTION);
|
|
}
|
|
|
|
// tolgo UDC da AL corrente...
|
|
MagClass.magazzino.taAL2UDC.deleteQuery(destAL, currUDC);
|
|
|
|
// ora stampo il nuovo cartellino nel formato impostato
|
|
MagClass.magazzino.stampaUdc(currUDC, Postazione.printer, tipoCartCurr, Request.UserHostName);
|
|
// incremento timing...
|
|
adesso = adesso.AddSeconds(2);
|
|
// registro stampa nuovo UDC
|
|
MagClass.magazzino.taSAO.insertQuery(adesso, MagClass.magazzino.CodSoggCurrUser, Postazione.name, Postazione.IP, currUDC, currParticolare, "stampaUDC", "Stampato UDC FINITO");
|
|
|
|
// 2016.06.15 modifica per creare subito un NUOVO UDC connesso a quello in origine... QTA 0 !!!
|
|
string udcParent = "";
|
|
// recupero parent... ULTIMO (descending)
|
|
try
|
|
{
|
|
udcParent = MagClass.magazzino.getUdcParentDesc(currUDC);
|
|
}
|
|
catch
|
|
{ }
|
|
// controllo che sia DAVVERO caricato UDC parent...
|
|
string oldUdc = "";
|
|
// verifico per eventuale consumo vecchio UDC... cerco nella posizione
|
|
DS_magazzino.v_UdcDetailDataTable tabUdcDet = null;
|
|
try
|
|
{
|
|
// cerco nella posizione
|
|
tabUdcDet = MagClass.magazzino.taDettUDC.getUdcDetailByIdxCella(idxCella);
|
|
}
|
|
catch
|
|
{ }
|
|
try
|
|
{
|
|
oldUdc = ((DS_magazzino.v_UdcDetailRow)tabUdcDet.Select(string.Format("UDC = '{0}'", udcParent))[0]).UDC;
|
|
}
|
|
catch
|
|
{ }
|
|
// PROCEDO SOLO SE HO UN UDC IN INGRESSO!!!
|
|
if (udcParent != "" && oldUdc != "")
|
|
{
|
|
// CREO NUOVO UDC!!!
|
|
string udcDest = "";
|
|
udcDest = checkCreaUDC(false, true);
|
|
// associo UDC con quello di destinazione
|
|
MagClass.magazzino.associaUdcParent(udcDest, udcParent, true);
|
|
// registro creazione nuovo UDC
|
|
MagClass.magazzino.taSAO.insertQuery(adesso, MagClass.magazzino.CodSoggCurrUser, Postazione.name, Postazione.IP, currUDC, currParticolare, "creaUDC", string.Format("Creato ed associato nuovo UDC {3} con codice {2}, qta: {0}, UDC Parent: {1}", qta, udcParent, udcDest, tipoUdcLinea));
|
|
}
|
|
// resetto
|
|
doResetData();
|
|
}
|
|
else
|
|
{
|
|
httpLog(string.Format("FINITI, Errore persi utente/particolare, ricarico!"), tipoLog.ERROR);
|
|
Response.Redirect("~/login.aspx");
|
|
}
|
|
}
|
|
else
|
|
{
|
|
Postazione.messaggiText = traduci("noOpAuth");
|
|
Postazione.warningText = "";
|
|
Postazione.CssClass = cssErr;
|
|
httpLog(string.Format("Errore manca OpAuth x UDC {0}", tipoUdcLinea), tipoLog.ERROR);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
Response.Redirect("~/menu.aspx");
|
|
}
|
|
doUpdate();
|
|
// raise dell'evento
|
|
raiseEvent(ucEvType.ReqUpdateParent);
|
|
if (needsRedirect)
|
|
{
|
|
Response.Redirect(user_std.pagCorrente);
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
}
|
|
}
|