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

namespace GMW_Term.WebUserControls
{
    public partial class mod_listePrelievo : System.Web.UI.UserControl
    {
        #region area da NON modificare

        #region area protected

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

        /// <summary>
        /// wrapper traduzione termini
        /// </summary>
        /// <param name="lemma"></param>
        /// <returns></returns>
        public string traduci(string lemma)
        {
            return user_std.UtSn.Traduci(lemma);
        }


        /// <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.Trim();
                        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;
                    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 richeista 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();
        }

        #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

        string _homeBtnText = "Home";
        string _homeBtnLink = "~/Home.aspx";
        /// <summary>
        /// testo del pulsante HOME
        /// </summary>
        public string homeBtnText
        {
            set
            {
                _homeBtnText = value;
                traduciObj();
            }
            get
            {
                return _homeBtnText;
            }
        }
        /// <summary>
        /// link del pulsante HOME
        /// </summary>
        public string homeBtnLink
        {
            set
            {
                _homeBtnLink = value;
                traduciObj();
            }
            get
            {
                return _homeBtnLink;
            }
        }

        // variabile per verificare se è operatore
        bool _validUserInSession = false;
        /// <summary>
        /// Verifica se c'è un valore in sessione di tipo operatore
        /// </summary>
        protected void verificaOperatoreInSessione()
        {
            if (string.IsNullOrEmpty(user_std.UtSn.utente))
            {
                _validUserInSession = false;
            }
            else
            {
                _validUserInSession = true;
            }
        }
        /// <summary>
        /// traduce stringhe oggetti
        /// </summary>
        protected void traduciObj()
        {
            // scrive label e text bottoni
            btnLoginPage.Text = string.Format("{0}\n[Alt+{1}]", traduci("Logout"), 7);
            btnLoginPage.AccessKey = "7";
            btnButtonsHome.Text = string.Format("{0}\n[Alt+{1}]", traduci(_homeBtnText), 9);
            btnButtonsHome.AccessKey = "9";
            btnShowPeriodo.Text = string.Format("{0}\n[Alt+{1}]", traduci("ImpostaPeriodo"), 8); 
            btnShowPeriodo.AccessKey = "8";
            btnCloseDet.Text = string.Format("{0}\n[Alt+{1}]", traduci("Close"), 3);
            btnCloseDet.AccessKey = "3";
            btnBarcode.Text = string.Format("{0}\n[Alt+{1}]", traduci("Barcode"), 1);
            btnBarcode.AccessKey = "1";
        }

        /// <summary>
        /// metodi al caricamento della pagina
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        protected void Page_Load(object sender, EventArgs e)
        {
            traduciObj();            
            // se username è valorizzato...
            verificaOperatoreInSessione();
            if (_validUserInSession)
            {
                btnLoginPage.Visible = memLayer.ML.confReadBool("showLogout");
                btnButtonsHome.Visible = true;
            }
            // se non è valorizzato chiede di effettuare login...
            else
            {
                Response.Redirect("Home.aspx");
            }
            // controllo se ci sia richiesta x mostrare dettagli...
            if (memLayer.ML.BoolSessionObj("showDetListaPre"))
            {
                memLayer.ML.emptySessionVal("showDetListaPre");
                showListDetails(memLayer.ML.StringSessionObj("CodListaAttiva"));
            }
            // controllo se sia abilitato pulsante x prendere in carico una LDP (ovvero NON HO altre LDP in carico...)
            bool ListaSelOk = (memLayer.ML.StringSessionObj("CodListaAttiva") == memLayer.ML.StringSessionObj("CodLista_sel"));
            if (ListaSelOk)
            {
                btnPrendiInCarico.Visible = false;
            }
            else
            {
                btnPrendiInCarico.Visible = true;
            }
        }

        /// <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)
            {
                mod_periodoAnalisi1.setPeriodoFree();
            }
            // registro evento update
            mod_periodoAnalisi1.eh_doUpdate += new EventHandler(mod_periodoAnalisi1_eh_doUpdate);
            aggiornaControlliDataGL();
        }
        /// <summary>
        /// aggiorna controlli datagrid e numero righe in pagina
        /// </summary>
        protected void aggiornaControlliDataGL()
        {
            grView.PageSize = 4;
        }

        /// <summary>
        /// aggiorno x update selettore date
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        void mod_periodoAnalisi1_eh_doUpdate(object sender, EventArgs e)
        {
            // aggiorno controllo corrente!
            updateOds();
        }
        /// <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>
        /// gestione cambio selezione valore
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        protected void grView_SelectedIndexChanged(object sender, EventArgs e)
        {
        }
        /// <summary>
        /// resetta la selezione dei valori in caso di modifiche su altri controlli
        /// </summary>
        public void resetSelezione()
        {
            SteamWare.memLayer.ML.emptySessionVal(string.Format("{0}_sel", _idxGridView));
            grView.SelectedIndex = -1;
            grView.DataBind();
            lblWarning.Visible = false;
        }

        /// <summary>
        /// salvo in session che il prox comando è iniziare lista prelievo...
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        protected void imgAzioneLista_Click(object sender, ImageClickEventArgs e)
        {
            ImageButton imgb = (ImageButton)sender;
            SteamWare.memLayer.ML.setSessionVal("nextObjCommand", imgb.CommandArgument);
        }
        /// <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();
            // 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;
            switch (_comando)
            {
                case "IniziaListaPrelievo":
                    iniziaListaPrelievo(codLista, CodSoggetto);
                    // blocco update!
                    e.Cancel = true;
                    break;
                case "CompletaListaPrelievo":
                    completaListaPrelievo(codLista, CodSoggetto);
                    // blocco update!
                    e.Cancel = true;
                    break;
                case "ShowDetail":
                    showListDetails(codLista);
                    // blocco update!
                    e.Cancel = true;
                    break;
                default:
                    // faccio update!
                    break;
            }
        }
        /// <summary>
        /// compelta e chiude x operatore la lista di prelievo
        /// </summary>
        /// <param name="codLista"></param>
        /// <param name="CodSoggetto"></param>
        private void completaListaPrelievo(string codLista, string CodSoggetto)
        {
            esitoOperazione esitoCompleta = GMW_data.MagClass.magazzino.completaListaPrelievo(memLayer.ML.StringSessionObj("CodCS"), codLista, CodSoggetto, Request.UserHostName);
            if (esitoCompleta == esitoOperazione.ok)
            {
                updateOds();
                grView.EditIndex = -1;
                grView.DataBind();
                // sollevo evento nuovo valore...
                if (eh_nuovoValore != null)
                {
                    eh_nuovoValore(this, new EventArgs());
                }
                // tolgo dalla session la lista prelievo attuale...
                memLayer.ML.emptySessionVal("CodLista_sel");
            }
            else if (esitoCompleta == esitoOperazione.errore_noUdc)
            {
                GMW_data.MagClass.magazzino.attivaListaPrelievo(memLayer.ML.StringSessionObj("CodCS"), codLista, CodSoggetto);
                httpLog(string.Format("Lista di prelievo {0} rilasciata poiché senza UDC prelevati da parte dell'opertore {1}", codLista, CodSoggetto), tipoLog.INFO);
                // tolgo dalla session la lista prelievo attuale...
                memLayer.ML.emptySessionVal("CodLista_sel");
                memLayer.ML.emptySessionVal("CodListaAttiva");
                memLayer.ML.emptySessionVal("activeTask");
            }
        }
        /// <summary>
        /// prende in carico ed inizia la lista di prelievo
        /// </summary>
        /// <param name="codLista"></param>
        /// <param name="CodSoggetto"></param>
        private void iniziaListaPrelievo(string codLista, string CodSoggetto)
        {
            GMW_data.MagClass.magazzino.iniziaListaPrelievo(memLayer.ML.StringSessionObj("CodCS"), codLista, CodSoggetto);
            updateOds();
            grView.EditIndex = -1;
            grView.DataBind();
            // sollevo evento nuovo valore...
            if (eh_nuovoValore != null)
            {
                eh_nuovoValore(this, new EventArgs());
            }
        }
        /// <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 grViewDetail_RowUpdating(object sender, GridViewUpdateEventArgs e)
        {
            // carico l'idx dell'oggetto
            string codLista = e.Keys["CodLista"].ToString();
            string udc = e.Keys["UDC"].ToString();
            // 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;
            switch (_comando)
            {
                case "confermaPrelievo":
                    // controllo SE sia ancora prelevabile questo UDC...
                    if (!udcPrelevato(udc))
                    {
                        GMW_data.MagClass.magazzino.confermaUdcPrelevatoPerLista(codLista, udc);
                    }
                    grViewDetail.EditIndex = -1;
                    grViewDetail.DataBind();
                    // sollevo evento nuovo valore...
                    if (eh_nuovoValore != null)
                    {
                        eh_nuovoValore(this, new EventArgs());
                    }
                    // blocco update!
                    e.Cancel = true;
                    break;
                case "annullaPrelievo":
                    GMW_data.MagClass.magazzino.annullaUdcPrelevatoPerLista(codLista, udc);
                    grViewDetail.EditIndex = -1;
                    grViewDetail.DataBind();
                    // sollevo evento nuovo valore...
                    if (eh_nuovoValore != null)
                    {
                        eh_nuovoValore(this, new EventArgs());
                    }
                    // blocco update!
                    e.Cancel = true;
                    break;
                default:
                    // faccio update!
                    break;
            }
        }


        /// <summary>
        /// mostro la lista di prelievo indicata
        /// </summary>
        /// <param name="codLista"></param>
        private void showListDetails(string codLista)
        {
            // salvo codice lista
            memLayer.ML.setSessionVal("CodLista_sel", codLista);
            // mostro dettaglio lista (e relativi buttons)
            pnlDetail.Visible = true;
            updateBtnPrendiInCarico(codLista);

            // nascondo elenco lista prelievo
            pnlMaster.Visible = false;
            setBarcodeBtn();
        }
        /// <summary>
        /// fix visibilità button barcode
        /// </summary>
        private void setBarcodeBtn()
        {
            // button x barcode: visibile solo se c'è una lista di prelievo attiva...
            if (MagClass.magazzino.userHasActiveLP)
            {
                btnBarcode.Visible = true;
            }
            else
            {
                btnBarcode.Visible = false;
            }
        }
        /// <summary>
        /// aggiorna il button della lista di prelievo
        /// </summary>
        /// <param name="codLista"></param>
        private void updateBtnPrendiInCarico(string codLista)
        {
            // sistemo testo e tooltip del button x prendere in carico/chiudere...
            int codStatoLista = 0;
            try
            {
                codStatoLista = MagClass.magazzino.taElencoListePrelievo.getByCodLista(codLista)[0].CodStatoLista;
            }
            catch
            { }
            btnPrendiInCarico.Text = string.Format("{0}\n[Alt+{1}]", traduci(string.Format("txt_{0}", cmdArgStato(codStatoLista))), 4);
            btnPrendiInCarico.AccessKey = "4";
            btnPrendiInCarico.ToolTip = traduci(cmdArgStato(codStatoLista));
            btnPrendiInCarico.CommandArgument = cmdArgStato(codStatoLista);
            //cbeCambiaStato.ConfirmText = traduci(cmdArgStato(codStatoLista));
        }
        /// <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()
        {
            // chiamo procedura che aggiorna ods principale
            grView.SelectedIndex = -1;
            updateOds();
        }
        /// <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>
        /// restituisce URL immagine del codice da mostrare x stato lista
        /// </summary>
        /// <param name="codStato"></param>
        /// <returns></returns>
        public string pathImgStato(object codStato)
        {
            int stato = Convert.ToInt32(codStato);
            string answ = "";
            if (MagClass.magazzino.userHasActiveLP && stato == 1)
            {
                answ = string.Format("~/images/squareDis_m_{0}.jpg", codStato);
            }
            else
            {
                answ = string.Format("~/images/square_m_{0}.jpg", codStato);
            }
            return answ;
        }
        /// <summary>
        /// restituisce il comando da associare all'immagine dato lo stato della lista
        /// </summary>
        /// <param name="codStato"></param>
        /// <returns></returns>
        public string cmdArgStato(object codStato)
        {
            int stato = Convert.ToInt32(codStato);
            string answ = "";
            switch (stato)
            {
                case 1:
                    answ = "IniziaListaPrelievo";
                    break;
                case 2:
                    answ = "CompletaListaPrelievo";
                    break;
            }
            return answ;
        }
        /// <summary>
        /// verifica la possibilità di click dato lo stato della lista secondo la regola:
        /// - se utente ne ha in carico una può solo chiuderla
        /// - altrimenti può prendere in carico una nuova
        /// </summary>
        /// <param name="codStato">stato della lista</param>
        /// <param name="codLista">codice identificativo della lista</param>
        /// <returns></returns>
        public bool enabledStato(object codStato, object codLista)
        {
            int stato = Convert.ToInt32(codStato);
            bool answ = false;
            // se la lista non è in carico all'utente è ovviamente NON abilitato...
            bool listaInCarico = false;
            try
            {
                listaInCarico = MagClass.magazzino.codListaAttivaUtente == codLista.ToString();
            }
            catch
            { }

            switch (stato)
            {
                case 1:
                    answ = !MagClass.magazzino.userHasActiveLP; // può prendere in carico SE non ne ha altre...
                    break;
                case 2:
                    if (listaInCarico)
                    {
                        answ = MagClass.magazzino.userHasActiveLP; // può chiudere se ce l'ha attiva...
                    }
                    break;
            }

            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>
        /// verifica se sia prelevabile
        /// </summary>
        /// <param name="statoPrelevata"></param>
        /// <param name="udc"></param>
        /// <returns></returns>
        public bool prelevaEnabled(object statoPrelevata, object udc)
        {
            bool answ = prelievoEnabled;
            if (prelievoEnabled)
            {
                // controllo se non risulti prelevato l'UDC in un altra lista...
                if (udcPrelevato(udc))
                {
                    answ = false;
                }
                else
                {
                    try
                    {
                        answ = !Convert.ToBoolean(statoPrelevata);
                    }
                    catch
                    { }
                }
            }
            return answ;
        }
        /// <summary>
        /// verifica se sia annullabile il prelievo
        /// </summary>
        /// <param name="annullaPrelevata"></param>
        /// <returns></returns>
        public bool annullaEnabled(object annullaPrelevata)
        {
            bool answ = prelievoEnabled;
            if (prelievoEnabled)
            {
                try
                {
                    answ = Convert.ToBoolean(annullaPrelevata);
                }
                catch
                { }
            }
            return answ;
        }
        /// <summary>
        /// determina se le righe di prelievo siano confermabili per prelievo (durante pick-up) - se c'è lista prelievo attiva ed è quella corrente!!!
        /// </summary>
        public bool prelievoEnabled
        {
            get
            {
                bool ListaInPrelievo = memLayer.ML.isInSessionObject("CodListaAttiva");
                bool ListaSelOk = (memLayer.ML.StringSessionObj("CodListaAttiva") == memLayer.ML.StringSessionObj("CodLista_sel"));
                bool buttonsEnabled = memLayer.ML.confReadBool("PrelDepoTermEnabled");
                return (ListaInPrelievo && ListaSelOk && buttonsEnabled);
            }
        }
        /// <summary>
        /// fornisce verifica se l'udc sia già stato prelevato altrove...
        /// </summary>
        /// <param name="udc"></param>
        /// <returns></returns>
        public bool udcPrelevato(object udc)
        {
            return GMW_data.MagClass.magazzino.taRigheListePrelievo.getPrelevateByUdc(udc.ToString()).Rows.Count > 0;
        }


        /// <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}_s.jpg", 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>
        /// effettua logout...
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        protected void btnLoginPage_Click(object sender, EventArgs e)
        {
            TermUtils.TU.forceLogOut();
            Response.Redirect("~/Barcode.aspx");
        }
        /// <summary>
        /// va alla pagina dei buttons principale
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        protected void btnButtonsHome_Click(object sender, EventArgs e)
        {
            Response.Redirect(homeBtnLink);
        }
        /// <summary>
        /// nasconde dettagli
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        protected void btnCloseDet_Click(object sender, EventArgs e)
        {
            // ricarico x evitare proliferazione "_" su prima colonna
            Response.Redirect("~/ListePrelievo.aspx");
        }
        /// <summary>
        /// passa al barcode!
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        protected void btnBarcode_Click(object sender, EventArgs e)
        {
            Response.Redirect("~/Barcode.aspx");
        }
        /// <summary>
        /// salvo in session che il prox comando è confermare prelievo...
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        protected void imgPrelevato_Click(object sender, ImageClickEventArgs e)
        {
            SteamWare.memLayer.ML.setSessionVal("nextObjCommand", "confermaPrelievo");
        }
        /// <summary>
        /// salvo in session che il prox comando è annullare prelievo...
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        protected void imgAnnullato_Click(object sender, ImageClickEventArgs e)
        {
            SteamWare.memLayer.ML.setSessionVal("nextObjCommand", "annullaPrelievo");
        }

        /// <summary>
        /// effettua trim della stringa
        /// </summary>
        /// <param name="testo"></param>
        /// <param name="maxChar"></param>
        /// <returns></returns>
        public string trimma(string testo, int maxChar)
        {
            string answ = testo;
            if (testo.Length > maxChar)
            {
                answ = testo.Substring(0, 10);
            }

            return answ;
        }
        /// <summary>
        /// cliccato link x dettaglio dest o particolare
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        protected void lnk_Click(object sender, EventArgs e)
        {
            LinkButton lnkb = (LinkButton)sender;
            SteamWare.memLayer.ML.setSessionVal("nextObjCommand", lnkb.CommandArgument);
        }
        /// <summary>
        /// verifica se sia abilitata la presa in carico delal lista di prelievo
        /// </summary>
        /// <returns></returns>
        public bool enabledPrendiInCarico()
        {
            bool answ = false;
            // carico i dati che mi servono...
            string codLista = memLayer.ML.StringSessionObj("CodLista_sel");
            int codStatoLista = 0;
            try
            {
                codStatoLista = MagClass.magazzino.taElencoListePrelievo.getByCodLista(codLista)[0].CodStatoLista;
            }
            catch
            { }
            try
            {
                answ = enabledStato(codStatoLista, codLista);
            }
            catch
            { }
            return answ;
        }
        /// <summary>
        /// esegue la presa in carico o la chiusura delal lista di prelievo
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        protected void btnPrendiInCarico_Click(object sender, EventArgs e)
        {
            // leggo valori da sessione
            string codLista = memLayer.ML.StringSessionObj("CodLista_sel");
            // leggo il comando ed il soggetto...
            Button btn = (Button)sender;
            string _comando = btn.CommandArgument;
            string CodSoggetto = MagClass.magazzino.CodSoggCurrUser;
            // controllo cosa fare
            switch (_comando)
            {
                case "IniziaListaPrelievo":
                    iniziaListaPrelievo(codLista, CodSoggetto);
                    break;
                case "CompletaListaPrelievo":
                    completaListaPrelievo(codLista, CodSoggetto);
                    // ricarico x evitare proliferazione "_" su prima colonna
                    Response.Redirect("~/ListePrelievo.aspx");
                    break;
            }
            // aggiorno visualizzazione
            updateBtnPrendiInCarico(codLista);
            setBarcodeBtn();
            grViewDetail.DataBind();
        }
        /// <summary>
        /// mostra selettori periodo x liste di prelievo
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        protected void btnShowPeriodo_Click(object sender, EventArgs e)
        {
            btnShowPeriodo.Visible = false;
            mod_periodoAnalisi1.Visible = true;
        }

        /// <summary>
        /// wrapper per log con salvataggio dell'IP del chiamante
        /// </summary>
        /// <param name="_testoPre"></param>
        /// <returns></returns>
        public bool httpLog(string _testoPre)
        {
            bool answ = false;
            string postazione_IP = "";
            try
            {
                postazione_IP = string.Format(" | {0} | ", Request.UserHostName);
            }
            catch
            { }
            logger.lg.scriviLog(postazione_IP + _testoPre);
            return answ;
        }
        /// <summary>
        /// wrapper per log con salvataggio dell'IP del chiamante
        /// </summary>
        /// <param name="_testoPre"></param>
        /// <returns></returns>
        public bool httpLog(string testoLog, tipoLog tipo)
        {
            bool answ = false;
            string postazione_IP = "";
            try
            {
                postazione_IP = string.Format(" | {0} | ", Request.UserHostName);
            }
            catch
            { }
            logger.lg.scriviLog(postazione_IP + testoLog, tipo);
            return answ;
        }
    }
}