using MapoDb;
using SteamWare;
using System;

namespace MoonPro.WebUserControls
{
    public partial class mod_UI : System.Web.UI.UserControl
    {
        protected string _bCode = "";
        protected MapoDb.MapoDb controllerMapo = new MapoDb.MapoDb();
        /// <summary>
        /// definisce se edit abilitato x utenti "admin"
        /// </summary>
        protected bool adminInput
        {
            get
            {
                return memLayer.ML.BoolSessionObj("adminInput");
            }
            set
            {
                memLayer.ML.setSessionVal("adminInput", value);
            }
        }
        /// <summary>
        /// effettua traduzione del lemma
        /// </summary>
        /// <param name="lemma"></param>
        /// <returns></returns>
        public string traduci(string lemma)
        {
            return user_std.UtSn.Traduci(lemma);
        }
        /// <summary>
        /// caricamento pagina
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        protected void Page_Load(object sender, EventArgs e)
        {
            popolaLabels();
            checkScadenze();
            updateUI();
            updateTurni();
        }
        /// <summary>
        /// aggiorna classi grafiche turni 
        /// </summary>
        protected void updateTurni()
        {
        }
        /// <summary>
        /// verifica che non siano scaduti i termini dell'input utente admine nel caso resetta titoli...
        /// </summary>
        private void checkScadenze()
        {
            DS_ProdTempi.PostazioniMapoRow rigaPost = DataLayer.obj.taPostazioni.getByIdxPostaz(idxPostazione)[0];
            if (rigaPost == null)
            {
                logger.lg.scriviLog(string.Format("Errore: manca record postazione per {0}", idxPostazione), tipoLog.ERROR);
            }
            DateTime scadenza = rigaPost.InputUntil;
            if (scadenza < DateTime.Now)
            {
                if (adminInput)
                {
                    adminInput = false;
                    memLayer.ML.emptySessionVal("lblTitoloUI");
                    memLayer.ML.emptySessionVal("lblMessUI");
                }
            }
        }
        /// <summary>
        /// controllo se ci sia qualcosa da mostrare...
        /// </summary>
        private void updateUI()
        {
            bool hasTitolo = memLayer.ML.isInSessionObject("lblTitoloUI");
            bool hasMess = memLayer.ML.isInSessionObject("lblMessUI");
            if (hasTitolo && hasMess)
            {
                showMess(memLayer.ML.StringSessionObj("lblTitoloUI"), memLayer.ML.StringSessionObj("lblMessUI"));
            }
        }
        /// <summary>
        /// restituisce una riga operatore data al matricola
        /// </summary>
        /// <param name="MatrOper"></param>
        /// <returns></returns>
        protected DS_applicazione.AnagraficaOperatoriRow getRigaOperatore(int MatrOper)
        {
            try
            {
                return DataLayer.obj.taOp.getByMatrOpr(MatrOper)[0];
            }
            catch
            {
                logger.lg.scriviLog(string.Format("Codice matricola operatore non trovato! {0}", BarCode));
                return null;
            }
        }

        /// <summary>
        /// popola le labels
        /// </summary>
        private void popolaLabels()
        {
            int odl = 0;
            DateTime dataFrom = DateTime.Now;
            DateTime dataTo = DateTime.Now;
            // label ODL
            try
            {
                DS_ProdTempi.ODLRow rigaOdl = DataLayer.obj.taODL.getByMacchina(idxMacchina)[0];
                odl = rigaOdl.IdxODL;
                dataFrom = rigaOdl.DataInizio;
                lblOdl.Text = string.Format("ODL num: {0}, iniziato il {1:dd/MM/yy} alle {1:HH:mm}", odl, dataFrom);
            }
            catch
            {
                lblOdl.Text = "n/a";
            }
            /************************************ 
             * data la postazione corrente decide cosa mostrare e come
             ************************************/
            MapoDb.DS_ProdTempi.stp_repDonati_getDatiProdMacchinaRow rigaProd = DataLayer.obj.taDatiProdMacch.GetData(idxMacchina)[0];
            lblCodArticolo.Text = rigaProd.CodArticolo;
            lblNumPzLanciati.Text = string.Format("{0} pz.", rigaProd.PezziLanciati);
            lblNumPzConf.Text = string.Format("{0} pz.", rigaProd.PezziConf);
            lblNumPzFatti.Text = string.Format("({0} pz.)", rigaProd.PezziProd);


            /************************************ 
             * calcolo efficienza totale
             * se il calcolo non è possibile mette n/a
             ************************************/
            decimal tempoProd = rigaProd.TCAssegnato * rigaProd.PezziConf;
            try
            {
                lblEfficienzaTot.Text = Convert.ToString(String.Format("{0:p2}", tempoProd / rigaProd.TempoOn / 100));
            }
            catch
            {
                lblEfficienzaTot.Text = "n/a";
            }
            // calcolo efficienza lavoro - se il calcolo non è possibile mette n/a
            try
            {
                lblEfficienzaLavoro.Text = Convert.ToString(String.Format("{0:p2}", tempoProd / rigaProd.TempoAuto / 100));
            }
            catch
            {
                lblEfficienzaLavoro.Text = "n/a";

            }
            // calcolo efficienza Teorica - se il calcolo non è possibile mette n/a
            try
            {
                lblEfficienzaEff.Text = Convert.ToString(String.Format("{0:p2}", tempoProd / rigaProd.TempoRun / 100));
            }
            catch
            {
                lblEfficienzaEff.Text = "n/a";
            }

            /************************************ 
             * imposto i TEMPI CICLO 
             ************************************/
            // riporto Tempo ciclo impostato
            lblTcImpostato.Text = Convert.ToString(String.Format("{0:0.###}", rigaProd.TCAssegnato));
            // riporto Tempo ciclo medio
            lblTcMedio.Text = Convert.ToString(String.Format("{0:0.###}", rigaProd.TCMedio));
            lblTcMedioRT.Text = Convert.ToString(String.Format("({0:0.###})", rigaProd.TCMedioRT));
            // riporto Tempo ciclo lavoro
            lblTcLavoro.Text = Convert.ToString(String.Format("{0:0.###}", rigaProd.TCLav));
            lblTcLavoroRT.Text = Convert.ToString(String.Format("({0:0.###})", rigaProd.TCLavRT));
            // riporto Tempo ciclo effettivo/tecnico, come media dei 10 migliori delle ultime 8 ore
            lblTcEffettivo.Text = Convert.ToString(String.Format("{0:0.###}", rigaProd.TCEff));
            lblTcEffettivoRT.Text = Convert.ToString(String.Format("({0:0.###})", rigaProd.TCEffRT));

            /************************************
             * Sistemo efficienze RT da tempi ciclo
             ************************************/
            try
            {
                lblEfficienzaTotRT.Text = Convert.ToString(String.Format("({0:p2})", rigaProd.TCAssegnato / rigaProd.TCMedioRT));
            }
            catch
            {
                lblEfficienzaTotRT.Text = "n/a";
            }
            // calcolo efficienza lavoro - se il calcolo non è possibile mette n/a
            try
            {
                lblEfficienzaLavoroRT.Text = Convert.ToString(String.Format("({0:p2})", rigaProd.TCAssegnato / rigaProd.TCLavRT));
            }
            catch
            {
                lblEfficienzaLavoroRT.Text = "n/a";

            }
            // calcolo efficienza Teorica - se il calcolo non è possibile mette n/a
            try
            {
                lblEfficienzaEffRT.Text = Convert.ToString(String.Format("({0:p2})", rigaProd.TCAssegnato / rigaProd.TCEffRT));
            }
            catch
            {
                lblEfficienzaEffRT.Text = "n/a";
            }
        }

        /// <summary>
        /// codice barcode
        /// </summary>
        public string BarCode
        {
            set
            {
                _bCode = value;
                // eseguo codice...
                decodeBCode();
            }
            get
            {
                return _bCode;
            }
        }
        /// <summary>
        /// mostra il messaggio indicato
        /// </summary>
        /// <param name="titolo"></param>
        /// <param name="messaggio"></param>
        protected void showMess(string titolo, string messaggio)
        {
            pnlMessaggi.Visible = true;
            lblTitolo.Text = titolo;
            lblMess.Text = messaggio;
        }
        /// <summary>
        /// idxMacchina
        /// </summary>
        public string idxMacchina
        {
            get
            {
                return memLayer.ML.StringSessionObj("idxMacchinaUI");
            }
            set
            {
                memLayer.ML.setSessionVal("idxMacchinaUI", value);
                setMacchinaPostazione();
            }
        }
        /// <summary>
        /// idxPostazione
        /// </summary>
        public string idxPostazione
        {
            get
            {
                return memLayer.ML.StringSessionObj("idxPostazioneUI");
            }
            set
            {
                memLayer.ML.setSessionVal("idxPostazioneUI", value);
                // calcolo la macchina...
                setMacchinaPostazione();
            }
        }
        /// <summary>
        /// aggiorna associazione codice macchina e postazione su DB
        /// </summary>
        private void setMacchinaPostazione()
        {
            // salvo associazione macchina / postazione se entrambe != ""
            if (idxMacchina != "" && idxPostazione != "")
            {
                DataLayer.obj.taPostazioni.updateMacchina(idxPostazione, idxMacchina);
            }
        }
        /// <summary>
        /// assegna il tipo di barcode dalal stringa passata
        /// </summary>
        /// <param name="_tipoBCode"></param>
        private void assegnaTipoBarcode(out tipoBarcode _tipoBCode)
        {
            // leggo le conf di gestione del barcode
            string prefDichProd = memLayer.ML.confReadString("prefDichProd");
            string prefDichFerm = memLayer.ML.confReadString("prefDichFerm");
            string prefDichOp = memLayer.ML.confReadString("prefDichOp");
            string prefDichCodArt = memLayer.ML.confReadString("prefDichCodArt");
            string prefDichAttrezzaggio = memLayer.ML.confReadString("prefDichAttrezzaggio");
            string prefModTurno = memLayer.ML.confReadString("prefModTurno");
            _tipoBCode = tipoBarcode.nd;
            // prendo le prime 2 cifre del barcode x capirne la natura
            string prefBarcode = BarCode.Substring(0, 2);
            if (prefBarcode == prefDichProd)
            {
                _tipoBCode = tipoBarcode.confermaProduzione;
            }
            else if (prefBarcode == prefDichFerm)
            {
                _tipoBCode = tipoBarcode.dichiaraFermata;
            }
            else if (prefBarcode == prefDichOp)
            {
                _tipoBCode = tipoBarcode.matrOperatore;
            }
            else if (prefBarcode == prefDichCodArt)
            {
                _tipoBCode = tipoBarcode.codArticolo;
            }
            else if (prefBarcode == prefDichAttrezzaggio)
            {
                _tipoBCode = tipoBarcode.attrezzaggio;
            }
            else if (prefBarcode == prefModTurno)
            {
                _tipoBCode = tipoBarcode.modificaTurno;
            }
        }

        /// <summary>
        /// esegue decodifica barcode
        /// </summary>
        private void decodeBCode()
        {
            // calcolo il tipo di barcode ricevuto
            tipoBarcode _tipoBCode;
            assegnaTipoBarcode(out _tipoBCode);
            // in primis verifico se sia abilitato input alla postazione
            if (adminInput)
            {
                // in base al tipo di barcode definisco il da farsi...
                switch (_tipoBCode)
                {
                    case tipoBarcode.nd:
                        // non faccio nulla
                        break;
                    case tipoBarcode.matrOperatore:
                        processaCartellinoOperatore();
                        break;
                    case tipoBarcode.codArticolo:
                        // x ora non serve
                        break;
                    case tipoBarcode.attrezzaggio:
                        processaAttrezzaggio();
                        break;
                    case tipoBarcode.confermaProduzione:
                        processaProduzione();
                        break;
                    case tipoBarcode.dichiaraFermata:
                        processaDichiaraFermata();
                        break;
                    case tipoBarcode.modificaTurno:
                        processaModificaTurno();
                        break;
                    default:
                        break;
                }
            }
            else // edit avanzato non permesso, possibile solo sparare barcode utente...
            {
                // controllo se sia un barcode utente...
                if (_tipoBCode == tipoBarcode.matrOperatore)
                {
                    processaCartellinoOperatore();
                }
                else
                {
                    // mostra warning xché interazione non permessa
                    salvaRicarica("Abilitazione richiesta!", "Codice non accettato: prima registrare barcode utente abilitato");
                }
            }

        }
        /// <summary>
        /// chiama modifica stato turno
        /// </summary>
        private void processaModificaTurno()
        {
            string prefModTurno = memLayer.ML.confReadString("prefModTurno");
            // recupero dati evento...
            int numTurno = 0;
            try
            {
                numTurno = Convert.ToInt32(BarCode.Replace(prefModTurno, ""));
            }
            catch
            {
                logger.lg.scriviLog(string.Format("Barcode modifica turno non valido! {0}", BarCode));
            }
            if (numTurno > 0)
            {
                DataLayer.obj.taTurniMacc.stp_turniMacchineUpdateTurno(idxMacchina, numTurno);
                // ricarico!
                salvaRicarica("Dichiarazione fermata", "Registrata modifica turno");
            }
            else
            {
                salvaRicarica("Errore", string.Format("Codice modifica turno non valido! {0}", BarCode));
            }
        }
        /// <summary>
        /// contiene in sessione i pezzi da confermare
        /// </summary>
        protected int prod2confirm
        {
            get
            {
                int answ = 0;
                try
                {
                    answ = memLayer.ML.IntSessionObj("prod2confirm");
                }
                catch
                {
                    answ = -1;
                }
                return answ;
            }
            set
            {
                memLayer.ML.setSessionVal("prod2confirm", value);
            }
        }
        /// <summary>
        /// processa barcode di dichiarazione e conferma produzione
        /// </summary>
        private void processaProduzione()
        {
            string prefDichProd = memLayer.ML.confReadString("prefDichProd");
            string MostraProd = memLayer.ML.confReadString("MostraProd");
            string ConfermaProd = memLayer.ML.confReadString("ConfermaProd");
            string AnnullaProd = memLayer.ML.confReadString("AnnullaProd");
            string AumentaProd = memLayer.ML.confReadString("AumentaProd");
            string DiminuisciProd = memLayer.ML.confReadString("DiminuisciProd");
            /* ***********************************************
             * Processing Produzione
             * ***********************************************
             * 
             * regole:
             * - serve x iniziare un mostra prod, che salva in sessione la produzione rilevata
             * - è accettato, se in sessione c'è un dato di prod, la conferma
             * - è accettato la cancellazione (svuota da sessione..)
             * - è accettato, se in sessione c'è un dato di prod, aumentare o diminuire la produzione
            */
            bool produzioneCaricata = memLayer.ML.isInSessionObject("prod2confirm");
            int variazione = 0;
            if (!produzioneCaricata) // se non ho caricato produzione è ammesso solo il comando di caricamento produzione da sistema...
            {
                if (BarCode == MostraProd)
                {
                    caricaProduzioneMacchina();
                }
                else
                {
                    // mostro warning
                    salvaRicarica("Errore codice produzione", "Deve prima essere richiesta la conferma di produzione per mostrare i dati di produzione e solo successivmaente si può confermare/annullare/modificare");
                }
            }
            else
            {
                if (BarCode == MostraProd)
                {
                    caricaProduzioneMacchina();
                }
                else if (BarCode == AnnullaProd)
                {
                    memLayer.ML.emptySessionVal("prod2confirm");
                    salvaRicarica("Annullata conferma produzione", "annullata operazione conferma di produzioone, prego ricominciare");
                }
                else if (BarCode.Substring(0, 3) == AumentaProd)
                {
                    variazione = Convert.ToInt32(BarCode.Replace(AumentaProd, ""));
                    prod2confirm += variazione;
                    salvaRicarica("Conferma produzione", string.Format("Pezzi prodotti da confermare: {0}, per il periodo {1:dd/MM/yy HH:mm:ss} --> {2:dd/MM/yy HH:mm:ss}", prod2confirm, DateTime.Now.AddDays(-1), DateTime.Now));
                }
                else if (BarCode.Substring(0, 3) == DiminuisciProd)
                {
                    variazione = Convert.ToInt32(BarCode.Replace(DiminuisciProd, ""));
                    prod2confirm -= variazione;
                    salvaRicarica("Conferma produzione", string.Format("Pezzi prodotti da confermare: {0}, per il periodo {1:dd/MM/yy HH:mm:ss} --> {2:dd/MM/yy HH:mm:ss}", prod2confirm, DateTime.Now.AddDays(-1), DateTime.Now));
                }
                else if (BarCode == ConfermaProd)
                {
                    confermaProduzioneSuDb();
                }
                else
                {
                    salvaRicarica("Errore!", string.Format("Codice produzione non riconosciuto: {0}", BarCode));
                }
            }
        }
        /// <summary>
        /// conferma al produzione sul db
        /// </summary>
        private void confermaProduzioneSuDb()
        {
            // carico i dati da confermare...
            DS_ProdTempi.stp_PzProd_getByMacchinaRow rigaProd;
            rigaProd = DataLayer.obj.taPzProd2conf.GetData(idxMacchina)[0];
            // carico i dati necessari x approvatgore ed ODL
            int idxOdl = 0; // userò ODL del turno
            DS_ProdTempi.ODLDataTable elencoOdlTurno;
            int MatrAppr = 0; // leggo da postazioniMapo
            try
            {
                idxOdl = DataLayer.obj.taODL.getByMacchina(idxMacchina)[0].IdxODL;
            }
            catch
            {
                logger.lg.scriviLog(string.Format("Errore a recuperare ODL per la macchina {0}", idxMacchina), tipoLog.ERROR);
            }
            try
            {
                MatrAppr = DataLayer.obj.taPostazioni.getByIdxPostaz(idxPostazione)[0].MatrOperatore;
            }
            catch
            {
                logger.lg.scriviLog(string.Format("Errore a recuperare MatrApp per la postazione {0}", idxPostazione), tipoLog.ERROR);
            }
            // chiamo la stored
            try
            {
                // ricavo i turni della macchina da anagrafica
                // !!!FARE!!! da db incrociando dati da anagrafica... x ora calcolo con turno 8 h x 7 gg/week
                int shiftTurno = 6;
                int durataTurno = 8;
                // calcolo quanti turni da approvare ci siano
                int numTurni2appr = (int)Math.Floor(rigaProd.DataTo.Subtract(rigaProd.DataFrom).TotalHours / durataTurno);
                // questa dataora rappresenta l'inizio del turno che man mano vado ad approvare
                DateTime dataCurr = rigaProd.DataFrom;
                turnoLavoro turnoCurr;
                int pzProd = 0;
                int idxStatoProd = 13; // hard coded!!!
                // definisco intervallo date x fare query (inizialmente è turno
                intervalloDate periodoOdl = new intervalloDate();
                intervalloDate periodoProd = new intervalloDate();
                // vado a ciclare da dataFrom a dataTo per ogni turno compreso fino all'ultimo turno intero
                for (int i = 0; i < numTurni2appr; i++)
                {
                    // calcolo il turno che comprende la data da approvare
                    turnoCurr = datario.mngr.getTurnoByDateTime(dataCurr, shiftTurno, durataTurno);
                    // recupero elenco ODL del turno (in modo che se ne ho + di 1 faccio + inserimenti produzione)
                    elencoOdlTurno = DataLayer.obj.taODL.getByMacchinaPeriodo(idxMacchina, turnoCurr.inizio, turnoCurr.fine);
                    // se ho almeno 1 ODL approvo...
                    foreach (DS_ProdTempi.ODLRow odl in elencoOdlTurno)
                    {
                        idxOdl = odl.IdxODL;
                        // calcolo periodo ODL
                        periodoOdl = datario.mngr.setIntervallo(odl.DataInizio, odl.DataFine);
                        // calcolo intersezione periodi: tra turno e validità ODL
                        periodoProd = datario.mngr.intersecaIntervalli(periodoOdl, turnoCurr.periodo);
                        // calcolo i pezzi da confermare x l'ODL in esame... ovvero imposto inizio/fine periodo da intersezione periodo ODL + turno
                        try
                        {
                            // approvando tanto la produzione
                            pzProd = DataLayer.obj.taPzProd2conf.getByMacchinaPeriodo(idxMacchina, periodoProd.inizio, periodoProd.fine)[0].pezziNonConfermati;
                        }
                        catch
                        {
                            pzProd = 0;
                        }
                        // carico i dati x Turno ed ODL
                        try
                        {
                            DataLayer.obj.taPzProd2conf.stp_DatiConf_conferma(idxOdl, idxMacchina, MatrAppr, turnoCurr.inizio, turnoCurr.fine, turnoCurr.TNum, idxStatoProd, pzProd);
                        }
                        catch
                        {
                            logger.lg.scriviLog(string.Format("Errore in INSERT dati x tab DatiConfermati: odl: {0}, idxMacchina: {1}, turno da {2} a {3}", idxOdl, idxMacchina, turnoCurr.inizio, turnoCurr.fine), tipoLog.ERROR);
                        }
                    }
                    // qui non ho + cambiato nulla per multi/ODL 
                    try
                    {
                        // chiamo stored inserimento dati produzione per il turno
                        DataLayer.obj.taDatiProd.stp_DatiProd_insAllPeriodo(idxMacchina, turnoCurr.inizio, turnoCurr.fine, turnoCurr.inizio.Date, turnoCurr.TNum, MatrAppr);
                    }
                    catch
                    {
                        logger.lg.scriviLog(string.Format("Errore in insert x tab DatiProduzione per il turno: odl: {0}, idxMacchina: {1}, turno da {2} a {3}", idxOdl, idxMacchina, turnoCurr.inizio, turnoCurr.fine), tipoLog.ERROR);
                    }
                    dataCurr = dataCurr.AddHours(durataTurno);
                }
                // IN FINE confermo la produzione della DIFFERENZA tra quanto rilevato a sistema dai tempi ciclo rilevati e quanto dichiarato all'istante della dichiarazione
                try
                {
                    pzProd = DataLayer.obj.taPzProd2conf.getByMacchinaPeriodo(idxMacchina, rigaProd.DataFrom, rigaProd.DataTo)[0].pezziNonConfermati;
                }
                catch
                {
                    pzProd = 0;
                }
                // confermo DELTA tab DatiConfermati
                DataLayer.obj.taPzProd2conf.stp_DatiConf_conferma(idxOdl, idxMacchina, MatrAppr, DateTime.Now, DateTime.Now, 1, idxStatoProd, prod2confirm - pzProd);
                // confermo DELTA tab DatiProduzione - ATTENZIONE NON METTO TEMPO NEGATIVO!!!
                DataLayer.obj.taDatiProd.stp_DatiProd_insert(idxOdl, idxMacchina, MatrAppr, DateTime.Now, DateTime.Now, 1, prod2confirm - pzProd, 0, "T_CorrProd");
            }
            catch
            {
                logger.lg.scriviLog("Errore nella chiamata a stored di conferma dati!", tipoLog.ERROR);
            }
            string messConferma = string.Format("Confermata la produzione per {0} pezzi!", prod2confirm);
            memLayer.ML.emptySessionVal("prod2confirm");
            salvaRicarica("Confermata produzione", messConferma);
        }
        /// <summary>
        /// carica da db la produzione x la macchina in oggetto
        /// </summary>
        private void caricaProduzioneMacchina()
        {
            DS_ProdTempi.stp_PzProd_getByMacchinaRow rigaProd;
            rigaProd = DataLayer.obj.taPzProd2conf.GetData(idxMacchina)[0];
            try
            {
                prod2confirm = rigaProd.pezziNonConfermati;
            }
            catch
            {
                prod2confirm = 0;
                logger.lg.scriviLog(string.Format("Errore recupero pezzi da confermare per la macchina {0}", idxMacchina), tipoLog.ERROR);
            }
            salvaRicarica("Conferma produzione", string.Format("Pezzi prodotti da confermare: {0}, per il periodo {1:dd/MM/yy HH:mm:ss} --> {2:dd/MM/yy HH:mm:ss}", rigaProd.pezziNonConfermati, rigaProd.DataFrom, rigaProd.DataTo));
        }
        /// <summary>
        /// effettua processing delel chiamate di attrezzaggio macchina
        /// </summary>
        private void processaAttrezzaggio()
        {
            string prefDichAttrezzaggio = memLayer.ML.confReadString("prefDichAttrezzaggio");
            string StartSetup = memLayer.ML.confReadString("StartSetup");
            string EndSetup = memLayer.ML.confReadString("EndSetup");
            string EndProd = memLayer.ML.confReadString("EndProd");
            // recupero dati evento attrezzaggio...
            int idxEvento = 0;
            try
            {
                // leggo 3-4 char che rappresenta evento (ignoro il resto che è codice ODL...)
                idxEvento = Convert.ToInt32(BarCode.Substring(2, 2));
            }
            catch
            {
                logger.lg.scriviLog(string.Format("Barcode attrezzaggio non valido! {0}", BarCode));
            }
            // verifico che l'ODL sia attrezzabile
            int idxODL = 0;
            DS_ProdTempi.ODLRow rigaOdl;
            try
            {
                idxODL = Convert.ToInt32(BarCode.Substring(4, BarCode.Length - 4));
                rigaOdl = DataLayer.obj.taODL.getByIdx(idxODL, false)[0];
            }
            catch
            {
                logger.lg.scriviLog(string.Format("impossibile ricavare codice ODL per attrezzaggio! {0}", BarCode));
            }
            // processo l'evento
            if (idxEvento > 0)
            {
                DS_applicazione.AnagraficaEventiRow rigaEvento = DataLayer.obj.taAnagEventi.GetByIdx(idxEvento)[0];
                if (rigaEvento != null)
                {
                    /* ***********************************************
                     * Processing ODL
                     * ***********************************************
                     * 
                     * regole evento inizio setup: 
                     * - se idxODL già usato --> errore esco
                     * - se idxODL ok chiudo eventuali ODL precedenti su stessa macchina e segno macchina+ dataora inizio
                     * 
                     * regole evento fine prod: 
                     * - se idxODL ok lo chiudo (dataora fine)
                     */

                    // controllo evento inizio attrezzaggio
                    if (BarCode.StartsWith(StartSetup))
                    {
                        // cerco di nuovo ODL tra i NON impiegati
                        int odlNonImpiegati = DataLayer.obj.taODL.getByIdx(idxODL, true).Rows.Count;
                        if (odlNonImpiegati > 0) // effettuo "consumo" ODL 
                        {
                            DataLayer.obj.taODL.inizioSetup(idxODL, idxMacchina, DataLayer.obj.taODL.getByIdx(idxODL, true)[0].TCAssegnato, "");
                        }
                        else // ODL già impiegato
                        {
                            salvaRicarica("Errore ODL", "l'ODL indicato è stato già lanciato, utilizzare un ODL nuovo");
                        }
                    }
                    else if (BarCode.StartsWith(EndProd)) // evento fine prod
                    {
                        // controllo se verificare codice odl da barcode... o se c'è idxOdl zero = manca...
                        if (!memLayer.ML.confReadBool("chkIdxOdlEndProd") || idxODL == 0)
                        {
                            try
                            {
                                // leggo idxOdl da ultimo odl attivo x macchina
                                idxODL = DataLayer.obj.taODL.getByMacchina(idxMacchina)[0].IdxODL;
                            }
                            catch
                            {
                                logger.lg.scriviLog(string.Format("Errore recupero odl per la macchina {0}", idxMacchina), tipoLog.ERROR);
                            }
                        }
                        // chiudo ODL corrente
                        DataLayer.obj.taODL.fineProd(idxODL, idxMacchina);
                    }
                    DS_applicazione.StatoMacchineRow rigaStato = DataLayer.obj.taStatoMacchine.GetDataByIdxMacchina(idxMacchina)[0];
                    // ricavo codice articolo...
                    string CodArticolo = DataLayer.obj.taODL.getByIdx(idxODL, false)[0].CodArticolo;
                    // processo evento...
                    controllerMapo.scriviRigaEventoBarcode(idxMacchina, idxEvento, CodArticolo, "", rigaStato.MatrOpr, rigaStato.pallet);
                    // ricarico a seconda del tipo di codice
                    if (BarCode.StartsWith(StartSetup))
                    {
                        salvaRicarica("Dichiarazione fermata", String.Format("Registrata dichiarazione inizio attrezzaggio per ODL {0}", idxODL));
                    }
                    else if (BarCode.StartsWith(EndSetup))
                    {
                        salvaRicarica("Fine attrezzaggio", String.Format("Registrata fine attrezzaggio per ODL {0}", idxODL));
                    }
                    else if (BarCode.StartsWith(EndProd))
                    {
                        salvaRicarica("Fine produzione", String.Format("Registrata fine produzione per ODL {0}", idxODL));

                    }

                }
                else
                {
                    salvaRicarica("Errore", string.Format("Codice attrezzaggio non valido! {0}", BarCode));
                }
            }
        }
        /// <summary>
        /// effettua processing cartellino fermate
        /// </summary>
        private void processaDichiaraFermata()
        {
            string prefDichFerm = memLayer.ML.confReadString("prefDichFerm");
            // recupero dati evento...
            int idxEvento = 0;
            try
            {
                idxEvento = Convert.ToInt32(BarCode.Replace(prefDichFerm, ""));
            }
            catch
            {
                logger.lg.scriviLog(string.Format("Barcode fermata non valido! {0}", BarCode));
            }
            if (idxEvento > 0)
            {
                DS_applicazione.AnagraficaEventiRow rigaEvento = DataLayer.obj.taAnagEventi.GetByIdx(idxEvento)[0];
                if (rigaEvento != null)
                {
                    DS_applicazione.StatoMacchineRow rigaStato = DataLayer.obj.taStatoMacchine.GetDataByIdxMacchina(idxMacchina)[0];
                    // processo evento...
                    controllerMapo.scriviRigaEventoBarcode(idxMacchina, idxEvento, rigaStato.CodArticolo, "", rigaStato.MatrOpr, rigaStato.pallet);
                    // ricarico!
                    salvaRicarica("Dichiarazione fermata", "Registrata dichiarazione fermata");
                }
                else
                {
                    salvaRicarica("Errore", string.Format("Codice evento non valido! {0}", BarCode));
                }
            }
        }
        /// <summary>
        /// effettua processing cartellino operatore
        /// </summary>
        /// <param name="prefDichOp"></param>
        private void processaCartellinoOperatore()
        {
            string prefDichOp = memLayer.ML.confReadString("prefDichOp");
            // recupero dati operatore...
            int matrOpr = 0;
            try
            {
                matrOpr = Convert.ToInt32(BarCode.Replace(prefDichOp, ""));
            }
            catch
            {
                logger.lg.scriviLog(string.Format("Barcode operatore non valido! {0}", BarCode));
            }
            if (matrOpr > 0)
            {
                DS_applicazione.AnagraficaOperatoriRow rigaOperatore = getRigaOperatore(matrOpr);
                if (rigaOperatore != null)
                {
                    if (rigaOperatore.isAdmin)
                    // se è admin apro finestra modifica
                    {
                        int minutiUpdateAdmin = memLayer.ML.confReadInt("minutiUpdateAdmin");
                        DataLayer.obj.taPostazioni.updateOperatoreAdmin(idxPostazione, matrOpr, minutiUpdateAdmin);
                        // salvo che sono in stato edit admin
                        adminInput = true;
                        // aggiorno pagina
                        salvaRicarica(string.Format("Benvenuto {0} {1}!", rigaOperatore.Nome, rigaOperatore.Cognome), string.Format("potrai effettuare operazioni amministrative fino alle {0:HH:mm:ss}", DateTime.Now.AddMinutes(minutiUpdateAdmin)));
                    }
                    else
                    // se è user std sostituisco utente corrente su macchina...
                    {
                        DataLayer.obj.taStatoMacchine.updateOper(idxMacchina, matrOpr);
                        salvaRicarica("Cambio Operatore", "effettuato cambio operatore");
                    }
                }
                else
                {
                    salvaRicarica("Errore", string.Format("Matricola operatore non valida! {0}", BarCode));
                }
            }
        }
        /// <summary>
        /// salva in sessione cosa mostrare x messaggio operatore e ricarica
        /// </summary>
        /// <param name="titolo"></param>
        /// <param name="mess"></param>
        protected void salvaRicarica(string titolo, string mess)
        {
            memLayer.ML.setSessionVal("lblTitoloUI", titolo);
            memLayer.ML.setSessionVal("lblMessUI", mess);
            // rimando a pagina attuale x evitare che "resti aperta " per troppo la finestra...
            Response.Redirect(string.Format("~/UI.aspx?idxPostazione={0}&idxMacchina={1}", idxPostazione, idxMacchina));
        }
        /// <summary>
        /// fornisce classe CSS x colorare il turno secondo apertura o meno
        /// </summary>
        /// <param name="turno"></param>
        /// <returns></returns>
        public string coloreDaTurno(object turno)
        {
            string answ = "sGr";
            bool aperto = false;
            try
            {
                aperto = Convert.ToBoolean(turno);
            }
            catch
            { }
            if (aperto) answ = "sVe";
            return answ;
        }
    }
}