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
  }
}