GMW/GMW/GMW_data/MagClass.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using SteamWare;

namespace GMW_data
{
    /// <summary>
    /// classe gestione operazioni sul magazzino
    /// </summary>
    public class MagClass
    {
        #region area table adapters

        // variabile di tipo table adapter
        public DS_magazzinoTableAdapters.AnagMagTableAdapter taAnagMag;
        public DS_magazzinoTableAdapters.BlocchiTableAdapter taBlocchi;
        public DS_magazzinoTableAdapters.CelleTableAdapter taCelle;
        public DS_magazzinoTableAdapters.TipoCellaTableAdapter taTipoCella;
        public DS_magazzinoTableAdapters.ElencoCartelliniTableAdapter taCartellini;
        public DS_magazzinoTableAdapters.PosizioneUdcCorrenteTableAdapter taPosUdcCorr;
        public DS_magazzinoTableAdapters.PosizioneUdcStoricoTableAdapter taPosUdcStorico;
        public DS_magazzinoTableAdapters.V_MagazziniOverviewTableAdapter taMagOverw;
        public DS_magazzinoTableAdapters.V_DettMagPartTableAdapter taDettMagPart;
        public DS_magazzinoTableAdapters.v_UdcDetailTableAdapter taDettUDC;
        public DS_magazzinoTableAdapters.ElencoListePrelievoTableAdapter taElencoListePrelievo;
        public DS_magazzinoTableAdapters.ElencoCartelliniTableAdapter taElencoCartellini;
        public DS_magazzinoTableAdapters.RigheListePrelievoTableAdapter taRigheListePrelievo;
        public DS_magazzinoTableAdapters.TipoListaPrelievoTableAdapter taTipoListaPrelievo;
        public DS_magazzinoTableAdapters.V_ParticolariOverviewTableAdapter taVParticolariOverwiew;
        public DS_magazzinoTableAdapters.v_particolariEsponenteFiguraTableAdapter taPartExpFig;
        public DS_magazzinoTableAdapters.V_statoCelleCapienzaAssegnatiTableAdapter taStatoCelle;
        public DS_magazzinoTableAdapters.RapQualTableAdapter taRapQual;
        public DS_magazzinoTableAdapters.v_RapQualSuntoTableAdapter taRQ_sunto;
        public DS_magazzinoTableAdapters.v_posizioniDelibereTableAdapter taPosizDelib;
        public DS_magazzinoTableAdapters.AnagParticolariTableAdapter taAnagPart;
        public DS_magazzinoTableAdapters.AnagPosizioniTableAdapter taAnagPos;


        /// <summary>
        /// init dei table adapters
        /// </summary>
        protected void initTA()
        {
            // istanzio oggetto

            taAnagMag = new GMW_data.DS_magazzinoTableAdapters.AnagMagTableAdapter();
            taBlocchi = new GMW_data.DS_magazzinoTableAdapters.BlocchiTableAdapter();
            taCelle = new GMW_data.DS_magazzinoTableAdapters.CelleTableAdapter();
            taTipoCella = new GMW_data.DS_magazzinoTableAdapters.TipoCellaTableAdapter();
            taCartellini = new GMW_data.DS_magazzinoTableAdapters.ElencoCartelliniTableAdapter();
            taPosUdcCorr = new GMW_data.DS_magazzinoTableAdapters.PosizioneUdcCorrenteTableAdapter();
            taPosUdcStorico = new GMW_data.DS_magazzinoTableAdapters.PosizioneUdcStoricoTableAdapter();
            taMagOverw = new GMW_data.DS_magazzinoTableAdapters.V_MagazziniOverviewTableAdapter();
            taDettMagPart = new GMW_data.DS_magazzinoTableAdapters.V_DettMagPartTableAdapter();
            taDettUDC = new GMW_data.DS_magazzinoTableAdapters.v_UdcDetailTableAdapter();
            taElencoListePrelievo = new GMW_data.DS_magazzinoTableAdapters.ElencoListePrelievoTableAdapter();
            taElencoCartellini = new GMW_data.DS_magazzinoTableAdapters.ElencoCartelliniTableAdapter();
            taRigheListePrelievo = new GMW_data.DS_magazzinoTableAdapters.RigheListePrelievoTableAdapter();
            taTipoListaPrelievo = new GMW_data.DS_magazzinoTableAdapters.TipoListaPrelievoTableAdapter();
            taVParticolariOverwiew = new GMW_data.DS_magazzinoTableAdapters.V_ParticolariOverviewTableAdapter();
            taPartExpFig = new GMW_data.DS_magazzinoTableAdapters.v_particolariEsponenteFiguraTableAdapter();
            taStatoCelle = new GMW_data.DS_magazzinoTableAdapters.V_statoCelleCapienzaAssegnatiTableAdapter();
            taRapQual = new GMW_data.DS_magazzinoTableAdapters.RapQualTableAdapter();
            taRQ_sunto = new GMW_data.DS_magazzinoTableAdapters.v_RapQualSuntoTableAdapter();
            taPosizDelib = new GMW_data.DS_magazzinoTableAdapters.v_posizioniDelibereTableAdapter();
            taAnagPart = new GMW_data.DS_magazzinoTableAdapters.AnagParticolariTableAdapter();
            taAnagPos = new GMW_data.DS_magazzinoTableAdapters.AnagPosizioniTableAdapter();
        }
        /// <summary>
        /// effettua setup dei connection strings da web.config delal singola applicazione
        /// </summary>
        protected virtual void setupConnectionStringBase()
        {
            string connString = memLayer.ML.confReadString("GMWConnectionString");
            // connections del db
            taAnagMag.Connection.ConnectionString = connString;
            taBlocchi.Connection.ConnectionString = connString;
            taCelle.Connection.ConnectionString = connString;
            taTipoCella.Connection.ConnectionString = connString;
            taCartellini.Connection.ConnectionString = connString;
            taPosUdcCorr.Connection.ConnectionString = connString;
            taPosUdcStorico.Connection.ConnectionString = connString;
            taMagOverw.Connection.ConnectionString = connString;
            taDettMagPart.Connection.ConnectionString = connString;
            taDettUDC.Connection.ConnectionString = connString;
            taElencoListePrelievo.Connection.ConnectionString = connString;
            taElencoCartellini.Connection.ConnectionString = connString;
            taRigheListePrelievo.Connection.ConnectionString = connString;
            taTipoListaPrelievo.Connection.ConnectionString = connString;
            taVParticolariOverwiew.Connection.ConnectionString = connString;
            taPartExpFig.Connection.ConnectionString = connString;
            taStatoCelle.Connection.ConnectionString = connString;
            taRapQual.Connection.ConnectionString = connString;
            taRQ_sunto.Connection.ConnectionString = connString;
            taPosizDelib.Connection.ConnectionString = connString;
            taAnagPart.Connection.ConnectionString = connString;
            taAnagPos.Connection.ConnectionString = connString;
        }

        #endregion

        #region Inizializzazione

        protected MagClass()
        {
            initTA();
            setupConnectionStringBase();
        }

        /// <summary>
        /// oggetto static per fare chiamate sul magazzino
        /// </summary>
        public static MagClass magazzino = new MagClass();

        #endregion

        #region metodi protected

        /// <summary>
        /// aggiunge le righe liste di prelievo necessarie a soddisfare la richiesta in logica FIFO dato un elenco di cartellini, la qta totale da allocare e la lista attuale
        /// </summary>
        /// <param name="QtaTot"></param>
        /// <param name="codListaAttuale"></param>
        /// <param name="tabellaElencoCartellini"></param>
        private void allocaRigheListaPrelievo(decimal QtaTot, string codListaAttuale, DS_magazzino.ElencoCartelliniDataTable tabellaElencoCartellini)
        {
            //ricavo il valore UDC della riga del più vecchio
            string udcAttuale;
            bool qtaOk = false;
            bool dataFinished = false;
            int progrUdc = 0;
            int numUdcDisponibili = tabellaElencoCartellini.Rows.Count;
            // contiene la quantità della riga attuale
            decimal qtaRiga;
            // somma progressiva della qta allocata - calcolo da db!
            decimal qtaAllocata = taElencoListePrelievo.getByCodLista(codListaAttuale)[0].Prelevato;
            //ciclo WHILE per lo riempimento FIFO con UDC secondo richiesta a partire da elenco fornito
            while (!qtaOk && !dataFinished)
            {
                /*
                 * crea una riga in righelistaprelievo passando come valori 
                 * il codlista attuale ricavato da sopr
                 * l'UDC dal primo della tabella getOlderUDC 
                 * 
                 * 
                 * recupero quantità dalla riga corrente;
                 * 
                 * imposto proposto a 1;
                 * imposto prelevato 0;
                 * taRighelistePreliveo.Insert;
                 * 
                 * qtaAllocata = qtaAllocata + Qta di questa riga (riuso il valore della colonna QTA
                 * tabella[contatore]; contatore++; 
                 * qtaOk = (qtaAllocata >= qtaRichiesta)
                 * dataFinished = (contatore >= numRighe);
                 * 
                 * */
                // ricavo la riga più vecchia
                qtaRiga = tabellaElencoCartellini[progrUdc].Qta;
                udcAttuale = tabellaElencoCartellini[progrUdc].UDC;
                // eseguo query di insert
                taRigheListePrelievo.Insert(codListaAttuale, udcAttuale, qtaRiga, true, false);

                //incremento qta allocata
                qtaAllocata = (qtaAllocata + qtaRiga);
                //incremento contatore
                progrUdc++;

                // verifico le condizioni, false se non cambia nulla true se cambia e si esce dal while
                qtaOk = (qtaAllocata >= QtaTot);
                dataFinished = (progrUdc >= numUdcDisponibili);
            }
        }

        #endregion

        #region Metodi esposti

        #region operazioni su UDC

        /// <summary>
        /// effettua lo spostamento di un UDC tra 2 posizioni indicate
        /// </summary>
        /// <param name="CodCS">Codice company/sito</param>
        /// <param name="UDC">Codice UDC</param>
        /// <param name="IdxCellaTo">Cella di destinazione</param>
        /// <param name="resetRLP">indica se sia richiesto resettare le Righe Liste Prelievo con lo spostsamento</param>
        /// <returns>esito comando</returns>
        public bool spostaUDC(string CodCS, string UDC, int IdxCellaTo, bool resetRLP)
        {
            bool answ = false;
            try
            {
                taPosUdcCorr.stp_spostaUdc(CodCS, UDC, IdxCellaTo, resetRLP);
                // cerco nuova posizione...
                if (taPosUdcCorr.getByCellaUdc(UDC, IdxCellaTo).Rows.Count > 0)
                {
                    answ = true;
                }
            }
            catch (Exception e)
            {
                logger.lg.scriviLog(string.Format("Errore durante spostamento cella: {0}", e), tipoLog.EXCEPTION);
            }
            // solo se ha fatto spostamento posizione corrente verifico se fare spostamento in posizione LOGICA magazzino
            if (answ)
            {
                try
                {
                    // verifico tipo cella e se ci sia da fare spostamento in mag logico/contabile
                    int idxTipoCella = taCelle.getByIdxCella(IdxCellaTo)[0].IdxTipoCella;
                    bool needSetMag = taTipoCella.getByIdx(idxTipoCella)[0].SetMag;
                    if (needSetMag)
                    {
                        // cambio (eventualmente) la posizione "logica" dato lo spostamento (il codice magazzino...)
                        int idxBlocco = taCelle.getByIdxCella(IdxCellaTo)[0].IdxBlocco;
                        int idxPosizione = Convert.ToInt32(taBlocchi.getByIdx(idxBlocco)[0].CodMag);
                        taCartellini.updateIdxPosizione(UDC, idxPosizione);
                    }
                }
                catch (Exception e)
                {
                    logger.lg.scriviLog(string.Format("Errore durante indicazione posizione UDC: {0}", e), tipoLog.EXCEPTION);
                }
            }
            return answ;
        }
        /// <summary>
        /// effettua lo scaricamento di un UDC (x spedizione)
        /// </summary>
        /// <param name="UDC">Codice UDC</param>
        /// <param name="IdxCellaFrom">Cella di origine</param>
        /// <param name="IdxPosizUdc">Codice posizione UDC finale</param>
        /// <returns>esito comando</returns>
        public bool scaricaUDC(string UDC, int IdxCellaFrom, int IdxPosizUdc)
        {
            bool answ = false;
            try
            {
                taPosUdcCorr.stp_scaricaUdc(UDC, IdxCellaFrom, IdxPosizUdc);
                answ = true;
            }
            catch
            { }
            return answ;
        }
        /// <summary>
        /// rettifica la qta di un UDC
        /// </summary>
        /// <param name="CodSoggetto">Codice soggetto/operatore</param>
        /// <param name="UDC">Codice UDC</param>
        /// <param name="qta">Nuova quantita associata</param>
        /// <returns>esito comando</returns>
        public bool rettificaQtaUDC(string UDC, decimal qta)
        {
            string CodSoggetto = CodSoggCurrUser;
            bool answ = false;
            try
            {
                int fatti = 0;
                fatti = taCartellini.updateQty(UDC, CodSoggetto, "U", "UDC_QTY", qta).Rows.Count;
                if (fatti > 0)
                {
                    answ = true;
                }
            }
            catch
            { }
            return answ;
        }
        /// <summary>
        /// verifica se l'UDC indicato sia valido, ovvero esistente
        /// </summary>
        /// <param name="UDC"></param>
        /// <returns></returns>
        public bool checkUDC(string UDC)
        {
            bool answ = false;
            try
            {
                answ = (taElencoCartellini.getDetailsUdcByUdc(UDC).Rows.Count > 0);
            }
            catch
            { }
            return answ;
        }
        /// <summary>
        /// effettua lo scaricamento (da db e da AS400) degli UDC di MP/WIP
        /// </summary>
        /// <param name="UDC"></param>
        /// <returns></returns>
        public bool scaricaUdcMpWip(string UDC)
        {
            // inizializzo
            bool answ = false;
            int idxCellaFrom = 0;
            int idxPosizUdcCorr = 0;
            int idxPosizUdcDest = 0;
            // calcolo posizione UDC corrente (se c'è...)
            try
            {
                // mi serve per posizione udc corrente
                DS_magazzino.PosizioneUdcCorrenteRow rigaUdcCorrente = taPosUdcCorr.getByUDC(UDC)[0];
                // il secondo idx che mi serve
                idxCellaFrom = rigaUdcCorrente.IdxCella;
            }
            catch (Exception e)
            {
                logger.lg.scriviLog(string.Format("Errore in fase di recupero cella per l'UDC {0}: {1}{2}", UDC, Environment.NewLine, e), tipoLog.EXCEPTION);
            }
            // ora calcolo gli altri dati dalla rica ElencoCartellini dell'UDC
            try
            {
                // calcolo posizione destinazione da state machine...
                idxPosizUdcCorr = taElencoCartellini.getDetailsUdcByUdc(UDC)[0].IdxPosizione;
                idxPosizUdcDest = StateMachine.SM.getIdxPostizioneTo("UDC_CONS", idxPosizUdcCorr);
            }
            catch (Exception e)
            {
                logger.lg.scriviLog(string.Format("Errore in fase di recupero dati posizioni from/to per l'UDC {0}: {1}{2}", UDC, Environment.NewLine, e), tipoLog.EXCEPTION);
            }
            // ora provo ad eseguire!
            try
            {
                if (idxPosizUdcDest != 0) // solo se c'è una posizione da cui poter fare lo scaricamento...
                {
                    // sposto UDC
                    answ = scaricaUDC(UDC, idxCellaFrom, idxPosizUdcDest);
                }
            }
            catch (Exception e)
            {
                logger.lg.scriviLog(string.Format("Errore in fase di scaricamneto dell'UDC {0}: {1}{2}", UDC, Environment.NewLine, e), tipoLog.EXCEPTION);
            }

            return answ;
        }
        /// <summary>
        /// riattiva un UDC (se permesso) da una posizione consumata ad una valida
        /// </summary>
        /// <param name="UDC"></param>
        /// <param name="CodSoggetto"></param>
        /// <returns></returns>
        public bool riattivaUdc(string UDC, string CodSoggetto)
        {
            // init
            bool answ = false;
            try
            {
                // salvo dati cartellino PRE
                DS_Applicazione.ElencoCartelliniRow rigaUdcPre = DataProxy.obj.taCartellini.stp_getByUdc(UDC)[0];
                GMW_data.DataProxy.obj.taCartellini.stp_riattivaUdc(UDC, CodSoggetto);
                // salvo dati cartellino POST
                DS_Applicazione.ElencoCartelliniRow rigaUdcPost = DataProxy.obj.taCartellini.stp_getByUdc(UDC)[0];
                answ = true;
            }
            catch (Exception e)
            {
                logger.lg.scriviLog(string.Format("Eccezione: {0}{1}", Environment.NewLine, e), tipoLog.EXCEPTION);
            }

            return answ;
        }
        /// <summary>
        /// sblocca un UDC (se permesso)
        /// </summary>
        /// <param name="UDC"></param>
        /// <param name="CodSoggetto"></param>
        /// <returns></returns>
        public bool sbloccaUdc(string UDC, string CodSoggetto)
        {
            // init
            bool answ = false;
            try
            {
                GMW_data.DataProxy.obj.taCartellini.stp_sbloccaUdc(UDC, CodSoggetto);
                answ = true;
            }
            catch (Exception e)
            {
                logger.lg.scriviLog(string.Format("Eccezione: {0}{1}", Environment.NewLine, e), tipoLog.EXCEPTION);
            }
            return answ;
        }
        /// <summary>
        /// controlla se l'udc delal qualità indicato ha benestare qualità ("S")
        /// </summary>
        /// <param name="UDC"></param>
        /// <returns></returns>
        public bool udcMpHasBenesQual(string UDC)
        {
            bool answ = false;
            try
            {
                DS_magazzino.RapQualRow rigaRapQual = taRapQual.getByUdc(UDC)[0];
                if (rigaRapQual.BenesQual == "S")
                {
                    answ = true;
                }
            }
            catch
            { }
            return answ;
        }

        #endregion

        #region procedure di verifica e traduzione dati da anagrafiche

        /// <summary>
        /// Verifica la corrispondenza dati tra RigheListePrelievo ed ElencoCartellini
        /// </summary>
        /// <param name="CodLista"></param>
        /// <param name="UDC"></param>
        /// <returns></returns>
        public bool verificaDatiUdc(string CodLista, string UDC)
        {
            bool answ = false;

            try
            {
                DS_magazzino.ElencoListePrelievoDataTable tabellaElenco = taElencoListePrelievo.getByCodLista(CodLista);
                DS_magazzino.ElencoListePrelievoRow rigaElenco = tabellaElenco[0];

                DS_magazzino.ElencoCartelliniDataTable tabellaUDC = taElencoCartellini.getDetailsUdcByUdc(UDC);
                DS_magazzino.ElencoCartelliniRow rigaUDC = tabellaUDC[0];

                // ricavo dati da confrontare - da Lista ricavo particolare/esponente/figura
                string particolareLista = rigaElenco.Particolare.Trim();
                string esponenteLista = rigaElenco.Esponente.Trim();
                string figuraLista = rigaElenco.Figura.Trim();
                string codImballoLista = rigaElenco.CodImballo.Trim();

                //stessi dati da UDC
                string particolareUDC = rigaUDC.Particolare.Trim();
                string esponenteUDC = rigaUDC.Esponente.Trim();
                string figuraUDC = rigaUDC.Figura.Trim();
                string codImballoUDC = rigaUDC.CodImballo.Trim();

                // condizioni di uguaglianza...
                bool particolareOk = false;
                bool esponenteOk = false;
                bool figuraOk = false;
                bool codImballoOk = false;
                // verifico le condizioni 1 ad 1...
                particolareOk = (particolareLista == particolareUDC);
                if (esponenteLista == "*")
                {
                    esponenteOk = true;
                }
                else
                {
                    esponenteOk = (esponenteLista == esponenteUDC);
                }
                if (figuraLista == "*")
                {
                    figuraOk = true;
                }
                else
                {
                    figuraOk = (figuraLista == figuraUDC);
                }
                if (codImballoLista == "*")
                {
                    codImballoOk = true;
                }
                else
                {
                    codImballoOk = (codImballoLista == codImballoUDC);
                }

                // verifica finale del risultato uguaglianza...
                answ = (particolareOk && esponenteOk && figuraOk && codImballoOk);
            }
            catch
            {
                answ = false;
            }

            return answ;
        }
        /// <summary>
        /// restituisce codice soggetto dell'user corrente
        /// </summary>
        /// <returns></returns>
        public string CodSoggCurrUser
        {
            get
            {
                // ricavo da session...
                string codSoggetto = "";
                try
                {
                    codSoggetto = DataProxy.obj.taSogg2Oper.getByUserDominio(user_std.UtSn.utente, user_std.UtSn.dominio)[0].CodSoggetto;
                    // salvo in sessione...
                    memLayer.ML.setSessionVal("CodSoggetto", codSoggetto);
                }
                catch (Exception e)
                {
                    logger.lg.scriviLog(string.Format("Non sono riuscito a recuperare il codice soggetto per l'utente loggato: {0}, errore {1}{2}", user_std.UtSn.userNameAD, Environment.NewLine, e), tipoLog.ERROR);
                }
                return codSoggetto;
            }
        }
        /// <summary>
        /// restituisce l'IdxCella dato il CodCella
        /// </summary>
        /// <param name="CodCS">Codice company/sito</param>
        /// <param name="CodCella"></param>
        /// <returns></returns>
        public int IdxCellaByCodCella(string CodCS, string CodCella)
        {
            int answ = 0;
            try
            {
                answ = taCelle.getByCodCella(CodCella)[0].IdxCella; // NON controllo il CodCS...
            }
            catch
            { }
            return answ;
        }
        /// <summary>
        /// restituisce il CodCella dato l'IdxCella
        /// </summary>
        /// <param name="CodCS">Codice company/sito</param>
        /// <param name="IdxCella"></param>
        /// <returns></returns>
        public string CodCellaByIdxCella(string CodCS, int IdxCella)
        {
            string answ = "";
            try
            {
                answ = taCelle.getByIdxCella(IdxCella)[0].CodCella; // NON controllo il CodCS...
            }
            catch
            { }
            return answ;
        }
        /// <summary>
        /// verifica se la cella indicata sia attiva
        /// </summary>
        /// <param name="CodCS">Codice company/sito</param>
        /// <param name="IdxCella"></param>
        /// <returns></returns>
        public bool cellaAttiva(string CodCS, int IdxCella)
        {
            bool answ = false;
            try
            {
                answ = taCelle.getByIdxCella(IdxCella)[0].Attiva; // NON controllo il CodCS...
            }
            catch
            { }
            return answ;
        }
        /// <summary>
        /// verifica se la cella indicata sia piena
        /// </summary>
        /// <param name="CodCS">Codice company/sito</param>
        /// <param name="IdxCella"></param>
        /// <returns></returns>
        public bool cellaPiena(string CodCS, int IdxCella)
        {
            bool answ = false;
            try
            {
                answ = taCelle.getByIdxCella(IdxCella)[0].Piena; // NON controllo il CodCS...
            }
            catch
            { }
            return answ;
        }
        /// <summary>
        /// verifica la cella indicata sia valida, ovvero esistente
        /// </summary>
        /// <param name="CodCella"></param>
        /// <returns></returns>
        public bool checkCella(string CodCella)
        {
            bool answ = false;
            try
            {
                answ = (taCelle.getByCodCella(CodCella).Rows.Count > 0);
            }
            catch
            { }
            return answ;
        }
        /// <summary>
        /// verifica se il particolare indicato sia valido, ovvero esistente
        /// </summary>
        /// <param name="CodCS">Codice company/sito</param>
        /// <param name="Particolare"></param>
        /// <returns></returns>
        public bool checkParticolare(string CodCS, string Particolare)
        {
            bool answ = false;
            try
            {
                answ = (taVParticolariOverwiew.getByParticolareFull(Particolare, CodCS).Rows.Count > 0);
            }
            catch
            { }
            return answ;
        }
        /// <summary>
        /// restituisce il num di UDC che corrispondono alla richiesta indicata
        /// </summary>
        /// <param name="CodCS"></param>
        /// <param name="Particolare"></param>
        /// <param name="codEsponente"></param>
        /// <param name="codFigura"></param>
        /// <param name="codImballo"></param>
        /// <param name="codTipoLista"></param>
        /// <returns></returns>
        public int numUdcDaPart(string CodCS, string Particolare, string codEsponente, string codFigura, string codImballo, string codTipoLista)
        {
            int answ = 0;
            try
            {
                answ = taVParticolariOverwiew.getByDatiListaPrelievo(Particolare, CodCS, codEsponente, codFigura, codImballo, codTipoLista)[0].NumUDC;
            }
            catch
            { }
            return answ;
        }
        /// <summary>
        /// verifica se l'UDC sia riattivabile, ovvero
        /// - sia permesso da web.config
        /// - l'UDC sia in un mag che permette riattivazione
        /// </summary>
        /// <param name="UDC"></param>
        /// <returns></returns>
        public bool udcIsRiattivabile(string UDC)
        {
            bool answ = false;
            // se permesso da web config controllo
            if (memLayer.ML.confReadBool("riattUdcPermessa"))
            {
                try
                {
                    // recupero posizione attuale
                    int idxPosizione = taElencoCartellini.getDetailsUdcByUdc(UDC)[0].IdxPosizione;
                    // verifico se riattivabile
                    answ = taAnagPos.getByIdxPosizione(idxPosizione)[0].IsRiattivaEnabled;
                }
                catch (Exception e)
                {
                    logger.lg.scriviLog(string.Format("Errore nella riattivazione dell'UDC {0}:{1}{2}", UDC, Environment.NewLine, e), tipoLog.EXCEPTION);
                }
            }
            return answ;
        }

        #endregion

        #region liste di prelievo

        /// <summary>
        /// Crea una lista di prelievo andando a prenotare gli UDC del particolare richiesto in logica FIFO
        /// </summary>
        /// <param name="CodCS"></param>
        /// <param name="TipoListaPrelievo"></param>
        /// <param name="Particolare"></param>
        /// <param name="Esponente"></param>
        /// <param name="Figura"></param>
        /// <param name="QtaTot"></param>
        /// <param name="CodImballo"></param>
        /// <param name="Destinatario"></param>
        /// <param name="DestinatarioDescrizione"></param>
        /// <returns></returns>
        public string creaListaPrelievo(string CodCS, string TipoListaPrelievo, string Particolare, string Esponente, string Figura, decimal QtaTot, string CodImballo, string Destinatario, string DestinatarioDescrizione)
        {
            /*
             * - ordini gli UDC per data dal + vecchio (data fusione? direi di si!)
             * 
             * - prenda 1 ad 1 gli UDC, e crei dall'UDC un record in RigheListePrelievo con 
             *   - CodLista (dal record appena generato)
             *   - UDC (il + vecchio trovato)
             *   - QTA (dell'UDC)
             *   - Proposto = 1 (vero)
             *   - Prelevato = 0 (falso)
             * - questo loop di prelievo va eseguito fino a quanto la somam delle qty sia maggiore o uguale alla qty richiesta, o fino a quando siano finiti gli UDC
             * 
             * - potrebbe esser cambiato approccio e si potrebbe fare una query ceh seleziona i + vecchi UDC in numero corretto fin dall'inizio da includere facendo una cosa del tipo
             *   - calcolo media qty degli UDC papabili x le condizioni dette prima
             *   - dato il totale ottengo quanti UDC mi servono arrotondando x eccesso (se ho 200 richiesti, media 70, CEIL(200/70) = 3)
             *   - faccio un SELECT TOP n (qui 3) * FROM ElencoCartellini WHERE ...
             *   - e questa select la uso x farci un INSERT INTO in RigheListePrelievo
             * 
             * - terminati questi step si aggiorna la lista di prelievo emttendo come qty quella data dalla somma degli UDC davvero proposti
             * 
             * - la stored deve restituire il codice della lista di prelievo e passarla qui, che a sua volta passerà al chiamante il codice della lista
             * */

            string answ = "K";

            // variabile di tipo datetime per data corrente
            DateTime adesso = DateTime.Now;
            // non la valorizzo qui ma calcolo ... se non fa verificare
            string RagioneSociale = "";

            // ricavo da session...
            string codSoggetto = CodSoggCurrUser;
            // proseguo SOLO se ho trovato cod soggetto...
            if (codSoggetto != "")
            {
                // li ricavo da db successivamente
                string disegnoGrezzo = "";
                string descParticolare = "";
                string codCliente = "";


                // ricavo codCliente
                try
                {
                    codCliente = DataProxy.obj.taAnagParticolari.getByParticolare(Particolare)[0].CodCliente;
                }
                catch { }

                // ricavo disegnoGrezzo
                try
                {
                    disegnoGrezzo = DataProxy.obj.taAnagParticolari.getByParticolare(Particolare)[0].DisegnoGrezzo;
                }
                catch { }

                try
                {
                    descParticolare = DataProxy.obj.taAnagParticolari.getByParticolare(Particolare)[0].DescParticolare;
                }
                catch { }

                // dato codcliente ricavo la ragione sociale
                try
                {
                    RagioneSociale = DataProxy.obj.taAnagClienti.getRagioneSocialeByCodCliente(codCliente)[0].RagSociale;
                }
                catch { }


                string codListaAttuale = "";
                try
                {
                    // eseguo soltanto la query (meglio con try catch così se non c'è non dà errore...)
                    DS_magazzino.ElencoListePrelievoDataTable tabellaElencoListe = taElencoListePrelievo.InsertQuery(string.Format("{0:yy}", adesso), string.Format("{0:MM}", adesso), TipoListaPrelievo, memLayer.ML.confReadString("CodCS"), codCliente, RagioneSociale, codSoggetto, Particolare, descParticolare, disegnoGrezzo, Esponente, Figura, CodImballo, QtaTot, Destinatario, DestinatarioDescrizione);

                    // ricavo prima (e unica) riga dalla select
                    DS_magazzino.ElencoListePrelievoRow rigaElencoListe = tabellaElencoListe[0];

                    // ricavo valore del CodLista attuale appena inserito
                    codListaAttuale = rigaElencoListe.CodLista;
                }
                catch (Exception e)
                {
                    logger.lg.scriviLog(string.Format("Eccezione creazione lista prelievo: {0}{1}", Environment.NewLine, e), tipoLog.ERROR);
                }
                if (codListaAttuale != "")
                {
                    answ = codListaAttuale;
                    DS_magazzino.ElencoCartelliniDataTable tabellaElencoCartellini = taElencoCartellini.getUdcUnusedOlder(codListaAttuale);
                    allocaRigheListaPrelievo(QtaTot, codListaAttuale, tabellaElencoCartellini);
                }
            }
            return answ;
        }
        /// <summary>
        /// indica come attivata in carico di una lista di prelievo
        /// </summary>
        /// <param name="CodCS">Codice company/sito</param>
        /// <param name="CodLista">codice della lista di prelievo</param>
        /// <param name="CodSoggetto">cod operatore carrellista</param>
        /// <returns></returns>
        public esitoOperazione attivaListaPrelievo(string CodCS, string CodLista, string CodSoggetto)
        {
            // da chiamare quando clicco e inizio lista prelievo .... vedi sopra
            esitoOperazione answ = esitoOperazione.errore;

            try
            {
                // la query recupera la lista in base al CodLista
                DS_magazzino.ElencoListePrelievoDataTable tabella = taElencoListePrelievo.getByCodLista(CodLista);
                DS_magazzino.ElencoListePrelievoRow riga = tabella[0];

                // se la lista esiste...
                if (tabella.Rows.Count > 0)
                {
                    // se la lista è ancora non completata
                    if (riga.CodStatoLista == (int)statoLista.bozza)
                    {
                        taElencoListePrelievo.updateStato(CodSoggetto, CodLista, (int)statoLista.generata);
                        answ = esitoOperazione.ok;
                    }
                    // se è già completata o iniziata dà errore
                    else
                    {
                        answ = esitoOperazione.errore_readOnly;
                    }
                }
                // se la lista non esiste dai errore
                else
                {
                    answ = esitoOperazione.errore;
                }
            }
            catch
            { }
            return answ;
        }
        /// <summary>
        /// indica presa in carico di una lista di prelievo
        /// </summary>
        /// <param name="CodCS">Codice company/sito</param>
        /// <param name="CodLista">codice della lista di prelievo</param>
        /// <param name="CodSoggetto">cod operatore carrellista</param>
        /// <returns></returns>
        public esitoOperazione iniziaListaPrelievo(string CodCS, string CodLista, string CodSoggetto)
        {
            memLayer.ML.setSessionVal("activeTask", string.Format("Lista Prelievo {0}", CodLista));
            memLayer.ML.setSessionVal("CodListaAttiva", CodLista, true);
            // da chiamare quando clicco e inizio lista prelievo .... vedi sopra
            esitoOperazione answ = esitoOperazione.errore;

            try
            {
                // la query recupera la lista in base al CodLista
                DS_magazzino.ElencoListePrelievoDataTable tabella = taElencoListePrelievo.getByCodLista(CodLista);
                DS_magazzino.ElencoListePrelievoRow riga = tabella[0];

                // se la lista esiste...
                if (tabella.Rows.Count > 0)
                {
                    // se la lista è ancora non completata
                    if (riga.CodStatoLista == (int)statoLista.generata)
                    {
                        taElencoListePrelievo.updateStato(CodSoggetto, CodLista, (int)statoLista.iniziata);
                        answ = esitoOperazione.ok;
                    }
                    // se è già completata o iniziata dà errore
                    else
                    {
                        answ = esitoOperazione.errore_readOnly;
                    }
                }
                // se la lista non esiste dai errore
                else
                {
                    answ = esitoOperazione.errore;
                }
            }
            catch
            { }
            return answ;
        }
        /// <summary>
        /// indica come completata (da parte del magazziniere) una lista di prelievo
        /// </summary>
        /// <param name="CodCS">Codice company/sito</param>
        /// <param name="CodLista">codice della lista di prelievo</param>
        /// <param name="CodSoggetto">cod operatore carrellista</param>
        /// <returns></returns>
        public esitoOperazione completaListaPrelievo(string CodCS, string CodLista, string CodSoggetto)
        {
            memLayer.ML.emptySessionVal("CodListaAttiva");
            memLayer.ML.emptySessionVal("activeTask");
            // da chiamare quando clicco e inizio lista prelievo .... vedi sopra
            esitoOperazione answ = esitoOperazione.errore;
            try
            {
                // la query recupera la lista in base al CodLista
                DS_magazzino.ElencoListePrelievoDataTable tabella = taElencoListePrelievo.getByCodLista(CodLista);
                DS_magazzino.ElencoListePrelievoRow riga = tabella[0];

                // se la lista esiste...
                if (tabella.Rows.Count > 0)
                {
                    // se la lista è ancora non completata
                    if (riga.CodStatoLista == (int)statoLista.iniziata)
                    {
                        // controllo se ALMENO un UDC sia stsato prelevato
                        int numUdcPrelevati = taRigheListePrelievo.getByCodListaPrelevate(CodLista).Rows.Count;
                        if (numUdcPrelevati > 0)
                        {
                            // ricavo il codtipolista
                            string codTipoListaAttuale = riga.CodTipoLista;

                            //leggo da tipoLista prelievo alcuni dati (es codcella di destinazione)
                            DS_magazzino.TipoListaPrelievoDataTable tabellaTipoLista = taTipoListaPrelievo.getByCodTipoLista(codTipoListaAttuale);
                            DS_magazzino.TipoListaPrelievoRow rigaTipoLista = tabellaTipoLista[0];

                            // leggo da righe lista prelievo il dato udc che mi serve
                            DS_magazzino.RigheListePrelievoDataTable tabellaRigheListaPrelievo = taRigheListePrelievo.getByCodListaPrelevate(CodLista);
                            DS_magazzino.RigheListePrelievoRow rigaListaPrelievo = tabellaRigheListaPrelievo[0];

                            // leggo il codice della cella...
                            string codCellaDestAttuale = rigaTipoLista.CodCella;
                            // lo trasformo x avere la cella di destinazione...
                            int idxCellaTo = taCelle.getByCodCella(codCellaDestAttuale)[0].IdxCella;
                            // sposto ("metto a terra") gli UDC
                            foreach (DS_magazzino.RigheListePrelievoRow row in tabellaRigheListaPrelievo.Rows)
                            {
                                // ricavo il codice UDC...
                                string _UDC = row.UDC;
                                // sposto UDC
                                spostaUDC(CodCS, _UDC, idxCellaTo, false);
                                // dopo aver spostato UDC sistemo eventuali Righe di Prelievo x lo stesso UDC pending...
                                taRigheListePrelievo.stp_RLP_sbloccaNonPrelevate(CodLista, _UDC);
                            }
                            // libero le righe non prelevate...
                            taRigheListePrelievo.stp_RLP_eliminaNonPrelevate(CodLista);
                            // aggiorno stato lista
                            taElencoListePrelievo.updateStato(CodSoggetto, CodLista, (int)statoLista.completata);
                            answ = esitoOperazione.ok;
                        }
                        else //nessun UDC prelevato
                        {
                            answ = esitoOperazione.errore_noUdc;
                        }
                    }
                    // se è già completata o NON iniziata dà errore
                    else
                    {
                        answ = esitoOperazione.errore_readOnly;
                    }
                }
                // se la lista non esiste dai errore
                else
                {
                    answ = esitoOperazione.errore;
                }
            }
            catch
            { }
            return answ;
        }
        /// <summary>
        /// Effettua lo scaricamento della lista di prelievo indicata, ovvero
        /// - toglie dalle posizioni di magazzino tutti gli UDC indicati come prelevati (liberando tali posizioni)
        /// - assegna tutti gli UDC prelevati alla cella indicata per il tipo di lista di prelievo interessata
        /// - elimina eventuali righe di prelievo della lista per UDC non effettivamente prelevate
        /// - chiude la lista di prelievo (completata = 1)
        /// </summary>
        /// <param name="CodCS">Codice company/sito</param>
        /// <param name="CodLista">codice della lista di prelievo</param>
        /// <param name="CodSoggetto">cod operatore carrellista</param>
        /// <returns>esito comando</returns>
        public esitoOperazione scaricaListaPrelievo(string CodCS, string CodLista, string CodSoggetto)
        {
            /*
             * Questa funzione serve ALLA FINE delle operazioni di prelievo, x chiudere la lista di prelievo
             * - controllo se la lista esiste, ed è ancora NON completata
             *  - se risulta già completata errore xché è "readOnly" la lista essendo già completata (vedere l'enum in fondo al codice)
             * - se la lista è ok
             *  - leggo da tipoLista prelievo alcuni dati (es codcella di destinazione)
             *  - sposto TUTTI gli UDC delle righeListaPrelievo, da posizione attuale a posizione indicata da tipo lista 
             *  (quindi da codCella --> IdxCella --> spostamento
             *  indico la lista come completata = 1 (true)
             * */
            // setup eventuali valori x rettifica
            bool fatto = false;

            esitoOperazione answ = esitoOperazione.errore;
            int trovate = 0;
            DS_magazzino.ElencoListePrelievoDataTable tabella;
            DS_magazzino.ElencoListePrelievoRow riga;
            try
            {
                tabella = taElencoListePrelievo.getByCodLista(CodLista);
                riga = tabella[0];
                trovate = tabella.Rows.Count;

                // se la lista esiste...
                if (trovate > 0)
                {
                    // se la lista è completata
                    if (riga.CodStatoLista == (int)statoLista.completata)
                    {
                        // ricavo il codtipolista
                        string codTipoListaAttuale = riga.CodTipoLista;

                        //leggo da tipoLista prelievo alcuni dati (es codcella di destinazione)
                        DS_magazzino.TipoListaPrelievoDataTable tabellaTipoLista = taTipoListaPrelievo.getByCodTipoLista(codTipoListaAttuale);
                        DS_magazzino.TipoListaPrelievoRow rigaTipoLista = tabellaTipoLista[0];

                        // leggo da righe lista prelievo il dato udc che mi serve
                        DS_magazzino.RigheListePrelievoDataTable tabellaRigheListaPrelievo = taRigheListePrelievo.getByCodListaPrelevate(CodLista);
                        DS_magazzino.RigheListePrelievoRow rigaListaPrelievo = tabellaRigheListaPrelievo[0];

                        // leggo il codice della cella...
                        string CodEvento = rigaTipoLista.CodEvento;
                        // posizione corrente dell'UDC
                        int idxPosizUdcCorr = 0;
                        // posizioen di destinazione per UDC corrente
                        int idxPosizUdcDest = 0;
                        // cella di provenienza
                        int idxCellaFrom = 0;
                        // cella di destinazione
                        int idxCellaTo = 0;
                        // scarico i vari UDC dal magazzino (come posizione corrente)
                        foreach (DS_magazzino.RigheListePrelievoRow row in tabellaRigheListaPrelievo.Rows)
                        {
                            // ricavo il codice UDC...
                            string UDC = row.UDC;
                            // mi serve per posizione udc corrente
                            DS_magazzino.PosizioneUdcCorrenteRow rigaUdcCorrente = taPosUdcCorr.getByUDC(UDC)[0];
                            // il secondo idx che mi serve
                            idxCellaFrom = rigaUdcCorrente.IdxCella;
                            // calcolo posizione destinazione da state machine...
                            idxPosizUdcCorr = taElencoCartellini.getDetailsUdcByUdc(UDC)[0].IdxPosizione;
                            idxPosizUdcDest = StateMachine.SM.getIdxPostizioneTo(CodEvento, idxPosizUdcCorr);
                            // a questo punto mi calcolo se c'è una cella di destinazione associata
                            try
                            {
                                idxCellaTo = MagClass.magazzino.taCelle.getByCodMag(CodCS, idxPosizUdcDest.ToString())[0].IdxCella;
                            }
                            catch
                            {
                                idxCellaTo = 0;
                            }
                            // sposto UDC, e così facendo genero movimenti batch x AS400
                            fatto = scaricaUDC(UDC, idxCellaFrom, idxPosizUdcDest);
                            // sposto nella PRIMA cella di destinazione associata l'UDC
                            if (idxCellaTo > 0)
                            {
                                spostaUDC(CodCS, UDC, idxCellaTo, false);
                            }
                            if (fatto)
                            {
                                // dopo aver scaricato UDC sistemo eventuali Righe di Prelievo x lo stesso pending...
                                magazzino.taRigheListePrelievo.stp_RLP_sbloccaNonPrelevate(CodLista, UDC);
                            }
                        }
                        // segna come scaricata la lista prelievo
                        taElencoListePrelievo.updateStato(CodSoggetto, CodLista, (int)statoLista.scaricata);
                        // restituisce ok
                        answ = esitoOperazione.ok;
                        // ora eseguo stored x copiare in altra tabella (quella per AS...) - SOLO SE NON E' prelievo fusi...
                        taElencoListePrelievo.stp_LP_exportToAs400(CodLista);
                    }
                    // se è già completata dà errore
                    else
                    {
                        answ = esitoOperazione.errore_readOnly;
                    }
                }
                // se la lista non esiste dai errore
                else
                {
                    answ = esitoOperazione.errore;
                }
            }
            catch
            { }
            return answ;
        }
        /// <summary>
        /// resetta (riporta in bozza) una lista di prelievo, spostando gli UDC alla posizione standard precedente
        /// </summary>
        /// <param name="CodCS">Codice company/sito</param>
        /// <param name="CodLista">codice della lista di prelievo</param>
        /// <param name="CodSoggetto">cod operatore carrellista</param>
        /// <returns></returns>
        public esitoOperazione resetListaPrelievo(string CodCS, string CodLista, string CodSoggetto)
        {
            memLayer.ML.emptySessionVal("CodListaAttiva");
            memLayer.ML.emptySessionVal("activeTask");
            // da chiamare quando clicco e inizio lista prelievo .... vedi sopra
            esitoOperazione answ = esitoOperazione.errore;
            try
            {
                // la query recupera la lista in base al CodLista
                DS_magazzino.ElencoListePrelievoDataTable tabella = taElencoListePrelievo.getByCodLista(CodLista);
                DS_magazzino.ElencoListePrelievoRow riga = tabella[0];

                // se la lista esiste...
                if (tabella.Rows.Count > 0)
                {
                    // ricontrollo che la lista sia completata
                    if (riga.CodStatoLista >= (int)statoLista.completata)
                    {
                        // calcolo tipo lista di prelievo
                        string codTipoListaAttuale = riga.CodTipoLista;
                        // dal tipo lista determino l'evento
                        string codEvento = taTipoListaPrelievo.getByCodTipoLista(codTipoListaAttuale)[0].CodEvento;
                        // dall'evento la posizione iniziale
                        int idxPosizione = StateMachine.SM.taTTPE.getByEvento(codEvento)[0].IdxPosizione;
                        // lo trasformo x avere la cella di destinazione...
                        int idxCellaTo = taCelle.getFirstByPosizione(idxPosizione.ToString())[0].IdxCella;
                        // leggo da righe lista prelievo il dato udc che mi serve
                        DS_magazzino.RigheListePrelievoDataTable tabellaRigheListaPrelievo = taRigheListePrelievo.getByCodListaPrelevate(CodLista);
                        DS_magazzino.RigheListePrelievoRow rigaListaPrelievo = tabellaRigheListaPrelievo[0];
                        // sposto ("metto a terra") gli UDC
                        foreach (DS_magazzino.RigheListePrelievoRow row in tabellaRigheListaPrelievo.Rows)
                        {
                            // ricavo il codice UDC...
                            string _UDC = row.UDC;
                            // sposto UDC
                            spostaUDC(CodCS, _UDC, idxCellaTo, false);
                        }
                        // indico le righe come NON prelevate...
                        taRigheListePrelievo.stp_RLP_resetPrelevate(CodLista);
                        // aggiorno stato lista che torna a BOZZA
                        taElencoListePrelievo.updateStato(CodSoggetto, CodLista, (int)statoLista.bozza);
                        answ = esitoOperazione.ok;
                    }
                    // se è già completata o NON iniziata dà errore
                    else
                    {
                        answ = esitoOperazione.errore_readOnly;
                    }
                }
                // se la lista non esiste dai errore
                else
                {
                    answ = esitoOperazione.errore;
                }
            }
            catch
            { }
            return answ;
        }


        /// <summary>
        /// Conferma che un dato UDC è stato prelevato per soddisfare la lista di prelievo ed aggiorna o aggiunge riga in RigheListePrelievo
        /// </summary>
        /// <param name="CodLista">codice della lista di prelievo</param>
        /// <param name="UDC">Codice UDC</param>
        /// <returns>esito comando</returns>
        public esitoOperazione confermaUdcPrelevatoPerLista(string CodLista, string UDC)
        {
            esitoOperazione answ = esitoOperazione.errore;

            // verifico che i dati corrispondano con il metodo relativo (vedi sopra)
            bool datiUdcOk = verificaDatiUdc(CodLista, UDC);

            if (datiUdcOk)
            {
                // richiamo stored  di upsert
                taRigheListePrelievo.upsertPrelevato(CodLista, UDC);
                // ...dò risposta positiva
                answ = esitoOperazione.ok;

            }
            else
            {
                // altrimenti dò errore mismatch e non proseguo
                return answ = esitoOperazione.errore_mismatch;
            }

            return answ;
        }
        /// <summary>
        /// annulla il prelievo di un UDC, aggiornando RigheListePrelievo (solo preventivato...)
        /// </summary>
        /// <param name="CodLista">codice della lista di prelievo</param>
        /// <param name="UDC">Codice UDC</param>
        /// <returns>esito comando</returns>
        public esitoOperazione annullaUdcPrelevatoPerLista(string CodLista, string UDC)
        {
            esitoOperazione answ = esitoOperazione.errore;

            /*
             * Questa funzione va chiamata da web o da terminalino ogni volta che si fa un annullamento di avvenuto prelievo, ovvero il carrellista ha ANNULLATO un prelievo di un UDC associato ad una lista
             * 
             * - in primis controllo: esiste questa riga di prelievo udc/lista?
             * - se i dati non corrispondono esco e mando falso --> vedere l'enum in fondo al codice ed 
             * usare esitoOperazione.errore_mismatch
             * - se i dati corrispondono allora 
             *  - cerco riga e tolgo check come prelevato
             * - se tutto ok passo esito ok
             * 
             * */
            try
            {
                // ricavo dati
                DS_magazzino.RigheListePrelievoDataTable tabella = taRigheListePrelievo.getByCodLista(CodLista);
                DS_magazzino.RigheListePrelievoRow riga = tabella[0];

                // se i dati esistono procedo - eseguo stored che setta non prelevato = false per la riga selezionata
                if (tabella.Rows.Count > 0)
                {
                    taRigheListePrelievo.setAnnullaUdcPrelevato(CodLista, UDC);
                    answ = esitoOperazione.ok;
                }

                else
                {
                    answ = esitoOperazione.errore_mismatch;
                }
            }
            catch
            { }
            return answ;
        }
        /// <summary>
        /// Rigenera una Lista di prelievo togliendo gli UDC non ancora prelevati rimettendo in logica FIFO gli UDC "liberi" disponibili
        /// </summary>
        /// <param name="CodLista">codice della lista di prelievo</param>
        /// <returns>esito comando</returns>
        public esitoOperazione scambiaUdcPerLista(string CodLista)
        {
            esitoOperazione answ = esitoOperazione.errore;

            /*
             * Questa funzione va chiamata da web o da terminalino ogni volta che si fa una richiesta di cambio per un UDC già prelevato, ovvero un altro carrellista prelevato un UDC associato alla mia lista corrente - rigenera UDC da prelevare
             * */
            try
            {
                // ricavo dati
                DS_magazzino.ElencoListePrelievoRow riga = taElencoListePrelievo.getByCodLista(CodLista)[0];
                // svuoto PRIMA gli UDC non prelevati
                taRigheListePrelievo.stp_RigheListePrelievo_eliminaNonPrelevate(CodLista);
                // rigenero righe UDC da prelevare
                DS_magazzino.ElencoCartelliniDataTable tabellaElencoCartellini = taElencoCartellini.getUdcUnusedOlder(CodLista);
                allocaRigheListaPrelievo(riga.QtaTot, CodLista, tabellaElencoCartellini);
            }
            catch
            { }
            return answ;
        }
        /// <summary>
        /// Aggiunge UN SOLO UDC in logica FIFO tra gli UDC "liberi" disponibili
        /// </summary>
        /// <param name="CodLista">codice della lista di prelievo</param>
        /// <returns>esito comando</returns>
        public esitoOperazione addUdcPerLista(string CodLista)
        {
            esitoOperazione answ = esitoOperazione.errore;
            try
            {
                // ricavo dati
                DS_magazzino.ElencoListePrelievoRow riga = taElencoListePrelievo.getByCodLista(CodLista)[0];
                // rigenero righe UDC da prelevare
                DS_magazzino.ElencoCartelliniDataTable tabellaElencoCartellini = new DS_magazzino.ElencoCartelliniDataTable();
                // aggiungo l'UDC + vecchio (se c'è)
                try
                {
                    tabellaElencoCartellini.ImportRow(taElencoCartellini.getUdcUnusedOlder(CodLista)[0]);
                }
                catch (Exception e)
                {
                    logger.lg.scriviLog(String.Format("Errore in aggiunta UDC a lista prelievo: {0}", e), tipoLog.EXCEPTION);
                }
                allocaRigheListaPrelievo(riga.QtaTot, CodLista, tabellaElencoCartellini);
            }
            catch
            { }
            return answ;
        }
        /// <summary>
        /// vero/falso che l'utent eha una lista di prelievo attiva
        /// </summary>
        public bool userHasActiveLP
        {
            get
            {
                bool answ = false;
                try
                {
                    answ = (MagClass.magazzino.taElencoListePrelievo.getByCodSogg(CodSoggCurrUser).Rows.Count > 0);
                }
                catch
                { }
                return answ;
            }
        }
        /// <summary>
        /// codice della lista di prelievo attiva
        /// </summary>
        public string codListaAttivaUtente
        {
            get
            {
                string answ = "";
                try
                {
                    answ = MagClass.magazzino.taElencoListePrelievo.getByCodSogg(CodSoggCurrUser)[0].CodLista;
                }
                catch
                { }
                return answ;
            }
        }
        /// <summary>
        /// 
        /// </summary>
        /// <param name="CodLista"></param>
        /// <returns></returns>
        public bool listaPrelevabile(string CodLista)
        {
            bool answ = false;
            try
            {
                answ = (MagClass.magazzino.taElencoListePrelievo.getByCodLista(CodLista).Select("CodStatoLista = 1").Length > 0); // filtro su stato = 1 (può esser presa in carico)
            }
            catch
            { }
            return answ;
        }

        #endregion

        #region area rapporti qualità

        /// <summary>
        /// Crea gli UDC da associare ai cartellini dei rapporti qualità deliberati, li associa e se richiesto lancia stampa
        /// </summary>
        /// <param name="numRapQual">identificativo rapp qualità</param>
        /// <param name="doPrint">true/false se stampare</param>
        /// <returns></returns>
        public bool creaUdcDaRappQualita(int numRapQual, bool doPrint)
        {
            bool answ = false;
            // ottengo elenco righe dei cartellini del rapp qualità indicato SENZA righe UDC
            DS_magazzino.RapQualDataTable tabRapQual = taRapQual.getByNumRapQualNoUdc(numRapQual);
            // per prima cosa verifico che ci sia il rapporto di qualità in esame e che abbia righe da associare ad UDC
            if (tabRapQual.Rows.Count > 0)
            {
                string UDC = "";
                foreach (DS_magazzino.RapQualRow rqRow in tabRapQual)
                {
                    // se non ha già un UDC... e se NON E' stato già scaricato...
                    if (rqRow.UDC == "" && rqRow.LegaScaric.ToUpper() == "N")
                    {
                        answ = true;

                        // per ogni riga creo un UDC 
                        DS_Applicazione.ElencoCartelliniDataTable tabCartellini = DataProxy.obj.taCartellini.stp_insNewFull(memLayer.ML.confReadString("CodCS"), memLayer.ML.confReadString("BilanciaMP"), string.Format("{0:yy}", DateTime.Now), rqRow.CodFor, rqRow.CodLega, "", "", "", "", DateTime.Now, 0, memLayer.ML.confReadString("CodImballoMP"), CodSoggCurrUser, 0, memLayer.ML.confReadInt("IdxPosizMP"), "M", "UDC_MP", rqRow.Qta, Convert.ToDouble(rqRow.Qta), 1, memLayer.ML.confReadString("CodStatoMP"), "", false); // UDC_MP HARD CODED!!!
                        try
                        {
                            UDC = tabCartellini[0].UDC;
                            // lo associo!
                            taRapQual.stp_associaUDC(rqRow.ProgUDC, UDC);
                        }
                        catch (Exception e)
                        {
                            logger.lg.scriviLog(string.Format("Non sono riuscito a creare associazioen UDC / rapp qual: UDC creato: {0}, progRappQual: {1}, eccezione: {2}", UDC, rqRow.ProgUDC, e), tipoLog.EXCEPTION);
                        }
                    }
                }

                // se devo stampare lancio stampa...
                if (doPrint)
                {
                    stampaUdcDaRappQualita(numRapQual);
                }
            }
            return answ;
        }
        /// <summary>
        /// effettua la (ri)stampa di TUTTI gli UDC dato un rapporto di qualità
        /// </summary>
        /// <param name="numRapQual">identificativo rapp qualità</param>
        /// <returns></returns>
        public bool stampaUdcDaRappQualita(int numRapQual)
        {
            bool answ = false;
            // ottengo elenco righe dei cartellini del rapp qualità indicato SENZA righe UDC
            DS_magazzino.RapQualDataTable tabRapQual = taRapQual.getByNumRapQual(numRapQual);
            // per prima cosa verifico che ci sia il rapporto di qualità in esame e che abbia righe da associare ad UDC
            if (tabRapQual.Rows.Count > 0)
            {
                answ = true;
                foreach (DS_magazzino.RapQualRow rqRow in tabRapQual)
                {
                    answ = reportPrinter.obj.stampaCartellino(tipoCartellino.cartMP, rqRow.UDC, "");
                }
            }
            return answ;
        }


        #endregion

        #endregion
    }
}

public enum esitoOperazione
{
    ok, // tutto ok, come true
    errore, // non è andata, errore generico
    errore_mismatch, // errore x mancanza corrispondenza tra dati (particolare-esponente-figura di lista ed UDC, ad esempio)
    errore_readOnly, // errore xché ild ato è read only o bloccato (es lista di prelievo già completata, NON posso riprenderla in carico)
    errore_posUDC, // errore perché UDC è in una posizione che non consente l'operazione indicata
    errore_noUdc
}

public enum statoLista
{
    bozza = 0,
    generata,
    iniziata,
    completata,
    scaricata
}