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

namespace GMW.WebUserControls
{
  public partial class mod_elencoListePrelievo : SteamWare.ApplicationUserControl
  {
    /// <summary>
    /// Oggetto locale gestione classe datamatrix...
    /// </summary>
    protected DataMatrix DataMatrix_mgr = new DataMatrix();
    #region area da NON modificare

    #region area protected

    protected string _idxGridView;
    protected string _idxGridViewExt;
    protected string _tabCache;
    protected bool _showNewBtn = false;

    /// <summary>
    /// imposta errore non cancellabilità per record correlati
    /// </summary>
    protected void setNoDeletableErrorMessage()
    {
      // mostro avviso di non cancellabilità...
      lblWarning.Text = traduci("notDeletable_hasChild");
      lblWarning.Visible = true;
      grView.DataBind();
    }
    /// <summary>
    /// esegue cancellazioen record
    /// </summary>
    protected void doDelete()
    {
      // posso cancellare...
      lblWarning.Visible = false;
      ods.Delete();
    }
    /// <summary>
    /// Valida la cancellazione per i dati mostrati dal gridView
    /// richiede sia preventivamentedichiarato _idxGridView
    /// </summary>
    /// <param name="sender"></param>
    /// <param name="e"></param>
    protected virtual void validaDelete(object sender, ObjectDataSourceMethodEventArgs e)
    {
      int idx = Convert.ToInt32(e.InputParameters[string.Format("Original_{0}", _idxGridView)]);
      if (objIsNotRelated(idx))
      {
        // annullo cancellazione...
        e.Cancel = true;
        // seleziono record... metto in session valore idx e poi ridisegno...
        SteamWare.memLayer.ML.setSessionVal(_idxGridView, idx);
        setNoDeletableErrorMessage();
      }
      else
      {
        doDelete();
      }
    }

    /// <summary>
    /// recupera i dati di un nuovo record contenuti nel footer di un gridView;
    /// questi devono esses opportunamente nominati (es: txt{0}, dl{0}, ...)
    /// </summary>
    /// <param name="sender"></param>
    /// <param name="e"></param>
    protected void recuperaFooter(object sender, ObjectDataSourceMethodEventArgs e)
    {
      //recupero la riga footer...
      DataColumnCollection colonne = colonneObj();
      string nomeCol;
      string tipoColonna = "";
      foreach (DataColumn colonna in colonne)
      {
        nomeCol = colonna.ColumnName;
        // cerco un textbox o quello che sia...
        if (grView.FooterRow.FindControl(string.Format("txt{0}", nomeCol)) != null)
        {
          tipoColonna = "textBox";
        }
        else if (grView.FooterRow.FindControl(string.Format("dl{0}", nomeCol)) != null)
        {
          tipoColonna = "dropDownList";
        }
        else if (grView.FooterRow.FindControl(string.Format("chk{0}", nomeCol)) != null)
        {
          tipoColonna = "checkBox";
        }
        else if (grView.FooterRow.FindControl(string.Format("selAjax_{0}", nomeCol)) != null)
        {
          tipoColonna = "selAjax";
        }
        // in base al tipo salvo negli inputparameters dell'ODS
        switch (tipoColonna)
        {
          case "textBox":
            e.InputParameters[nomeCol] = ((TextBox)grView.FooterRow.FindControl(string.Format("txt{0}", nomeCol))).Text;
            break;
          case "dropDownList":
            e.InputParameters[nomeCol] = ((DropDownList)grView.FooterRow.FindControl(string.Format("dl{0}", nomeCol))).SelectedValue;
            break;
          case "checkBox":
            e.InputParameters[nomeCol] = ((CheckBox)grView.FooterRow.FindControl(string.Format("chk{0}", nomeCol))).Checked;
            break;
          case "selAjax":
            e.InputParameters[nomeCol] = ((mod_selettore_ajax)grView.FooterRow.FindControl(string.Format("selAjax_{0}", nomeCol))).valore;
            break;
          default:
            break;
        }
        tipoColonna = "";
      }
    }
    /// <summary>
    /// inserisce nuovo valore da footer
    /// </summary>
    /// <param name="sender"></param>
    /// <param name="e"></param>
    protected void lblIns_click(object sender, EventArgs e)
    {
      // click su inserimento, chiamo il metodo insert dell'ObjectDataSource
      ods.Insert();
      SteamWare.memLayer.ML.emptyCacheVal(_tabCache);
    }
    /// <summary>
    /// annulla inserimento nuovo valore da footer
    /// </summary>
    /// <param name="sender"></param>
    /// <param name="e"></param>
    protected void lblCanc_click(object sender, EventArgs e)
    {
      // annullo inserimento: nascondo footer, bind controlli...
      grView.FooterRow.Visible = false;
    }

    /// <summary>
    /// traduce gli header delle colonne
    /// </summary>
    /// <param name="sender"></param>
    /// <param name="e"></param>
    protected void grView_DataBound(object sender, EventArgs e)
    {
      if (grView.Rows.Count > 0)
      {
        LinkButton lb;
        // aggiorno gli headers        
        foreach (TableCell cella in grView.HeaderRow.Cells)
        {
          try
          {
            lb = (LinkButton)cella.Controls[0];
            lb.Text = traduci(lb.Text);
          }
          catch
          { }
        }
        int totRecord = grView.Rows.Count + grView.PageSize * (grView.PageCount - 1);
        lblNumRec.Text = string.Format("{0} records of ~ {1}", grView.Rows.Count, totRecord);
      }
      else
      {
        lblNumRec.Text = "";
      }
    }
    /// <summary>
    /// gestione evento richiesta nuovo valore (mostra footer, ...)
    /// </summary>
    /// <param name="sender"></param>
    /// <param name="e"></param>
    protected void btnNew_Click(object sender, EventArgs e)
    {
      // reset selezione...
      resetSelezione();
      // mostro il footer oppure la riga dei dettagli x nuovo...
      if (grView.FooterRow != null)
      {
        grView.FooterRow.Visible = true;
      }
      // sollevo evento nuovo valore...
      if (eh_nuovoValore != null)
      {
        eh_nuovoValore(this, new EventArgs());
      }
    }
    /// <summary>
    /// reset della selezione
    /// </summary>
    /// <param name="sender"></param>
    /// <param name="e"></param>
    protected void btnReset_Click(object sender, EventArgs e)
    {
      resetSelezione();
    }

    /// <summary>
    /// collega i controlli
    /// </summary>
    protected override void bindControlli()
    {
      base.bindControlli();
      caricaTabelle();
    }

    #endregion

    #region gestione eventi

    //public event EventHandler eh_resetSelezione;
    public event EventHandler eh_nuovoValore;
    //public event EventHandler eh_selValore;

    #endregion

    #region public

    /// <summary>
    /// definisce visibilità btnNew
    /// </summary>
    public bool showNewBtn
    {
      get
      {
        return _showNewBtn;
      }
      set
      {
        _showNewBtn = value;
      }
    }
    /// <summary>
    /// effettua update del modulo
    /// </summary>
    public void doUpdate()
    {
      resetSelezione();
    }


    #endregion

    #endregion

    #region area codice variabile

    /// <summary>
    /// numero righe gridview da mostrare legato a controllo textbox
    /// </summary>
    public int numRigheGrView
    {
      get
      {
        int answ = _righeDataGridMed;
        try
        {
          answ = Convert.ToInt32(txtNumRighe.Text.Trim());
          if (answ == 0)
          {
            answ = _righeDataGridMed;
            txtNumRighe.Text = _righeDataGridMed.ToString();
          }
        }
        catch
        { }
        return answ;
      }
      set
      {
        txtNumRighe.Text = value.ToString();
      }
    }
    /// <summary>
    /// aggiorna controlli datagrid e numero righe in pagina
    /// </summary>
    protected override void aggiornaControlliDataGL()
    {
      base.aggiornaControlliDataGL();
      // indico num righe da controllo
      grView.PageSize = numRigheGrView;
    }
    /// <summary>
    /// carico le tabelle
    /// </summary>
    private void caricaTabelle()
    {
    }
    /// <summary>
    /// verifica complessiva non esistenza record child
    /// </summary>
    /// <param name="idxObj"></param>
    /// <returns></returns>
    protected bool objIsNotRelated(object idxObj)
    {
      bool answ = true;
      return answ;
    }
    /// <summary>
    /// elenco colonne del datagrid
    /// </summary>
    /// <returns></returns>
    protected DataColumnCollection colonneObj()
    {
      DS_magazzino.ElencoListePrelievoDataTable tabella = new DS_magazzino.ElencoListePrelievoDataTable();
      DataColumnCollection colonne = tabella.Columns;
      return colonne;
    }
    /// <summary>
    /// inizializzazione valori di default
    /// </summary>
    /// <param name="e"></param>
    protected override void OnInit(EventArgs e)
    {
      base.OnInit(e);
      _idxGridView = "CodLista";
      if (!Page.IsPostBack)
      {
        // imposto page num...
        numRigheGrView = _righeDataGridMed;
        // continuo setup
        btnForceReload.Text = traduci("ReloadDataMatrix");
        btnForceReload.Visible = memLayer.ML.confReadBool("showReloadDataMatrix");
        setBtnState();
        mod_viewRigheListaPrelievo1.Visible = false;
        mod_selPeriodo1.setPeriodoFree();
        mod_filtroStato.ods = odsFiltroStati;
        mod_filtroTipo.ods = odsTipoLista;
        mod_filtroTipoPart.ods = odsTipoPart;
        // controllo se ci sia richiesta x creare nuova lista, nel caso precompilo valori...
        if (memLayer.ML.BoolSessionObj("PrecompilaListaPrelievo"))
        {
          mod_nuovaListaPrelievo1.Visible = true;
          mod_nuovaListaPrelievo1.ParticolareRichiesto = memLayer.ML.StringSessionObj("Particolare_sel");
          memLayer.ML.emptySessionVal("PrecompilaListaPrelievo");
        }
        else
        {
          mod_nuovaListaPrelievo1.Visible = false;
        }
        pnlSetDestTipo.Visible = false;
      }
      // registro evento update
      mod_viewRigheListaPrelievo1.eh_nuovoValore += new EventHandler(mod_viewRigheListaPrelievo1_eh_nuovoValore);
      mod_selPeriodo1.eh_doUpdate += new EventHandler(mod_periodoAnalisi1_eh_doUpdate);
      mod_nuovaListaPrelievo1.eh_nuovoValore += new EventHandler(mod_nuovaListaPrelievo1_eh_nuovoValore);
    }
    /// <summary>
    /// seleziona/deseleziona le righe indicate...
    /// </summary>
    /// <param name="sender"></param>
    /// <param name="e"></param>
    protected void btnSelAll_Click(object sender, EventArgs e)
    {
      // seleziono tutti i valori visibili nel datagrid
      CheckBox chkbox = ((CheckBox)sender);
      bool isChecked = chkbox.Checked;
      if (!isChecked)
      {
        chkbox.ToolTip = traduci("btnSelAll");
      }
      else
      {
        chkbox.ToolTip = traduci("btnDeselAll");
      }
      foreach (GridViewRow riga in grView.Rows)
      {
        ((CheckBox)riga.FindControl("chkSelect")).Checked = isChecked;
      }
    }
    /// <summary>
    /// mostra oggetti x creare una nuova lista di prelievo
    /// </summary>
    /// <param name="sender"></param>
    /// <param name="e"></param>
    void mod_nuovaListaPrelievo1_eh_nuovoValore(object sender, EventArgs e)
    {
      if (modo == ctrlMode.standard)
      {
        modo = ctrlMode.nuovaLDP;
      }
      else
      {
        modo = ctrlMode.standard;
      }
      setBtnState();
      checkFixOds();
    }
    /// <summary>
    /// aggiorno x update selettore date
    /// </summary>
    /// <param name="sender"></param>
    /// <param name="e"></param>
    void mod_periodoAnalisi1_eh_doUpdate(object sender, EventArgs e)
    {
      setBtnState();
      checkFixOds();
    }
    /// <summary>
    /// aggiorno x  update valori righe prelievo
    /// </summary>
    /// <param name="sender"></param>
    /// <param name="e"></param>
    void mod_viewRigheListaPrelievo1_eh_nuovoValore(object sender, EventArgs e)
    {
      setBtnState();
      checkFixOds();
    }
    /// <summary>
    /// svuoto da cache post update
    /// </summary>
    /// <param name="sender"></param>
    /// <param name="e"></param>
    protected void ods_Updated(object sender, ObjectDataSourceStatusEventArgs e)
    {
      resetSelezione();
    }
    /// <summary>
    /// aggiorno visualizzazione
    /// </summary>
    private void updateOds()
    {
      grView.DataBind();
    }

    /// <summary>
    /// determina se sia eliminabile il record (=non usato oppure smart)
    /// </summary>
    /// <param name="CodStato">stato lista</param>
    /// <returns></returns>
    public bool delEnabled(object CodStato)
    {
      bool answ = isWritable();
      try
      {
        answ = ((int)CodStato < (int)statoLista.iniziata);
      }
      catch
      { }
      return answ;
    }
    /// <summary>
    /// determina se sia abilitato il pulsante x attivare una lista di prelievo
    /// </summary>
    /// <param name="statoIniziata"></param>
    /// <returns></returns>
    public bool attivaEnabled(object CodStato)
    {
      bool answ = false;
      try
      {
        answ = ((int)CodStato == (int)statoLista.bozza);
      }
      catch
      { }
      return answ;
    }
    /// <summary>
    /// determina se sia abilitato il pulsante x iniziare una lista di prelievo
    /// </summary>
    /// <param name="statoIniziata"></param>
    /// <returns></returns>
    public bool iniziaEnabled(object CodStato)
    {
      bool answ = false;
      try
      {
        answ = ((int)CodStato == (int)statoLista.generata);
      }
      catch
      { }
      return answ;
    }
    /// <summary>
    /// determina se sia abilitato il pulsante x completare una lista di prelievo
    /// </summary>
    /// <param name="statoIniziata"></param>
    /// <returns></returns>
    public bool completaEnabled(object CodStato)
    {
      bool answ = false;
      try
      {
        answ = ((int)CodStato == (int)statoLista.iniziata);
      }
      catch
      { }
      return answ;
    }
    /// <summary>
    /// determina se sia abilitato il pulsante x approvare e scaricare una lista di prelievo
    /// </summary>
    /// <param name="CodStato">stato lista</param>
    /// <param name="codTipo">tipo lista di prelievo</param>
    /// <returns></returns>
    public bool ScaricaEnabled(object CodStato, object codTipo)
    {
      bool answ = false;
      // se la lista è di tipo smart NON si può comunque scaricare, cerco smart nel codice e NON lo deve contenere
      if (!codTipo.ToString().Contains("Smart"))
      {
        try
        {
          answ = ((int)CodStato == (int)statoLista.completata);
        }
        catch
        { }
      }
      return answ;
    }
    /// <summary>
    /// determina se sia abilitato export su AS400 da codLista
    /// </summary>
    /// <param name="codLista"></param>
    /// <returns></returns>
    protected bool as400Export(string codLista)
    {
      // 2014.07.09 inserisco controllo da TIPO LISTA --> se si debba scaricare su AS400...
      bool answ = false;
      DS_magazzino.ElencoListePrelievoDataTable tabElencoListe = new DS_magazzino.ElencoListePrelievoDataTable();
      try
      {
        tabElencoListe = MagClass.magazzino.taElencoListePrelievo.getByCodLista(codLista);
        answ = MagClass.magazzino.taTipoListaPrelievo.getByCodTipoLista(tabElencoListe[0].CodTipoLista)[0].toAs400;
      }
      catch
      {
        answ = false;
      }
      return answ;
    }

    /// <summary>
    /// determina se sia abilitato il pulsante x resettare una lista di prelievo a bozza
    /// </summary>
    /// <param name="codLista">codice univoco lista prelievo</param>
    /// <param name="CodStato">stato lista</param>
    /// <returns></returns>
    public bool ResetVisible(object codLista, object CodStato)
    {
      bool answ = false;
      // condizione: NON CI SIANO ODETTE
      bool condOdette = false;
      // 2014.06.12 modifica x NUOVA gestione packing list, NON permetto reset se scaricata...
      // condizione: SOLO COMPLETATA può essere resettata SE c'è export 2 as400, altrimenti ANCHE scaricata
      bool condStato = false;
      try
      {
        // controllo SE c'è export su AS400 accetto SOLO in stato completata
        if (as400Export(codLista.ToString()))
        {
          // se == completata resetto
          condStato = ((int)CodStato == (int)statoLista.completata);
        }
        else // NON ESPORTO in AS400
        {
          // se >= completata resetto
          condStato = ((int)CodStato >= (int)statoLista.completata);
        }
        // cerco odette x la LDP, se NON ci sono è ok!
        condOdette = !Odette.mgr.listaHasOdette(codLista.ToString());
      }
      catch
      { }
      answ = (condOdette && condStato); // aggiungere controllo scrivibilità? isWritable();
      return answ;
    }
    /// <summary>
    /// determina se sia abilitato il pulsante x resettare una lista di prelievo a bozza
    /// </summary>
    /// <param name="codLista">codice univoco lista prelievo</param>
    /// <param name="CodStato">stato lista</param>
    /// <param name="codTipo">tipo lista di prelievo</param>
    /// <returns></returns>
    public bool ResetEnabled(object codLista, object CodStato, object codTipo)
    {
      bool answ = false;
      // se la lista è di tipo smart NON si può comunque scaricare, cerco smart nel codice e NON lo deve contenere
      if (!codTipo.ToString().Contains("Smart"))
      {
        // condizione: NON CI SIANO ODETTE
        bool condOdette = false;
        // condizione: non in carico ad operatore
        bool condStato = false;
        try
        {
          // controllo SE c'è export su AS400 accetto SOLO in stato completata
          if (as400Export(codLista.ToString()))
          {
            // se == completata resetto
            condStato = ((int)CodStato == (int)statoLista.completata);
          }
          else // NON ESPORTO in AS400
          {
            // se >= completata resetto
            condStato = ((int)CodStato >= (int)statoLista.completata);
          }
          // cerco odette x la LDP, se NON ci sono è ok!
          condOdette = !Odette.mgr.listaHasOdette(codLista.ToString());
        }
        catch
        { }
        answ = (condOdette && condStato);
      }
      return answ;
    }
    /// <summary>
    /// sistema il tooltip di reset
    /// </summary>
    /// <param name="codTipo"></param>
    /// <returns></returns>
    public string tooltipReset(object codTipo)
    {
      string answ = "";
      if (!codTipo.ToString().Contains("Smart"))
      {
        answ = traduci("ResetListaPrelievo");
      }
      else
      {
        answ = traduci("ResetSmartNotEnabled");
      }
      return answ;
    }
    /// <summary>
    /// imposta immagine reset
    /// </summary>
    /// <param name="codTipo"></param>
    /// <returns></returns>
    public string imgReset(object codTipo)
    {
      string answ = "";
      if (!codTipo.ToString().Contains("Smart"))
      {
        answ = "~/images/resetBozza.png";
      }
      else
      {
        answ = "~/images/resetBozza_disabled.png";
      }
      // ULTERIORE CONTROLLO POSSIBILE: CHECK tabTranPosizioneEventi
      return answ;
    }
    /// <summary>
    /// gestione cambio selezione valore
    /// </summary>
    /// <param name="sender"></param>
    /// <param name="e"></param>
    protected void grView_SelectedIndexChanged(object sender, EventArgs e)
    {
      setBtnState();
      checkFixOds();
      // nascondo forzatura
      lbtForzaDL.Visible = false;
    }
    /// <summary>
    /// aggiorna visualizzazione
    /// </summary>
    private void aggiornaElencoRighe()
    {
      // salvo in session il valore selezionato...
      SteamWare.memLayer.ML.setSessionVal(string.Format("{0}_sel", _idxGridView), grView.SelectedValue, true);
      // setto se sia possibile prelevare le righe (SOLO se iniziata)
      bool prelievoOk = false;
      bool cambioUdcOk = false;
      int CodStato = 0;
      string codTipoLista = "";
      DS_magazzino.ElencoListePrelievoDataTable tabElencoListe = new DS_magazzino.ElencoListePrelievoDataTable();
      try
      {
        tabElencoListe = MagClass.magazzino.taElencoListePrelievo.getByCodLista(grView.SelectedValue.ToString());
        CodStato = tabElencoListe[0].CodStatoLista;
        codTipoLista = tabElencoListe[0].CodTipoLista;
        cambioUdcOk = (CodStato == (int)statoLista.bozza);
        prelievoOk = (CodStato == (int)statoLista.iniziata);
      }
      catch
      { }
      mod_viewRigheListaPrelievo1.prelievoEnabled = prelievoOk; // abilito il prelievo SOLO se la lista è già iniziata... 
      mod_viewRigheListaPrelievo1.editRigheEnabled = cambioUdcOk; // abilito il prelievo SOLO se la lista è in BOZZA...  
      mod_viewRigheListaPrelievo1.intStatoLista = CodStato; // salvo il cod (INT) stato della lista 
      mod_viewRigheListaPrelievo1.codTipoLista = codTipoLista; // salvo il tipo lista 
                                                               // mostra con dettagli
      mod_viewRigheListaPrelievo1.Visible = true;
      mod_viewRigheListaPrelievo1.resetSelezione();
    }
    /// <summary>
    /// resetta la selezione dei valori in caso di modifiche su altri controlli
    /// </summary>
    public void resetSelezione()
    {
      currCodLista = "";
      lblErroriLDP.Text = "";
      memLayer.ML.emptySessionVal(string.Format("{0}_sel", _idxGridView));
      grView.SelectedIndex = -1;
      setBtnState();
      checkFixOds();
      lblWarning.Visible = false;
      // nascondo forzatura
      lbtForzaDL.Visible = false;
      // nasconde dettagli
      mod_viewRigheListaPrelievo1.Visible = false;
    }
    /// <summary>
    /// salvo in session il prox comando
    /// </summary>
    /// <param name="sender"></param>
    /// <param name="e"></param>
    protected void img_Click(object sender, ImageClickEventArgs e)
    {
      SteamWare.memLayer.ML.setSessionVal("nextObjCommand", ((ImageButton)sender).CommandArgument);
    }
    /// <summary>
    /// codice lista selezionata
    /// </summary>
    protected string currCodLista
    {
      get
      {
        return memLayer.ML.StringSessionObj("CodListaSel");
      }
      set
      {
        memLayer.ML.setSessionVal("CodListaSel", value);
      }
    }
    /// <summary>
    /// in caso di aggiornamento verifico se sia salvato un comando inizia o completa lista prelievo...
    /// </summary>
    /// <param name="sender"></param>
    /// <param name="e"></param>
    protected void grView_RowUpdating(object sender, GridViewUpdateEventArgs e)
    {
      // carico l'idx dell'oggetto
      string codLista = e.Keys["CodLista"].ToString();
      currCodLista = codLista;
      // quale comando?
      string _comando = "";
      if (SteamWare.memLayer.ML.isInSessionObject("nextObjCommand"))
      {
        _comando = SteamWare.memLayer.ML.StringSessionObj("nextObjCommand");
        SteamWare.memLayer.ML.emptySessionVal("nextObjCommand");
      }
      string CodSoggetto = MagClass.magazzino.CodSoggCurrUser;
      esitoOperazione result = esitoOperazione.ok;
      switch (_comando)
      {
        case "attivaListaPrelievo":
          result = MagClass.magazzino.attivaListaPrelievo(memLayer.ML.StringSessionObj("CodCS"), codLista, CodSoggetto);
          showErrorLDP(result);
          updateOds();
          grView.EditIndex = -1;
          grView.DataBind();
          // sollevo evento nuovo valore...
          if (eh_nuovoValore != null)
          {
            eh_nuovoValore(this, new EventArgs());
          }
          mod_viewRigheListaPrelievo1.Visible = false;
          // blocco update!
          e.Cancel = true;
          break;
        case "iniziaListaPrelievo":
          result = MagClass.magazzino.iniziaListaPrelievo(memLayer.ML.StringSessionObj("CodCS"), codLista, CodSoggetto);
          showErrorLDP(result);
          updateOds();
          grView.EditIndex = -1;
          grView.DataBind();
          // sollevo evento nuovo valore...
          if (eh_nuovoValore != null)
          {
            eh_nuovoValore(this, new EventArgs());
          }
          mod_viewRigheListaPrelievo1.Visible = false;
          // blocco update!
          e.Cancel = true;
          break;
        case "completaListaPrelievo":
          result = MagClass.magazzino.completaListaPrelievo(memLayer.ML.StringSessionObj("CodCS"), codLista, CodSoggetto, Request.UserHostName);
          showErrorLDP(result);
          updateOds();
          grView.EditIndex = -1;
          grView.DataBind();
          // sollevo evento nuovo valore...
          if (eh_nuovoValore != null)
          {
            eh_nuovoValore(this, new EventArgs());
          }
          mod_viewRigheListaPrelievo1.Visible = false;
          // blocco update!
          e.Cancel = true;
          break;
        case "scaricaListaPrelievo":
          int slotPL = Convert.ToInt32(ddlSlotLPAS.SelectedValue);
          result = MagClass.magazzino.scaricaListaPrelievo(memLayer.ML.StringSessionObj("CodCS"), codLista, CodSoggetto, Request.UserHostName, slotPL);
          showErrorLDP(result);
          updateOds();
          grView.EditIndex = -1;
          grView.DataBind();
          // sollevo evento nuovo valore...
          if (eh_nuovoValore != null)
          {
            eh_nuovoValore(this, new EventArgs());
          }
          mod_viewRigheListaPrelievo1.Visible = false;
          // blocco update!
          e.Cancel = true;
          break;
        case "resetListaPrelievo":
          result = MagClass.magazzino.resetListaPrelievo(memLayer.ML.StringSessionObj("CodCS"), codLista, CodSoggetto, Request.UserHostName);
          showErrorLDP(result);
          updateOds();
          grView.EditIndex = -1;
          grView.DataBind();
          // sollevo evento nuovo valore...
          if (eh_nuovoValore != null)
          {
            eh_nuovoValore(this, new EventArgs());
          }
          mod_viewRigheListaPrelievo1.Visible = false;
          // blocco update!
          e.Cancel = true;
          break;
        default:
          // faccio update!
          break;
      }
    }
    /// <summary>
    /// imposta la visualizzazione di un codice di errore a seconda di come è andata l'operazione sulla LDP
    /// </summary>
    /// <param name="result"></param>
    private void showErrorLDP(esitoOperazione result)
    {
      if (result != esitoOperazione.ok)
      {
        switch (result)
        {
          case esitoOperazione.errore:
            lblErroriLDP.Text = traduci("ERR-RLP-001");
            break;
          case esitoOperazione.errore_mismatch:
            lblErroriLDP.Text = traduci("ERR-RLP-002");
            break;
          case esitoOperazione.errore_readOnly:
            lblErroriLDP.Text = traduci("ERR-RLP-003");
            break;
          case esitoOperazione.errore_posUDC:
            lblErroriLDP.Text = traduci("ERR-RLP-004");
            break;
          case esitoOperazione.errore_noUdc:
            lblErroriLDP.Text = traduci("ERR-RLP-005");
            break;
          case esitoOperazione.errore_nonScaricabile:
            lblErroriLDP.Text = traduci("ERR-RLP-006");
            break;
          case esitoOperazione.errore_noDeliberPM:
            lblErroriLDP.Text = traduci("ERR-RLP-007");
            lbtForzaDL.Visible = true;
            break;
          case esitoOperazione.errore_UdcNc:
            lblErroriLDP.Text = traduci("ERR-RLP-008");
            lbtForzaDL.Visible = true;
            break;
          case esitoOperazione.errore_DtmxNc:
            lblErroriLDP.Text = traduci("ERR-RLP-009");
            lbtForzaDL.Visible = true;
            break;
        }
        lblErroriLDP.Visible = true;
      }
      else
      {
        lblErroriLDP.Visible = false;
      }
    }
    /// <summary>
    /// chiamato post modifica valore check/selezione nel selettore filtro stato
    /// </summary>
    /// <param name="sender"></param>
    /// <param name="e"></param>
    public void eh_selectedStato(object sender, EventArgs e)
    {
      checkFixOds();
    }
    /// <summary>
    /// ssitema visualizzazione dal filtraggi
    /// </summary>
    private void checkFixOds()
    {
      ods.FilterParameters.Clear();
      ods.FilterExpression = "(CodLista LIKE '%{0}%' OR Particolare LIKE '%{0}%' OR DescParticolare LIKE '%{0}%')";

      // parametro ricerca attuale
      SessionParameter parametroFiltro = new SessionParameter();
      parametroFiltro.SessionField = "valoreCercato";
      parametroFiltro.Name = "ricerca";
      parametroFiltro.DefaultValue = "*";
      ods.FilterParameters.Add(parametroFiltro);

      // filtro stato lista
      if (mod_filtroStato.valore != "*")
      {
        ods.FilterExpression += " AND CodStatoLista = {1}";
      }
      ControlParameter parametroListaStato = new ControlParameter();
      parametroListaStato.ControlID = "mod_filtroStato";
      parametroListaStato.PropertyName = "valore";
      parametroListaStato.Name = "CodStato";
      parametroListaStato.DefaultValue = "0";
      ods.FilterParameters.Add(parametroListaStato);

      // filtro tipo lista
      if (mod_filtroTipo.valore != "*")
      {
        ods.FilterExpression += " AND CodTipoLista = '{2}'";
      }
      ControlParameter parametroListaTipo = new ControlParameter();
      parametroListaTipo.ControlID = "mod_filtroTipo";
      parametroListaTipo.PropertyName = "valore";
      parametroListaTipo.Name = "CodTipoLista";
      parametroListaTipo.DefaultValue = "0";
      ods.FilterParameters.Add(parametroListaTipo);

      // se sono in modalità scarico multiplo nascondo stati !=3 e SmartList...
      if (modo == ctrlMode.scaricaMultiLDP)
      {
        ods.FilterExpression += " AND CodStatoLista = 3 AND CodTipoLista <> '00-Smart'";
      }

      // chiamo procedura che aggiorna ods principale
      updateOds();
      // ridisegno controllo child!
      aggiornaElencoRighe();
    }
    /// <summary>
    /// chiamato post modifica valore check/selezione nel selettore filtro tipo
    /// </summary>
    /// <param name="sender"></param>
    /// <param name="e"></param>
    public void eh_selectedTipo(object sender, EventArgs e)
    {
      checkFixOds();
    }
    /// <summary>
    /// chiamato post modifica valore check/selezione nel selettore filtro tipo particolare
    /// </summary>
    /// <param name="sender"></param>
    /// <param name="e"></param>
    public void eh_selectedTipoPart(object sender, EventArgs e)
    {
      checkFixOds();
    }
    /// <summary>
    /// restituisce URL immagine del codice da mostrare x stato lista
    /// </summary>
    /// <param name="CodStato"></param>
    /// <returns></returns>
    public string pathImgStato(object CodStato)
    {
      return string.Format("~/images/circle_s_{0}.png", CodStato);
    }
    /// <summary>
    /// restituisce tooltip da mostrare x STATO lista
    /// </summary>
    /// <param name="CodStato"></param>
    /// <returns></returns>
    public string tooltipStato(object codice)
    {
      return traduci(string.Format("StatoLista_{0}", codice));
    }
    /// <summary>
    /// restituisce URL immagine del codice da mostrare x TIPO lista
    /// </summary>
    /// <param name="CodStato"></param>
    /// <returns></returns>
    public string pathImgTipo(object codice)
    {
      return string.Format("~/images/lista_{0}_m.png", codice);
    }
    /// <summary>
    /// restituisce tooltip da mostrare x TIPO lista
    /// </summary>
    /// <param name="CodStato"></param>
    /// <returns></returns>
    public string tooltipTipo(object codice)
    {
      return traduci(codice.ToString());
    }
    /// <summary>
    /// mostra controllo per creare nuove liste di prelievo
    /// </summary>
    /// <param name="sender"></param>
    /// <param name="e"></param>
    protected void btnNewLista_Click(object sender, EventArgs e)
    {
      if (modo == ctrlMode.standard)
      {
        modo = ctrlMode.nuovaLDP;
      }
      else
      {
        modo = ctrlMode.standard;
      }
      grView.SelectedIndex = -1;
      setBtnState();
      checkFixOds();
    }
    /// <summary>
    /// mostra controllo per modificare destinatario e tipo lista
    /// </summary>
    /// <param name="sender"></param>
    /// <param name="e"></param>
    protected void btnSetDestTipo_Click(object sender, EventArgs e)
    {
      if (modo == ctrlMode.standard)
      {
        modo = ctrlMode.setDestTipoLDP;
      }
      else
      {
        modo = ctrlMode.standard;
      }
      grView.SelectedIndex = -1;
      setBtnState();
      checkFixOds();
    }
    /// <summary>
    /// va in modalità scaricamento liste multiple in blocco
    /// </summary>
    /// <param name="sender"></param>
    /// <param name="e"></param>
    protected void btnSetModeScaricaListeSel_Click(object sender, EventArgs e)
    {
      if (modo == ctrlMode.standard)
      {
        modo = ctrlMode.scaricaMultiLDP;
      }
      else
      {
        modo = ctrlMode.standard;
      }
      grView.SelectedIndex = -1;
      setBtnState();
      checkFixOds();
    }
    /// <summary>
    /// imposta lo stato dei buttons (visibilità, label...) in base a stato controllo
    /// </summary>
    protected void setBtnState()
    {
      // traduzioni "base"
      btnNewLista.Text = traduci("NuovaListaPrelievo");
      btnSetDestTipo.Text = traduci("ImpostaDestTipo");
      btnUpdateDestTipo.Text = traduci("SalvaDestTipo");
      btnSetModeScaricaListeSel.Text = traduci("btnSetModeScaricaListeSel");
      btnScaricaSelLDP.Text = traduci("btnScaricaSelLDP");
      // visibilità "base"
      btnNewLista.Enabled = true;
      btnSetDestTipo.Enabled = true;
      btnSetModeScaricaListeSel.Enabled = true;
      pnlSetDestTipo.Visible = false;
      pnlScaricaMultiLDP.Visible = false;
      mod_nuovaListaPrelievo1.Visible = false;
      // sistemo button tipo liste a DX (tutti / solo NC)
      fixBtnShowNc(mod_viewRigheListaPrelievo1.minScoreNC == 0);

      // in base a modo imposto...
      switch (modo)
      {
        case ctrlMode.standard:
          // tutto standard...
          break;
        case ctrlMode.nuovaLDP:
          // traduzioni
          btnNewLista.Text = traduci("NascondiNuovaListaPrelievo");
          // visibilità
          btnSetDestTipo.Enabled = false;
          btnSetModeScaricaListeSel.Enabled = false;
          mod_nuovaListaPrelievo1.Visible = true;
          break;
        case ctrlMode.setDestTipoLDP:
          // traduzioni
          btnSetDestTipo.Text = traduci("NascondiImpostaDestTipo");
          // visibilità
          btnNewLista.Enabled = false;
          btnSetModeScaricaListeSel.Enabled = false;
          pnlSetDestTipo.Visible = true;
          break;
        case ctrlMode.scaricaMultiLDP:
          // traduzioni
          btnSetModeScaricaListeSel.Text = traduci("btnUnSetModeScaricaListeSel");
          // visibilità
          btnNewLista.Enabled = false;
          btnSetDestTipo.Enabled = false;
          pnlScaricaMultiLDP.Visible = true;
          break;
        default:
          break;
      }
    }
    /// <summary>
    /// traduce il cod soggetto in cognome-nome operatore
    /// </summary>
    /// <param name="CodSogg"></param>
    /// <param name="stringaPre">In carico a: / Completato da: / ... </param>
    /// <returns></returns>
    public string traduciCodSogg(object CodSogg, object stringaPre)
    {
      string answ = "-";
      try
      {
        DS_Applicazione.AnagOperatoriRow oper = DataProxy.obj.taAnagOperatore.getByCodSoggetto(CodSogg.ToString())[0];
        answ = string.Format("{3} {0} {1} ({2})", oper.Cognome, oper.Nome, oper.CodDipendente, stringaPre); // Ermanno: traduzione testo!
      }
      catch
      { }
      return answ;
    }

    /// <summary>
    /// restituisce l'url formattato del il report della stampa come da web.config
    /// </summary>
    /// <param name="codLista"></param>
    /// <returns></returns>
    public string formattaUrlReport(object codLista)
    {
      string url, urlFormat, opzPdf, nomeRep, urlWebServer;
      try
      {
        urlFormat = SteamWare.memLayer.ML.confReadString("urlReporting");
        urlWebServer = SteamWare.memLayer.ML.confReadString("urlWebServer");
        opzPdf = "";
        nomeRep = SteamWare.memLayer.ML.confReadString("reportName");
        // versione con reporting services
        url = string.Format(urlFormat, SteamWare.memLayer.ML.AppConf["reportingServerAddress"], SteamWare.memLayer.ML.confReadString("reportDir"), nomeRep, codLista, opzPdf);

      }
      catch
      {
        url = "";
      }
      return url;
    }
    /// <summary>
    /// forza ricaricamento dati datamatrix/gitterbox/odette
    /// </summary>
    /// <param name="sender"></param>
    /// <param name="e"></param>
    protected void btnForceReload_Click(object sender, EventArgs e)
    {
      DataMatrix_mgr.importNuoviDati();
    }
    /// <summary>
    /// aggiorna destinatario e tipo lista selezionate da valori indicati
    /// </summary>
    /// <param name="sender"></param>
    /// <param name="e"></param>
    protected void btnUpdateDestTipo_Click(object sender, EventArgs e)
    {
      string CodLista = "";
      foreach (GridViewRow riga in grView.Rows)
      {
        if (((CheckBox)riga.FindControl("chkSelect")).Checked && ((CheckBox)riga.FindControl("chkSelect")).Visible)
        {
          CodLista = ((Label)riga.FindControl("lblCodLista")).Text;
          updateDestTipoLDP(CodLista);
        }
      }
      if (modo == ctrlMode.standard)
      {
        modo = ctrlMode.setDestTipoLDP;
      }
      else
      {
        modo = ctrlMode.standard;
      }
      setBtnState();
      checkFixOds();
    }
    /// <summary>
    /// scarica le LDP selezionate...
    /// </summary>
    /// <param name="sender"></param>
    /// <param name="e"></param>
    protected void btnScaricaSelLDP_Click(object sender, EventArgs e)
    {
      string CodLista = "";
      esitoOperazione result = esitoOperazione.ok;
      int slotPL = Convert.ToInt32(ddlSlotLPAS.SelectedValue);
      foreach (GridViewRow riga in grView.Rows)
      {
        if (((CheckBox)riga.FindControl("chkSelect")).Checked && ((CheckBox)riga.FindControl("chkSelect")).Visible)
        {
          CodLista = ((Label)riga.FindControl("lblCodLista")).Text;
          result = MagClass.magazzino.scaricaListaPrelievo(memLayer.ML.StringSessionObj("CodCS"), CodLista, MagClass.magazzino.CodSoggCurrUser, Request.UserHostName, slotPL);
        }
      }
      if (modo == ctrlMode.standard)
      {
        modo = ctrlMode.scaricaMultiLDP;
      }
      else
      {
        modo = ctrlMode.standard;
      }
      setBtnState();
      checkFixOds();
    }
    /// <summary>
    /// determina abilitazione pulsante check: se siano modificabili destinatario e tipo lista, SOLO in stato completato (3/4) 
    /// </summary>
    /// <param name="CodStato"></param>
    /// <returns></returns>
    public bool modDestAndTipo(object CodStato)
    {
      bool answ = false;
      try
      {
        answ = ((int)CodStato == (int)statoLista.completata);
      }
      catch
      { }
      return answ;
    }
    /// <summary>
    /// aggiorna la lista di prelievo indicata impostando destinatario e tipo
    /// </summary>
    /// <param name="CodLista"></param>
    private void updateDestTipoLDP(string CodLista)
    {
      MagClass.magazzino.taElencoListePrelievo.stp_LP_updateDestTipo(CodLista, ddlTipoLista.SelectedValue, ddlDestin.SelectedValue, ddlDestin.SelectedItem.Text, MagClass.magazzino.CodSoggCurrUser, DateTime.Now);
    }
    /// <summary>
    /// modo di funzionamento del controllo
    /// </summary>
    protected ctrlMode modo
    {
      get
      {
        ctrlMode answ = ctrlMode.standard;
        if (memLayer.ML.isInSessionObject("ctrlMode") && memLayer.ML.StringSessionObj("ctrlMode") != "")
        {
          try
          {
            answ = (ctrlMode)memLayer.ML.objSessionObj("ctrlMode");
          }
          catch
          { }
        }
        return answ;
      }
      set
      {
        memLayer.ML.setSessionVal("ctrlMode", value, false);
      }
    }
    /// <summary>
    /// chiamata post page change gridview
    /// </summary>
    /// <param name="sender"></param>
    /// <param name="e"></param>
    protected void grView_PageIndexChanged(object sender, EventArgs e)
    {
      // sistemazione dell'ods post evento cambio pagina
      checkFixOds();
    }
    /// <summary>
    /// chiamata post sort gridview
    /// </summary>
    /// <param name="sender"></param>
    /// <param name="e"></param>
    protected void grView_Sorted(object sender, EventArgs e)
    {
      // sistemazione dell'ods
      checkFixOds();
    }
    /// <summary>
    /// entrando in editing fix ods
    /// </summary>
    /// <param name="sender"></param>
    /// <param name="e"></param>
    protected void grView_RowEditing(object sender, GridViewEditEventArgs e)
    {
      // sistemazione dell'ods post evento sort
      checkFixOds();
    }
    /// <summary>
    /// post edit fix ods
    /// </summary>
    /// <param name="sender"></param>
    /// <param name="e"></param>
    protected void grView_RowUpdated(object sender, GridViewUpdatedEventArgs e)
    {
      // sistemazione dell'ods
      checkFixOds();
    }
    /// <summary>
    /// aggiorno controllo paginazione...
    /// </summary>
    /// <param name="sender"></param>
    /// <param name="e"></param>
    protected void txtNumRighe_TextChanged(object sender, EventArgs e)
    {
      aggiornaControlliDataGL();
      checkFixOds();
    }
    /// <summary>
    /// forza le delibere:
    /// - la delibera DC x ogni NC aperta su UDC della lista
    /// - la delibera logistica x gli UDC di trattamenti senza PM
    /// <param name="sender"></param>
    /// <param name="e"></param>
    protected void lbtForzaDL_Click(object sender, EventArgs e)
    {
      MagClass.magazzino.taRigheListePrelievo.setDlUdcSenzaDeliberaPM(currCodLista, DateTime.Now, MagClass.magazzino.CodSoggCurrUser);
      lbtForzaDL.Visible = false;
      resetSelezione();
    }
    /// <summary>
    /// Mostra solo UDC con NC o tutti...
    /// </summary>
    /// <param name="sender"></param>
    /// <param name="e"></param>
    protected void lbtShowOnlyUdcNC_Click(object sender, EventArgs e)
    {
      // imposto parametro nel controllo dettaglio
      mod_viewRigheListaPrelievo1.minScoreNC = 1;
      // inverto visibilità buttons
      fixBtnShowNc(false);
    }
    /// <summary>
    /// Mostra TUTTI UDC...
    /// </summary>
    /// <param name="sender"></param>
    /// <param name="e"></param>
    protected void lbtShowAllUdc_Click(object sender, EventArgs e)
    {
      // imposto parametro nel controllo dettaglio
      mod_viewRigheListaPrelievo1.minScoreNC = 0;
      // inverto visibilità buttons
      fixBtnShowNc(true);
    }

    protected void fixBtnShowNc(bool showAll)
    {
      lbtShowOnlyUdcNC.Visible = showAll;
      lbtShowAllUdc.Visible = !showAll;
    }

    #endregion
  }
}
/// <summary>
/// possibili stati del controllo
/// </summary>
public enum ctrlMode
{
  standard = 0,
  nuovaLDP,
  setDestTipoLDP,
  scaricaMultiLDP
}