using GMW_data;
using SteamWare;
using System;
using System.Web.UI;
using System.Web.UI.WebControls;

namespace GMW.WebUserControls
{
  /// <summary>
  /// Pagina finiti DT
  /// </summary>
  public partial class mod_PostFin_DT : GMW_data.UserControlBCodeMan
  {
#if false
    /// <summary>
    /// Oggetto locale gestione classe datamatrix...
    /// </summary>
    protected DataMatrix DataMatrix_mgr = new DataMatrix();  
#endif
    /// <summary>
    /// Imposta variabili specifiche classe
    /// </summary>
    public override void setupVariabili()
    {
      flusso = "FI";
      flussoAnc = "TT";
      // temporaneo TL (Trattati/Liquidi)
      flussoTemp = "TL";
      statoUDC = "Fin";
      statoUDC_pre = "Tratt";
      eventoUDC = "UDC_TL_DT"; //UDC_FINWIP ???
      eventoUDC_qta = "UDC_QTY";
      eventoUDC_temp = "UDC_TRATT";
      codLineaKo = "W8200";
      QtaImballoStd = memLayer.ML.cdvi("QtaImballoFiniti");
      CodImballoStd = memLayer.ML.cdv("CodImballoFiniti");
      sVarIdxCella = "IdxCellaLineaFinitiDtx";
      IdxPosizioneIn = memLayer.ML.cdvi("IdxPosizioneTrattati");
      IdxPosizioneOut = memLayer.ML.cdvi("IdxPosizioneFiniti");


      tipoUdcLinea = "Finito";
      IdxPosizioneOutTempName = "IdxPosizioneFinTemp";
      IdxPosizioneOutTemp = memLayer.ML.cdvi(IdxPosizioneOutTempName);
      tipoCartCurr = tipoCartellino.cartFiniti;
      enableBCodeParticolare = false;
    }
    /// <summary>
    /// Codice AL in carico
    /// </summary>
    public override string sourceAL
    {
      get
      {
        return lblAL.Text.Trim();
      }
      set
      {
        lblAL.Text = value;
      }
    }
    /// <summary>
    /// Codice AL della cella corrente
    /// </summary>
    public override string destAL
    {
      get
      {
        return lblDestAL.Text.Trim();
      }
      set
      {
        lblDestAL.Text = value;
      }
    }
    /// <summary>
    /// qta pezzi x UDC
    /// </summary>
    public override int qta
    {
      get
      {
        int qta = 0;
        try
        {
          qta = Convert.ToInt32(txtQta.Text.Trim());
        }
        catch
        { }
        return qta;
      }
      set
      {
        txtQta.Text = value.ToString();
      }
    }
    /// <summary>
    /// valore barcode
    /// </summary>
    public override string barcodeIn
    {
      get
      {
        return txtBarcode.Text.Trim();
      }
      set
      {
        txtBarcode.Text = value;
      }
    }
    /// <summary>
    /// caricamento pagina
    /// </summary>
    /// <param name="sender"></param>
    /// <param name="e"></param>
    public override void Page_Load(object sender, EventArgs e)
    {
      // inizializzazione base!
      base.Page_Load(sender, e);
      // inizializzazione custom...
      if (!Page.IsPostBack)
      {
        currUDC = "";
        forceDelete = false;
        setDefaultVal();
        grViewSource.DataBind();
      }
    }
    /// <summary>
    /// imposta i valori di default all'avvio
    /// </summary>
    private void setDefaultVal()
    {
      sourceAL = currAL != "" ? currAL : "";
      destAL = AlByCella;
    }
    /// <summary>
    /// Sistema css del panel AL
    /// </summary>
    /// <param name="tipoPanel"></param>
    private void fixCssAL(string tipoPanel)
    {
      divAL.Attributes.Remove("class");
      divAL.Attributes.Add("class", string.Format("panel panel-{0} small", tipoPanel));
    }
    /// <summary>
    /// sistema modalità input
    /// </summary>
    public override void setVisibility()
    {
      bool showBtn = false;
      bool onPrinting = divImballi.Visible;
      if (sourceAL != "" && string.IsNullOrEmpty(currAL))
      {
        showBtn = true;
        fixCssAL("warning");
      }
      else
      {
        fixCssAL("success");
      }
      // ora controllo btn quantità
      showBtn = false;
      if (grViewDest.SelectedIndex >= 0)
      {
        showBtn = true;
      }
      divQta.Visible = showBtn;
      divImballi.Visible = showBtn;
      // se btn stampa già visibile NON devo riselezionare...
      if (showBtn && !onPrinting)
      {
        selezionaImballo();
      }
    }
    /// <summary>
    /// reset maschera...
    /// </summary>
    protected void doReset()
    {
      // resetta
      fixCssAL("warning");
      lastBarcodeIn = "";
      Postazione.messaggiText = "";
      Postazione.warningText = "";
      Postazione.CssClass = cssAtt;
      doUpdate();
    }
    /// <summary>
    /// Verifica l'AL se sia ok x procedere:
    /// - Attivo
    /// </summary>
    /// <param name="AL"></param>
    /// <param name="Tipo">T/L</param>
    /// <returns></returns>
    protected bool checkAL(string AL, string tipo)
    {
      bool answ = false;
      try
      {
        answ = MagClass.magazzino.taEA.getByAL_TipoAttivo(AL, tipo).Rows.Count > 0;
      }
      catch
      { }
      if (answ)
      {
        Postazione.warningText = "";
        Postazione.CssClass = cssOk;
      }
      else
      {
        Postazione.warningText = traduci("ErroreAlNonTtAttivo");
        Postazione.CssClass = cssErr;
      }

      return answ;
    }
    /// <summary>
    /// Verifica l'AL se abbia datamatrix
    /// </summary>
    /// <param name="AL"></param>
    /// <returns></returns>
    protected bool checkDtxAL(string AL)
    {
      bool answ = false;
      try
      {
        answ = DataMatrix_mgr.taDtx2UDC.getByAL(AL).Rows.Count > 0;
      }
      catch
      { }
      if (!answ)
      {
        Postazione.warningText = traduci("ErroreAlNonDtx");
        Postazione.CssClass = cssErr;
      }
      else
      {
        Postazione.warningText = "";
        Postazione.CssClass = cssOk;
      }
      return answ;
    }
    /// <summary>
    /// Recupera num trattamento da UDC
    /// </summary>
    /// <param name="UDC"></param>
    /// <returns></returns>
    public string trattUdc(object UDC)
    {
      string answ = "";
      try
      {
        DS_magazzino.Attr2UDCRow riga = (DS_magazzino.Attr2UDCRow)MagClass.magazzino.taAtt2UDC.getByUdc(UDC.ToString()).Select("CodAttr = 'NT'")[0];
        answ = riga.ValAttr;
      }
      catch
      { }
      return answ;
    }
    /// <summary>
    /// controlla se ci sia un barcode e cosa farne...
    /// </summary>
    public override void checkBarcode()
    {
      if (barcodeIn != "")
      {
        if (barcodeIn != lastBarcodeIn)
        {
          Postazione.messaggiText = string.Format("{0}: {1}", traduci("BCodeIns"), barcodeIn);
          tipoCodiceBarcode tipoBC = MagClass.tipoBCode_L5(barcodeIn);
          // per prima cosa se non ho almeno un UDC trattamenti od un AL (che ne porti uno) sollevo un errore...
          int numUdcCella = 0;
          DS_magazzino.v_UdcDetailDataTable tabUdcIn = new DS_magazzino.v_UdcDetailDataTable();
          try
          {
            tabUdcIn = MagClass.magazzino.taDettUDC.getUdcDetailByIdxCellaIdxPosizione(idxCella, IdxPosizioneIn);
            numUdcCella = tabUdcIn.Rows.Count;
          }
          catch
          { }
          if (tipoBC == tipoCodiceBarcode.ND)
          {
            // sollevo errore, in primis va caricato qualche UDC sorgente...
            Postazione.warningText = traduci("ERR-BCD-001");
            Postazione.CssClass = cssErr;
            sendUpdateTablet("ND", "-", traduci("ERR-UDC-MIS-TT01"), "-", "-", "-", cssErr, cssErr, cssErr);
          }
          else if (numUdcCella == 0 && !(tipoBC == tipoCodiceBarcode.AL || tipoBC == tipoCodiceBarcode.UDC))
          {
            // sollevo errore, in primis va caricato qualche UDC sorgente...
            Postazione.warningText = traduci("ERR-UDC-MIS-TT01");
            Postazione.CssClass = cssErr;
            sendUpdateTablet("ND", "-", traduci("ERR-UDC-MIS-TT01"), "-", "-", "-", cssErr, cssErr, cssErr);
          }
          else
          {
            switch (tipoBC)
            {
              case tipoCodiceBarcode.Imballo:
                // cerco di selezionare!
                try
                {
                  ddlImballi.SelectedValue = barcodeIn;
                }
                catch
                {
                  Postazione.warningText = traduci("ERR-IMB-001");
                  Postazione.CssClass = cssErr;
                }
                break;
              case tipoCodiceBarcode.Comando:
                // se è reset cancello tutto!
                if (barcodeIn == memLayer.ML.cdv("cmdReset"))
                {
                  doReset();
                }
                break;
              case tipoCodiceBarcode.UDC:
                // controllo di avere destAL valido, sennò ricarico pagina...
                if (destAL.Length <= 5)
                {
                  //Postazione.messaggiText = "";
                  Postazione.warningText = traduci("ERR-ALF-001");
                  Postazione.CssClass = cssErr;
                }
                else
                {
                  // controllo se sia un UDC valido...
                  if (!MagClass.magazzino.checkUDC(barcodeIn))

                  {
                    //Postazione.messaggiText = "";
                    Postazione.warningText = traduci("ERR-LIQ-003");
                    Postazione.CssClass = cssErr;
                  }
                  else
                  {
                    // recupero UDC!
                    DS_magazzino.ElencoCartelliniRow cartUDC = MagClass.magazzino.taCartellini.getByUdc(barcodeIn)[0];
                    // verifico che il particolare dell'UDC sia compatibile con i formati datamatrix permessi sulla linea...
                    if (FormatoDtmxPartic(cartUDC.Particolare) != FormatoDtmxLinea)
                    {
                      Postazione.warningText = traduci("ERR-UDC-DTX-001");
                      Postazione.CssClass = cssErr;
                    }
                    else
                    {
                      // verifico UDC in ingresso NON abbia DTX associati
                      int numDtx = DataMatrix_mgr.taDtx2UDC.getByUDC(barcodeIn).Count;
                      if (numDtx > 0 && cartUDC.CodStato == statoUDC_pre)
                      {
                        Postazione.warningText = traduci("ERR-UDC-DTX-002");
                        Postazione.CssClass = cssErr;
                      }
                      else
                      {
                        // verifico stato (statoUdc/statoUdc_pre) e posizioni (IdxPosizioneIn/IdxPosizioneOut): tratt a sx da consumare, fin a dx da stampare/ricaricare...
                        if (cartUDC.CodStato == statoUDC_pre && cartUDC.IdxPosizione == IdxPosizioneIn)
                        {
                          // verifico che abbia attributo trattamento
                          int numTratt = MagClass.magazzino.taAtt2UDC.getByUdc(barcodeIn).Select("CodAttr = 'NT'").Length;
                          if (numTratt == 0)
                          {
                            Postazione.warningText = traduci("ERR-UDC-DTX-003");
                            Postazione.CssClass = cssErr;
                          }
                          else
                          {
                            currParticolare = cartUDC.Particolare;
                            origParticolare = cartUDC.Particolare;
                            // procedo a caricare UDC a SX, eventualmente consumando precedente...
                            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
                              {
                                // disattivo AL sorgente!
                                try
                                {
                                  sourceAL = MagClass.magazzino.taAL2UDC.getByUDC(barcodeIn)[0].AL;
                                  MagClass.magazzino.taEA.DisattivaAL(sourceAL);
                                }
                                catch
                                { }
                                // imposto qta STD...
                                qta = maxQta;
                                // processo (eventualmente creando UDC...)
                                processUdcInOut(idxCellaCurr, true, false);
                              }
                            }
                          }
                        }
                        else if (cartUDC.CodStato == statoUDC && cartUDC.IdxPosizione == IdxPosizioneOut)
                        {
                          // in primis verifico CI SIA almeno 1 udc sulla cella IN
                          if (numUdcCella == 0)
                          {
                            // errore: devo avere UDC IN (trattati)
                            Postazione.warningText = traduci("ERR-UDC-MIS-TT02");
                            Postazione.CssClass = cssErr;
                            sendUpdateTablet("ND", "-", traduci("ERR-UDC-MIS-TT02"), "-", "-", "-", cssErr, cssErr, cssErr);
                          }
                          else
                          {
                            bool partOk = true;
                            // recupero elenco UDC in uscita...
                            DS_magazzino.v_A2U2DDataTable tab = MagClass.magazzino.taA2U2D.getByAL(destAL);
                            // verifico se ci siano dello stesso particolare
                            if (tab.Select(string.Format("Particolare='{0}'", cartUDC.Particolare)).Length > 0)
                            {
                              partOk = false;
                            }
                            // se UDC dello STESSO particolare già caricato NON posso procedere...
                            if (!partOk)
                            {
                              Postazione.warningText = traduci("ERR-UDC-DTX-007");
                              Postazione.CssClass = cssErr;
                            }
                            else
                            {
                              // ricarico UDC SOLO SE ha già attributo "BL"
                              if (!MagClass.magazzino.udcHasAttr(barcodeIn, "BL"))
                              //int trovato = MagClass.magazzino.taAtt2UDC.getByUdc(barcodeIn).Select("CodAttr = 'BL'").Length;
                              //if (trovato < 1)
                              {
                                Postazione.warningText = traduci("ERR-UDC-DTX-008");
                                Postazione.CssClass = cssErr;
                              }
                              else
                              {
                                // verifico particolare letto con particolare già sulla linea (a SX) che DEVE esserci
                                if (tabUdcIn.Select(string.Format("Particolare = '{0}'", cartUDC.Particolare)).Length == 0)
                                {
                                  // errore particolare...
                                  Postazione.warningText = traduci("ERR-UDC-DTX-006");
                                  Postazione.CssClass = cssErr;
                                  sendUpdateTablet("ND", "-", traduci("ERR-UDC-DTX-006"), "-", "-", "-", cssErr, cssErr, cssErr);
                                }
                                else
                                {
                                  bool fatto = MagClass.magazzino.liquidiRiprendiInCaricoUDC(barcodeIn, MagClass.magazzino.CodSoggCurrUser, destAL, Postazione.currIdxCella);
                                  if (fatto)
                                  {
                                    Postazione.messaggiText = traduci("UDC-FIN-REL");
                                    Postazione.warningText = "";
                                    Postazione.CssClass = cssOk;
                                    checkUpdateTablet(barcodeIn);
                                  }
                                  else
                                  {
                                    //Postazione.messaggiText = "";
                                    Postazione.warningText = traduci("ERR-UDC-DTX-010");
                                    Postazione.CssClass = cssErr;
                                    sendUpdateTablet("ND", "-", traduci("ERR-UDC-DTX-010"), "-", "-", "-", cssErr, cssErr, cssErr);
                                  }
                                }
                              }
                            }
                          }
                        }
                        else
                        {
                          bool udcCaricato = false;
                          DS_magazzino.v_A2U2DDataTable tab = MagClass.magazzino.taA2U2D.getByAL(destAL);
                          if (tab.Select(string.Format("UDC = '{0}'", barcodeIn)).Length > 0)
                          {
                            udcCaricato = true;
                          }
                          // se è già in posizione indico già caricato...
                          if (udcCaricato)
                          {
                            Postazione.warningText = traduci("ERR-UDC-DTX-007");
                          }
                          else
                          {
                            Postazione.warningText = traduci("ERR-LIQ-002");
                          }
                          Postazione.CssClass = cssErr;
                        }
                      }
                    }
                  }
                }
                break;
              case tipoCodiceBarcode.DataMatrixTrovato:
                Postazione.messaggiText = barcodeIn;
                string udcDest = "";
                string parentUdc = "";
                string testoLog = "";
                // verifica preliminare: se OK procedo, se è KO NON LO CONSIDERO PROPRIO
                bool isOk = false;
                try
                {
                  isOk = DataMatrix_mgr.taVerifica.GetData(barcodeIn)[0].StatoDtx == "OK";
                }
                catch
                { }
                if (!isOk)
                {
                  // non accetto Dtx e mostro errore
                  Postazione.warningText = traduci("ERR-DTX-012");
                  Postazione.CssClass = cssErr;
                  if (logLevel > 7)
                  {
                    testoLog = string.Format("{0} | {1}", barcodeIn, Postazione.warningText);
                    logger.lg.scriviLog(testoLog, tipoLog.INFO);
                  }
                }
                else
                {
                  // verifico NON sia associato ad ALCUN UDC
                  bool dtxFree = false;
                  bool dtxInDestAL = false;
                  try
                  {
                    dtxFree = DataMatrix_mgr.taDtx2UDC.getByDtx(barcodeIn).Count == 0;
                  }
                  catch (Exception exc)
                  {
                    string.Format("Errore in check dtxFree per {0} | {1}", barcodeIn, exc);
                    logger.lg.scriviLog(testoLog, tipoLog.EXCEPTION);
                  }
                  try
                  {
                    dtxInDestAL = DataMatrix_mgr.taDtx2UDC.getByDtxAl(destAL, barcodeIn).Rows.Count == 1;
                  }
                  catch (Exception exc)
                  {
                    string.Format("Errore in check dtxInDestAL per {0} | {1}", barcodeIn, exc);
                    logger.lg.scriviLog(testoLog, tipoLog.EXCEPTION);
                  }
                  if (!dtxFree && !dtxInDestAL)
                  {
                    Postazione.warningText = traduci("ERR-DTX-017");
                    Postazione.CssClass = cssErr;
                    if (logLevel > 7)
                    {
                      testoLog = string.Format("{0} | {1}", barcodeIn, Postazione.warningText);
                      logger.lg.scriviLog(testoLog, tipoLog.INFO);
                    }
                  }
                  else
                  {
                    // verifico particolare UDC == particolare DTX
                    string partDtx = "";
                    try
                    {
                      partDtx = DataMatrix_mgr.taDtxAcq.getByKey(barcodeIn)[0].Particolare;
                    }
                    catch (Exception exc)
                    {
                      string.Format("Errore in check partDtx per {0} | {1}", barcodeIn, exc);
                      logger.lg.scriviLog(testoLog, tipoLog.EXCEPTION);
                    }
                    bool partOk = false;
                    // cerco se ci sia un UDC trattati con quel particolare...
                    try
                    {
                      if (tabUdcIn.Select(string.Format("Particolare='{0}'", partDtx)).Length > 0)
                      {
                        partOk = true;
                        currParticolare = partDtx;
                        parentUdc = ((DS_magazzino.v_UdcDetailRow)tabUdcIn.Select(string.Format("Particolare='{0}'", partDtx))[0]).UDC;
                      }
                    }
                    catch (Exception exc)
                    {
                      string.Format("Errore in check parentUdc per {0} | {1}", barcodeIn, exc);
                      logger.lg.scriviLog(testoLog, tipoLog.EXCEPTION);
                    }
                    if (!partOk)
                    {
                      Postazione.warningText = traduci("ERR-UDC-DTX-004");
                      Postazione.CssClass = cssErr;
                      if (logLevel > 7)
                      {
                        testoLog = string.Format("{0} | {1}", barcodeIn, Postazione.warningText);
                        logger.lg.scriviLog(testoLog, tipoLog.INFO);
                      }
                    }
                    else
                    {
                      DateTime adesso = DateTime.Now;
                      if (currParticolare != "")
                      {
                        try
                        {
                          udcDest = MagClass.magazzino.taCartellini.getByParticolareAL(currParticolare, destAL)[0].UDC;
                        }
                        catch
                        {
                          udcDest = "";
                        }
                        if (string.IsNullOrEmpty(udcDest))
                        {
                          // crea UDC DEST...
                          qta = maxQta;

                          udcDest = verificaAssociaUdcParentChild(parentUdc, true, true);
                        }
                        else
                        {
                          verificaAssociaUdcParentChild(parentUdc, false, false);
                        }
                        procDtx(udcDest);
                        checkUpdateTablet(udcDest);
                      }
                      else
                      {
                        Postazione.warningText = traduci("UdcNonTrovato");
                        Postazione.CssClass = cssErr;
                      }
                    }
                  }
                }
                break;
              default:
                Postazione.warningText = traduci("ERR-BCD-001");
                Postazione.CssClass = cssErr;
                break;
            }
          }
        }
        lastBarcodeIn = barcodeIn;
        barcodeIn = "";
      }
      else
      {
        lastBarcodeIn = "";
      }
      doUpdate();
    }

    #region metodi processing DataMatrix letto da BarCode

    /// <summary>
    /// max quantità da anagrafica...
    /// </summary>
    public int maxQta
    {
      get
      {
        int answ = 0;
        // calcola qtaMax da particoalre corrente...
        try
        {
          answ = DataProxy.obj.taAnagPartImb.getByStatoParticolare(CodCs, statoUDC, currParticolare)[0].QtaStd;
        }
        catch
        { }
        return answ;
      }
    }
    /// <summary>
    /// processo DTX...
    /// </summary>
    /// <param name="udcDest"></param>
    /// <returns></returns>
    private bool procDtx(string udcDest)
    {
      bool fatto = false;
      // verifico se sia modalità "rimozione" datamatrix x cui tolgo i datamatrix dall'UDC finale..
      if (chkDtxMode.Checked)
      {
        // verifico che sia nell'AL DEST x poter rimuovere...
        if (DataMatrix_mgr.taDtx2UDC.getByDtxAl(destAL, barcodeIn).Rows.Count != 1)
        {
          Postazione.warningText = traduci("ERR-DTX-018");
          Postazione.CssClass = cssAtt;
        }
        else
        {
          // elimino associazione DTX e UDC dest...
          DataMatrix_mgr.taDtx2UDC.deleteQuery(udcDest, barcodeIn, MagClass.magazzino.CodSoggCurrUser, IdxPosizioneOut, Postazione.currIdxCella);
          fatto = true;
          Postazione.messaggiText += " " + traduci("DtxRem");
          Postazione.warningText = "";
          Postazione.CssClass = cssAtt;
        }
      }
      else
      {
        // verifico qtaMax NON sia superata...
        if (MagClass.magazzino.taA2U2D.getByUDC(udcDest)[0].QtaDtx >= maxQta)
        {
          Postazione.warningText = traduci("ERR-UDC-DTX-005");
          Postazione.CssClass = cssErr;
        }
        else
        {
          // verifico che NON sia nell'AL DEST x poter aggiungere...
          if (DataMatrix_mgr.taDtx2UDC.getByDtxAl(destAL, barcodeIn).Rows.Count == 1)
          {
            Postazione.warningText = traduci("ERR-DTX-006");
            Postazione.CssClass = cssAtt;
          }
          else
          {
            // se lo trovo chiamo procedura di spostamento Dtx tra UDC sorgente --> dest (con eventuale creazione dest)
            DataMatrix_mgr.taDtx2UDC.UpdateUDC(udcDest, barcodeIn, statoUDC, DateTime.Now, MagClass.magazzino.CodSoggCurrUser, false, false);
            // fix messaggi
            Postazione.messaggiText += " " + traduci("ConfermatoDtx");
            Postazione.warningText = "";
            Postazione.CssClass = cssAtt;
            fatto = true;
          }
        }
      }
      return fatto;
    }

    #endregion

    /// <summary>
    /// aggiorna tabella + focus a barcode
    /// </summary>
    public override void doUpdate()
    {
      base.doUpdate();
      setDefaultVal();
      grViewSource.DataBind();
      grViewDest.DataBind();
      raiseEvent(ucEvType.ReqUpdateParent);
      verificaBtnStampa();
      txtBarcode.Focus();
    }
    /// <summary>
    /// traduce gli header delle colonne
    /// </summary>
    /// <param name="sender"></param>
    /// <param name="e"></param>
    protected void grViewSource_DataBound(object sender, EventArgs e)
    {
      if (grViewSource.Rows.Count > 0)
      {
        LinkButton lb;
        // aggiorno gli headers        
        foreach (TableCell cella in grViewSource.HeaderRow.Cells)
        {
          try
          {
            lb = (LinkButton)cella.Controls[0];
            lb.Text = traduci(lb.Text);
          }
          catch
          { }
        }
        int totRecord = grViewSource.Rows.Count + grViewSource.PageSize * (grViewSource.PageCount - 1);
        lblNumRec.Text = string.Format("{0} records of ~ {1}", grViewSource.Rows.Count, totRecord);
      }
      else
      {
        lblNumRec.Text = "";
      }
    }
    /// <summary>
    /// qui la selezione è x scaricare...
    /// </summary>
    /// <param name="sender"></param>
    /// <param name="e"></param>
    protected void grViewSource_SelectedIndexChanged(object sender, EventArgs e)
    {
      consumaUdc(grViewSource.SelectedValue.ToString());
      doUpdate();
    }
    /// <summary>
    /// evento selezione grView destinazione: ricarico dati!
    /// </summary>
    /// <param name="sender"></param>
    /// <param name="e"></param>
    protected void grViewDest_SelectedIndexChanged(object sender, EventArgs e)
    {
      // ricarico dati dell'UDC come particolare e quantità...
      currUDC = grViewDest.SelectedDataKey["UDC"].ToString();
      int qtaDtx = 0;
      if (MagClass.magazzino.checkUDC(currUDC))
      {
        DS_Applicazione.ElencoCartelliniRow rigaUDC = DataProxy.obj.taCartellini.stp_getByUdc(currUDC)[0];
        //currParticolare = DataProxy.obj.taCartellini.stp_getByUdc(currUDC)[0].Particolare;
        //qta = Convert.ToInt32(DataProxy.obj.taCartellini.stp_getByUdc(currUDC)[0].Qta);
        //qtaDtx = Convert.ToInt32(MagClass.magazzino.taA2U2D.getByUDC(currUDC)[0].QtaDtx);
        currParticolare = rigaUDC.Particolare;
        qta = Convert.ToInt32(rigaUDC.Qta);
        qtaDtx = Convert.ToInt32(MagClass.magazzino.taA2U2D.getByUDC(currUDC)[0].QtaDtx);
        // imposto particolare...
        lblPart.Text = currParticolare;
        ddlImballi.DataBind();
        selezionaImballo();
      }
      Postazione.messaggiText = traduci("partSelected");
      Postazione.warningText = "";
      Postazione.CssClass = cssOk;
      setVisibility();
      doUpdate();
      // fisso focus su note!
      txtNote.Focus();
      checkUpdateTablet(currUDC);
    }
    /// <summary>
    /// effettua check e update tablet
    /// </summary>
    /// <param name="UDC"></param>
    private void checkUpdateTablet(string UDC)
    {
      if (memLayer.ML.confReadBool("updateTablet"))
      {
        try
        {
          string particolare = "";
          int qtaDtx = 0;
          int qtaTot = 0;
          if (MagClass.magazzino.checkUDC(UDC))
          {
            DS_Applicazione.ElencoCartelliniRow riga = DataProxy.obj.taCartellini.stp_getByUdc(UDC)[0];
            particolare = string.Format("{0} - {1}", riga.Particolare, riga.DescParticolare);
            qtaTot = Convert.ToInt32(DataProxy.obj.taCartellini.stp_getByUdc(UDC)[0].Qta);
            qtaDtx = Convert.ToInt32(MagClass.magazzino.taA2U2D.getByUDC(UDC)[0].QtaDtx);
          }
          // update tablet
          string css = "";
          string mess = "";
          if (qtaDtx > qtaTot)
          {
            css = cssErr;
            mess = traduci("ERR-QTY-001");
          }
          else if (qtaDtx == qtaTot)
          {
            css = cssOk;
            mess = traduci("Ready4Print");
          }
          else
          {
            css = cssWait;
            mess = "-";
          }
          sendUpdateTablet(UDC, particolare, mess, qtaDtx.ToString(), qtaTot.ToString(), string.Format("({0})", qtaDtx - qtaTot), cssOk, cssAtt, css);
        }
        catch (Exception exc)
        {
          logger.lg.scriviLog(string.Format("Errore in fase di check dati x tablet: {0}{1}", Environment.NewLine, exc));
        }
      }
    }
    /// <summary>
    /// variabile force delete salvata...
    /// </summary>
    protected bool forceDelete
    {
      get
      {
        return memLayer.ML.BoolSessionObj(string.Format("ForceDelAL_{0}", uid));
      }
      set
      {
        memLayer.ML.setSessionVal(string.Format("ForceDelAL_{0}", uid), value);
      }
    }
    /// <summary>
    /// Verifica se Assieme sia vuoto (no DTX negli UDC)
    /// </summary>
    /// <param name="AL">Codice AL</param>
    /// <returns></returns>
    protected bool assiemeIsEmpty(string AL)
    {
      bool answ = false;
      try
      {
        answ = DataMatrix_mgr.taDtx2UDC.getByAL(AL).Rows.Count == 0;
      }
      catch { }
      return answ;
    }
    /// <summary>
    /// reset della selezione
    /// </summary>
    /// <param name="sender"></param>
    /// <param name="e"></param>
    public override void btnReset_Click(object sender, EventArgs e)
    {
      grViewDest.SelectedIndex = -1;
      base.btnReset_Click(sender, e);
    }
    /// <summary>
    /// update Qty x UDC selezionato...
    /// </summary>
    /// <param name="sender"></param>
    /// <param name="e"></param>
    public override void lbtUpdQty_Click(object sender, EventArgs e)
    {
      base.lbtUpdQty_Click(sender, e);
      // fix tablet
      checkUpdateTablet(currUDC);
      grViewDest.SelectedIndex = -1;
      doUpdate();
    }
    /// <summary>
    /// Metodo aggiornamento qta    
    /// </summary>
    public override void aggiornaQta()
    {
      // verifico NON sia superata la quantità MAX permessa...
      qta = qta > maxQta ? maxQta : qta;
      // eseguo metodo base!
      base.aggiornaQta();
    }
    /// <summary>
    /// verifica visibilità btn stampa UDC
    /// </summary>
    private void verificaBtnStampa()
    {
      bool showBtnStampa = false;
      // se ho selezionato udc...
      if (currUDC != "")
      {
        DS_magazzino.v_A2U2DRow riga;
        int qtaUDC = 0;
        int qtaDtx = 0;
        try
        {
          riga = MagClass.magazzino.taA2U2D.getByUDC(currUDC)[0];
          qtaUDC = Convert.ToInt32(riga.Qta);
          qtaDtx = riga.QtaDtx;
        }
        catch
        { }
        if (qtaUDC > 0)
        {
          // se le qta voluta e dtx sono uguali...
          if (qtaUDC == qtaDtx)
          {
            showBtnStampa = true;
          }
        }
      }
      divNote.Visible = showBtnStampa;
    }
    /// <summary>
    /// fornisce in output la corretta classe css x icona
    /// </summary>
    /// <param name="qta"></param>
    /// <param name="qtaDtx"></param>
    /// <returns></returns>
    public string cssGlyphByQty(object _qta, object _qtaDtx)
    {
      string answ = "fa fa-pencil fa-2x";
      int qtaUDC = 0;
      int qtaDtx = -1;
      try
      {
        qtaUDC = Convert.ToInt32(_qta);
      }
      catch { }
      try
      {
        qtaDtx = Convert.ToInt32(_qtaDtx);
      }
      catch { }
      if (qtaUDC == qtaDtx)
      {
        answ = "fa fa-print fa-2x";
      }
      return answ;
    }
    /// <summary>
    /// effettua processo di sistemazione UDC e stampa
    /// </summary>
    /// <param name="sender"></param>
    /// <param name="e"></param>
    protected void lbtStampaUDC_Click(object sender, EventArgs e)
    {
      bool needsRedirect = false;
      // verifico postazione sia valida...
      if (Postazione.name != "" && Postazione.IP != "")
      {
        string codImballo = "";
        try
        {
          codImballo = imballoSel;
        }
        catch
        {
          codImballo = CodImballoStd;
        }
        // se NON HA selezionato prendo default...
        if (string.IsNullOrEmpty(codImballo) || codImballo == "-")
        {
          codImballo = CodImballoStd;
        }
        // in base ad AL sorgente e destinazione, fa le operazioni di update x UDC e poi lo stampa
        bool fatto = false;
        string noteTrim = txtNote.Text.Trim();
        try
        {
          // update UDC!
          MagClass.magazzino.updateFinDtxFull(currUDC, noteTrim, DateTime.Now, codImballo, destAL);
          fatto = true;
        }
        catch (Exception exc)
        {
          logger.lg.scriviLog(string.Format("Errore in stampa UDC FIN DT:{0}{1}", Environment.NewLine, exc));
        }
        if (fatto)
        {
          // lancio stampa
          MagClass.magazzino.stampaUdc(currUDC, Postazione.printer, tipoCartellino.cartFinitiSP, Request.UserHostName);
          // registro creazione AL
          MagClass.magazzino.taSAO.insertQuery(DateTime.Now, MagClass.magazzino.CodSoggCurrUser, Postazione.name, Postazione.IP, currUDC, currParticolare, "stampaUDC", string.Format("Stampato UDC Dtx {0} su linea {1}, note: {2} ", currUDC, Postazione.currCodLinea, noteTrim));
          Postazione.CssClass = cssAtt;
          Postazione.warningText = "";
          Postazione.messaggiText = traduci("cartUDCStampato");
          // calcolo particolare completo di descrizione
          DS_Applicazione.ElencoCartelliniRow riga = DataProxy.obj.taCartellini.stp_getByUdc(currUDC)[0];
          string particolare = string.Format("{0} - {1}", riga.Particolare, riga.DescParticolare);
          // indico su tablet come fatto
          sendUpdateTablet(currUDC, particolare, traduci("cartUDCStampato"), qta.ToString(), qta.ToString(), "", cssOk, cssOk, cssOk);
          // resetto...
          grViewDest.SelectedIndex = -1;
          qta = 0;
          currUDC = "";
        }
        doUpdate();
      }
      else
      {
        // ricarico che mi manca postazione!
        Postazione.CssClass = cssAtt;
        Postazione.warningText = traduci("ERR-POS-001");
        Postazione.messaggiText = "";
        needsRedirect = true;
      }
      doUpdate();
      // raise dell'evento
      raiseEvent(ucEvType.ReqUpdateParent);
      if (needsRedirect)
      {
        Response.Redirect(user_std.pagCorrente);
      }
    }
    /// <summary>
    /// Effettua update della pagina tablet RT collegata alla postazione liquidi
    /// </summary>
    /// <param name="UDC"></param>
    /// <param name="particolare"></param>
    /// <param name="mess"></param>
    /// <param name="qtaIn"></param>
    /// <param name="qtaTot"></param>
    /// <param name="qtaRim"></param>
    /// <param name="css1"></param>
    /// <param name="css2"></param>
    /// <param name="css3"></param>
    protected void sendUpdateTablet(string UDC, string particolare, string mess, string qtaIn, string qtaTot, string qtaRim, string css1, string css2, string css3)
    {
      if (memLayer.ML.confReadBool("updateTablet"))
      {
        try
        {
          string answ = SteamWare.urlUtils.callUrl(string.Format(@"{0}/MBC.aspx?txt01={1}&txt02={2}&txt03={3}&txt04={4}&txt05={5}&txt06={6}&css1={7}&css2={8}&css3={9}", memLayer.ML.confReadString("urlRT"), UDC, particolare, mess, qtaIn, qtaTot, qtaRim, css1, css2, css3), false);
        }
        catch (Exception exc)
        {
          logger.lg.scriviLog(string.Format("Errore in chiamata a pagina Tablet: {0}{1}", Environment.NewLine, exc));
          barcodeIn = "";
        }
      }
    }
    /// <summary>
    /// Imposta e legge imballo selezionato
    /// </summary>
    public override string imballoSel
    {
      get
      {
        return ddlImballi.SelectedValue;
      }
      set
      {
        ddlImballi.SelectedValue = value;
      }
    }
  }
}