using System;
using System.Collections.Generic;

namespace SteamWare
{
    /// <summary>
    /// classe gestione utente: auth e permission/ruoli - versione GENERICA
    /// </summary>
    public class user_std
    {
        /* Classe che si occupa di:
         * ----------------------------------------
         * 1) gestione username
         * 2) gestione ruoli da anagrafica
         * 3) gestione declinazione ruoli in permessi
         * 4) gestione vocabolario
         * 
         * in Standard GENERICO
         */
        #region area protected / private

        #region metodi

        /// <summary>
        /// cancella da session l'utente
        /// </summary>
        protected void clearAllUserData()
        {
            memLayer.ML.emptySessionVal("USER_NAME");
            memLayer.ML.emptySessionVal("DOMINIO");
            memLayer.ML.emptySessionVal("permessiUtente");
        }
        /// <summary>
        /// carica la riga dati utente
        /// </summary>
        protected virtual void setupRiga()
        {
            //logger.lg.scriviLog(string.Format(@"setupRiga x utente {0}\{1}", dominio, utente), tipoLog.STARTUP);
            DataLayer_AnagGen.UTENTERow _rigaUtenteAnagGen = ((DataLayer_AnagGen.UTENTERow)DataWrap.DW.taUtente.GetDataByUtenteDominio(utente, dominio).Rows[0]);
            rigaUtente = _rigaUtenteAnagGen;
        }
        /// <summary>
        /// carica la riga dati utente da SOLO USERNAME
        /// </summary>
        protected virtual void setupRigaByUsername()
        {
            DataLayer_AnagGen.UTENTERow _rigaUtenteAnagGen = ((DataLayer_AnagGen.UTENTERow)DataWrap.DW.taUtente.getByUserName(utente).Rows[0]);
            rigaUtente = _rigaUtenteAnagGen;
        }
        /// <summary>
        /// Carica la tabella diritti dell'utente da db e salva in session
        /// </summary>
        protected virtual void setupDirittiPermessi()
        {
            DataLayer_AnagGen.DIRITTIDataTable _dirittiUtente = DataWrap.DW.taDiritti.GetByUserDominioModulo(utente, dominio, modulo);
            diritti = _dirittiUtente; // salvo in session i diritti..
            if (diritti.Count > 0)
            {
                setPermessiDaDiritti();
            }
        }
        /// <summary>
        /// Carica la tabella diritti dell'utente da db e salva in session
        /// </summary>
        protected virtual void setupDirittiPermessiByUsername()
        {
            DataLayer_AnagGen.DIRITTIDataTable _dirittiUtente = DataWrap.DW.taDiritti.GetByUserModulo(utente, modulo);
            diritti = _dirittiUtente; // salvo in session i diritti..
            if (diritti.Count > 0)
            {
                setPermessiDaDiritti();
            }
        }
        /// <summary>
        /// Carica la tabella diritti dell'utente da db e salva in session SOLO per il CDC indicato
        /// </summary>
        /// <param name="cdc"></param>
        protected virtual void setupDirittiPermessi(string cdc)
        {
            DataLayer_AnagGen.DIRITTIDataTable _dirittiUtente = DataWrap.DW.taDiritti.GetByUserDominioModuloCdc(utente, dominio, modulo, cdc);
            diritti = _dirittiUtente; // salvo in session i diritti..
            if (diritti.Count > 0)
            {
                setPermessiDaDiritti();
            }
        }
        /// <summary>
        /// Effettua setup dei permessi una volta salvati i diritti
        /// </summary>
        protected virtual void setPermessiDaDiritti()
        {
            // proseguo coi permessi
            DataLayer_AnagGen.PermessiDataTable allPermessi = DataWrap.DW.taPermessi.GetData();
            DataLayer_AnagGen.Permessi2FunzioneDataTable allPerm2Funz = DataWrap.DW.taPermessi2Funzione.GetData();
            DataLayer_AnagGen.PermessiDataTable _permessiUtente = new DataLayer_AnagGen.PermessiDataTable();
            DataLayer_AnagGen.PermessiDataTable _permessiUtenteWrite = new DataLayer_AnagGen.PermessiDataTable();
            string filtroFunz, filtroPerm, filtroPermWrite;
            filtroPerm = " COD_PERMESSO IN  (";
            filtroPermWrite = " COD_PERMESSO IN  (";
            // filtro i diritti utente x non avere duplicati...
            Dictionary<string, string> funzioniUtente = new Dictionary<string, string>();
            foreach (DataLayer_AnagGen.DIRITTIRow riga in diritti)
            {
                try
                {
                    funzioniUtente.Add(riga.COD_FUNZIONE, riga.COD_FUNZIONE);
                }
                catch
                { }
            }
            foreach (KeyValuePair<string, string> kvp in funzioniUtente)
            {
                filtroFunz = string.Format("COD_FUNZIONE='{0}'", kvp.Value);
                // recupero le righe dei righe2perm
                DataLayer_AnagGen.Permessi2FunzioneRow[] righe_p2f = (DataLayer_AnagGen.Permessi2FunzioneRow[])allPerm2Funz.Select(filtroFunz);
                foreach (DataLayer_AnagGen.Permessi2FunzioneRow riga_p2f in righe_p2f)
                {
                    filtroPerm += string.Format("'{0}', ", riga_p2f.COD_PERMESSO);
                    // se � write metto in tab relativa...
                    try
                    {
                        if (riga_p2f.READWRITE == "S")
                        {
                            filtroPermWrite += string.Format("'{0}', ", riga_p2f.COD_PERMESSO);
                        }
                    }
                    catch
                    {
                    }
                }
            }
            // cambio modalit� controllo permessi abilitati x problema permessi non trovati...
            if (filtroPerm != " COD_PERMESSO IN  (")
            {
                filtroPerm = filtroPerm.Remove(filtroPerm.Length - 2);
                filtroPerm += ") ";
                DataLayer_AnagGen.PermessiRow[] righePerm = (DataLayer_AnagGen.PermessiRow[])allPermessi.Select(filtroPerm, "GRUPPO, NUMERO");
                foreach (DataLayer_AnagGen.PermessiRow rigaPerm in righePerm)
                {
                    _permessiUtente.ImportRow(rigaPerm);
                }
            }
            else
            {
                logger.lg.scriviLog("Permessi utente non trovati!", tipoLog.ERROR);
            }
            permessi = _permessiUtente;
            // salvo, se ci sono, permessi write...
            if (filtroPermWrite != " COD_PERMESSO IN  (")
            {
                filtroPermWrite = filtroPermWrite.Remove(filtroPermWrite.Length - 2);
                filtroPermWrite += ") ";
                DataLayer_AnagGen.PermessiRow[] righePermW = (DataLayer_AnagGen.PermessiRow[])allPermessi.Select(filtroPermWrite, "GRUPPO, NUMERO");
                foreach (DataLayer_AnagGen.PermessiRow rigaPerm in righePermW)
                {
                    _permessiUtenteWrite.ImportRow(rigaPerm);
                }
            }
            else
            {
                logger.lg.scriviLog("Permessi utente WRITE non trovati!", tipoLog.ERROR);
            }
            permessiWrite = _permessiUtenteWrite;
        }

        /// <summary>
        /// imposta la lingua utente dal valore della riga DB
        /// </summary>
        protected virtual void setupLingua()
        {
            string _lingua = "";
            try
            {
                _lingua = rigaUtente.COD_LINGUA;
            }
            catch { }
            if (string.IsNullOrEmpty(_lingua))
            {
                _lingua = "IT";
            }

            lingua = _lingua;
        }

        /// <summary>
        /// costruisce la mappa del sito per l'utente
        /// </summary>
        protected virtual void setupMappaSito()
        {
            string _mappa = "";
            _mappa += "<mainMenu>";
            try
            {
                // partiamo dai permessi utente di numero "0" (sono intestazioni men�...)
                DataLayer_AnagGen.PermessiRow[] vociMenu = (DataLayer_AnagGen.PermessiRow[])permessi.Select("NUMERO ='0'", "GRUPPO");
                foreach (DataLayer_AnagGen.PermessiRow voce in vociMenu)
                {
                    _mappa += formattaNodo(voce.NOME, voce.DESCRIZIONE, voce.URL, siteNodeType.startContainer);
                    // per ogni livello riempiamo con i permessi figli
                    DataLayer_AnagGen.PermessiRow[] pagine = (DataLayer_AnagGen.PermessiRow[])permessi.Select(string.Format("GRUPPO ='{0}' AND NUMERO > 0", voce.GRUPPO), "NUMERO");
                    foreach (DataLayer_AnagGen.PermessiRow pagina in pagine)
                    {
                        _mappa += formattaNodo(pagina.NOME, pagina.DESCRIZIONE, pagina.URL, siteNodeType.leaf);
                    }
                    _mappa += formattaNodo(voce.NOME, voce.DESCRIZIONE, voce.URL, siteNodeType.endContainer);
                }
            }
            catch
            { }
            // salva in session...
            _mappa += "</mainMenu>";
            mappaSito = _mappa;
        }

        /// <summary>
        /// formatta un nodo in modo corretto dai dati indicati
        /// </summary>
        /// <param name="titolo"></param>
        /// <param name="descrizione"></param>
        /// <param name="url"></param>
        /// <param name="tipoNodo"></param>
        protected string formattaNodo(string titolo, string descrizione, string url, siteNodeType tipoNodo)
        {
            string _out = "";
            switch (tipoNodo)
            {
                case siteNodeType.startContainer:
                    _out = string.Format("<menu title=\"{0}\" description=\"{1}\" url=\"~/{2}\">", Traduci(titolo), Traduci(descrizione), url);
                    break;
                case siteNodeType.endContainer:
                    _out = "</menu>";
                    break;
                case siteNodeType.leaf:
                    _out = string.Format("<voce title=\"{0}\" description=\"{1}\" url=\"~/{2}\" />", Traduci(titolo), Traduci(descrizione), url);
                    break;
            }
            return _out;
        }

        #endregion

        #endregion

        #region area public

        #region area utente

        /// <summary>
        /// restituisce la tabella diritti da session
        /// </summary>
        public DataLayer_AnagGen.DIRITTIDataTable diritti
        {
            get
            {
                if (memLayer.ML.serializeSession)
                {
                    return DataSetAdapter<DataLayer_AnagGen.DIRITTIDataTable>.convert(memLayer.ML.dsSessionObj("dirittiUtente"));
                }
                else
                {
                    return (DataLayer_AnagGen.DIRITTIDataTable)memLayer.ML.objSessionObj("dirittiUtente");
                }
            }
            set
            {
                if (memLayer.ML.serializeSession)
                {
                    memLayer.ML.setSessionDataTable("dirittiUtente", value);
                }
                else
                {
                    memLayer.ML.setSessionVal("dirittiUtente", value);
                }
            }
        }
        /// <summary>
        /// tabella dei permessi utente
        /// </summary>
        public DataLayer_AnagGen.PermessiDataTable permessi
        {
            get
            {
                DataLayer_AnagGen.PermessiDataTable tabPermessi = null;
                try
                {
                    if (memLayer.ML.serializeSession)
                    {
                        tabPermessi = DataSetAdapter<DataLayer_AnagGen.PermessiDataTable>.convert(memLayer.ML.dsSessionObj("permessiUtente"));
                    }
                    else
                    {
                        tabPermessi = (DataLayer_AnagGen.PermessiDataTable)memLayer.ML.objSessionObj("permessiUtente");
                    }

                }
                catch (Exception exc)
                {
                    logger.lg.scriviLog(String.Format("Errore recupero permessi!{0}{1}", Environment.NewLine, exc), tipoLog.EXCEPTION);
                }
                return tabPermessi;
            }
            set
            {
                if (memLayer.ML.serializeSession)
                {
                    memLayer.ML.setSessionDataTable("permessiUtente", value);
                }
                else
                {
                    memLayer.ML.setSessionVal("permessiUtente", value);
                }
            }
        }
        /// <summary>
        /// tabella dei permessi utente di tipo "WRITE" enabled
        /// </summary>
        public DataLayer_AnagGen.PermessiDataTable permessiWrite
        {
            get
            {
                if (memLayer.ML.serializeSession)
                {
                    return DataSetAdapter<DataLayer_AnagGen.PermessiDataTable>.convert(memLayer.ML.dsSessionObj("permessiUtenteWrite"));
                }
                else
                {
                    return (DataLayer_AnagGen.PermessiDataTable)memLayer.ML.objSessionObj("permessiUtenteWrite");
                }
            }
            set
            {
                if (memLayer.ML.serializeSession)
                {
                    memLayer.ML.setSessionDataTable("permessiUtenteWrite", value);
                }
                else
                {
                    memLayer.ML.setSessionVal("permessiUtenteWrite", value);
                }
            }
        }


        /// <summary>
        /// inizializza la gestione utente...
        /// </summary>
        public user_std()
        {
        }

        /// <summary>
        /// retituisce username AD
        /// </summary>
        public string userNameAD
        {
            get
            {
                return string.Format(@"{0}\{1}", dominio, utente);
            }
        }

        /// <summary>
        /// oggetto utente con metodi get/set
        /// </summary>
        public string utente
        {
            get
            {
                return memLayer.ML.StringSessionObj("USER_NAME");
            }
            set
            {
                memLayer.ML.setSessionVal("USER_NAME", value, true);
            }
        }
        /// <summary>
        /// oggetto password con metodi get/set
        /// </summary>
        public string passwd
        {
            get
            {
                return memLayer.ML.StringSessionObj("passwd");
            }
            set
            {
                memLayer.ML.setSessionVal("passwd", value, true);
            }
        }

        /// <summary>
        /// oggetto dominio con metodi get/set
        /// </summary>
        public string dominio
        {
            get
            {
                return memLayer.ML.StringSessionObj("DOMINIO");
            }
            set
            {
                memLayer.ML.setSessionVal("DOMINIO", value, true);
            }
        }

        /// <summary>
        /// oggetto modulo (applicazione) con metodi get/set
        /// </summary>
        public string modulo
        {
            get
            {
                return memLayer.ML.CRS("CodModulo");
            }
        }

        /// <summary>
        /// oggetto lingua utente con metodi get/set
        /// </summary>
        public string lingua
        {
            get
            {
                string answ = "";
                try
                {
                    answ = memLayer.ML.StringSessionObj("Lingua");
                }
                catch (Exception exc)
                {
                    logger.lg.scriviLog(string.Format("Errore recupero lingua utente{0}{1}", Environment.NewLine, exc), tipoLog.EXCEPTION);
                }
                if (string.IsNullOrEmpty(answ))
                {
                    answ = memLayer.ML.CRS("baseLang");
                }
                return answ.ToUpper();
            }
            set
            {
                memLayer.ML.setSessionVal("Lingua", value);
            }
        }
        /// <summary>
        /// oggetto runMode corrente
        /// </summary>
        public runModes currRunMode
        {
            get
            {
                runModes answ = runModes.normal;
                try
                {
                    if (memLayer.ML.isInSessionObject("runMode"))
                    {
                        answ = (runModes)memLayer.ML.objSessionObj("runMode");
                    }
                }
                catch
                { }
                return answ;
            }
            set
            {
                memLayer.ML.setSessionVal("runMode", value, true);
            }
        }

        /// <summary>
        /// restituisce true se utente forzato da forceUser
        /// </summary>
        public bool isForcedUser
        {
            get
            {
                return memLayer.ML.BoolSessionObj("isForcedUser");
            }
            set
            {
                memLayer.ML.setSessionVal("isForcedUser", value);
            }
        }

        /// <summary>
        /// restituisce i valori della riga utente da db
        /// </summary>
        public DataLayer_AnagGen.UTENTERow rigaUtente
        {
            get
            {
                if (memLayer.ML.serializeSession)
                {
                    DataLayer_AnagGen.UTENTEDataTable table = DataSetAdapter<DataLayer_AnagGen.UTENTEDataTable>.convert(memLayer.ML.dsSessionObj("rigaUtente"));
                    return table[0];
                }
                else
                {
                    return (DataLayer_AnagGen.UTENTERow)memLayer.ML.objSessionObj("rigaUtente");
                }
            }
            set
            {
                if (memLayer.ML.serializeSession)
                {
                    memLayer.ML.setSessionDataTable("rigaUtente", value.Table);
                }
                else
                {
                    memLayer.ML.setSessionVal("rigaUtente", value);
                }
            }
        }

        /// <summary>
        /// restituisce riga utente data la matricola...
        /// </summary>
        /// <param name="matricola">matricola</param>
        /// <returns></returns>
        public DataLayer_AnagGen.UTENTERow rigaUtenteDaMatricola(string matricola)
        {
            DataLayer_AnagGen.UTENTERow answ = null;
            try
            {
                answ = DataWrap.DW.taUtente.getByMatricola(matricola)[0];
            }
            catch (Exception exc)
            {
                logger.lg.scriviLog(string.Format("{0}{1}", Environment.NewLine, exc), tipoLog.EXCEPTION);
            }
            return answ;
        }

        /// <summary>
        /// restituisce una stringa formattata con cognome, nome e matricola
        /// </summary>
        public string CognomeNomeMatr
        {
            get
            {
                return string.Format("{0} {1} ({2})", rigaUtente.COGNOME, rigaUtente.NOME, rigaUtente.MATRICOLA);
            }
        }

        /// <summary>
        /// restituisce una stringa della sigla dell'utente
        /// </summary>
        public string sigla
        {
            get
            {
                string answ = "";
                if (isAuth)
                {
                    answ = rigaUtente.SIGLA;
                }
                return answ;
            }
        }

        /// <summary>
        /// restituisce una stringa formattata con cognome e nome
        /// </summary>
        public string CognomeNome
        {
            get
            {
                string answ = "";
                if (isAuth)
                {
                    answ = string.Format("{0} {1}", rigaUtente.COGNOME, rigaUtente.NOME);
                }
                return answ;
            }
        }
        /// <summary>
        /// restituisce una stringa formattata con cognome
        /// </summary>
        public string cognome
        {
            get
            {
                string answ = "";
                if (isAuth)
                {
                    answ = string.Format("{0}", rigaUtente.COGNOME);
                }
                return answ;
            }
        }
        /// <summary>
        /// restituisce una stringa formattata con nome
        /// </summary>
        public string nome
        {
            get
            {
                string answ = "";
                if (isAuth)
                {
                    answ = string.Format("{0}", rigaUtente.NOME);
                }
                return answ;
            }
        }

        #endregion

        #region area vocabolario

        /// <summary>
        /// traduce il lemma nella lingua dell'user corrente
        /// </summary>
        /// <param name="lemma"></param>
        /// <returns></returns>
        public string Traduci(string lemma)
        {
            // lemma � invariante... .ToUpper()!!!
            lemma = lemma.ToUpper();
            string answ = string.Format("_{0}_", lemma);
            try
            {
                if (string.IsNullOrEmpty(lingua))
                {
                    lingua = memLayer.ML.CRS("baseLang");
                    if (string.IsNullOrEmpty(lingua))
                    {
                        lingua = "IT";
                    }
                }
                if (DataWrap.DW.vocabolarioOk)
                {
                    answ = DataWrap.DW.dictVocabolario[lingua + "#" + lemma];
                }
            }
            catch (Exception exc)
            {
                logger.lg.scriviLog(String.Format("Eccezione durante traduzione:{0}{1}", Environment.NewLine, exc), tipoLog.EXCEPTION);
                // loggo!
                logger.lg.scriviLog(lemma, tipoLog.LEMMA);
                // loggo risultato x voc
                logger.lg.scriviLog(string.Format("Presenti {0} lemmi in vocabolario, richiesto lingua {1} | lemma {2}", DataWrap.DW.numRecVoc, lingua, lemma));
                if (DataWrap.DW.numRecVoc > 4)
                {
                    // mostro primi 4...
                    int i = 0;
                    foreach (var item in DataWrap.DW.dictVocabolario)
                    {
                        if (i <= 4)
                        {
                            logger.lg.scriviLog(string.Format("Key: {0} | Val: {1}", item.Key, item.Value), tipoLog.INFO);
                            i++;
                        }
                    }
                }
            }
            if (currRunMode == runModes.echoLemmi)
            {
                logger.lg.scriviLog(lemma, tipoLog.LEMMA);
            }

            return answ;
        }

        /// <summary>
        /// traduce il lemma in inglese
        /// </summary>
        /// <param name="lemma"></param>
        /// <returns></returns>
        public string TraduciEn(string lemma)
        {
            // lemma � invariante... .ToUpper()!!!
            lemma = lemma.ToUpper();
            string answ = string.Format("_{0}_", lemma);
            try
            {
                answ = DataWrap.DW.dictVocabolario["EN#" + lemma];
            }
            catch
            {
            }
            return answ;
        }

        /// <summary>
        /// traduce il lemma nella lingua richiesta
        /// </summary>
        /// <param name="lemma">The lemma.</param>
        /// <param name="lingua">The lingua.</param>
        /// <returns></returns>
        public string Traduci(string lemma, string lingua)
        {
            // lemma � invariante... .ToUpper()!!!
            lemma = lemma.ToUpper();
            string answ = string.Format("_{0}_", lemma);
            try
            {
                answ = DataWrap.DW.dictVocabolario[lingua + "#" + lemma];
            }
            catch
            {
            }
            return answ;
        }

        /// <summary>
        /// traduce il lemma nella lingua dell'user e in inglese tra parentesi
        /// </summary>
        /// <param name="lemma"></param>
        /// <returns></returns>
        public string FullTrad(string lemma)
        {
            return Traduci(lemma) + " (" + TraduciEn(lemma) + ")";
        }

        #endregion

        /// <summary>
        /// fornisce un file XML della mappa del sito abilitato per l'utente...
        /// </summary>
        public string mappaSito
        {
            get
            {
                return memLayer.ML.StringSessionObj("mappaSito");
            }
            set
            {
                memLayer.ML.setSessionVal("mappaSito", value);
            }
        }
        /// <summary>
        /// LogOff utente con reset dati
        /// </summary>
        /// <returns></returns>
        public bool logOffUtente()
        {
            bool risultato = false;
            clearAllUserData();
            utente = "";
            dominio = "";
            risultato = true;
            return risultato;
        }
        /// <summary>
        /// Procedura da chiamare DOPO aver messo in session i dati utente/dominio x caricare gli altri dati
        /// </summary>
        /// <param name="_dominio"></param>
        /// <param name="_username"></param>
        /// <returns></returns>
        public bool startUpUtente(string _dominio, string _username)
        {
            bool risultato = false;
            try
            {
                clearAllUserData();
                if (_username != "" && _dominio != "")
                {
                    //logger.lg.scriviLog(string.Format("startUpUtente:{2} dominio:\t{0}{2}username:\t{1}", _dominio, _username, Environment.NewLine), tipoLog.STARTUP); 
                    utente = _username;
                    dominio = _dominio;
                    setupRiga();
                    setupLingua();
                    setupDirittiPermessi();
                    setupMappaSito();
                    salvaDatiAccessori();
                    risultato = true;
                }
            }
            catch (Exception exc)
            {
                logger.lg.scriviLog(string.Format("Errore in fase di startUpUtente:{0}{1}", Environment.NewLine, exc), tipoLog.EXCEPTION);
            }
            return risultato;
        }
        /// <summary>
        /// Procedura da chiamare DOPO aver messo in session i dati utente/dominio x caricare gli altri dati
        /// </summary>
        /// <param name="_username"></param>
        /// <param name="_pwd"></param>
        /// <returns></returns>
        public bool startUpUtentePwd(string _username, string _pwd)
        {
            bool risultato = false;
            clearAllUserData();
            if (_username != "" && _pwd != "")
            {
                // controllo la pwd 
                if (checkUserPwd(_username, _pwd))
                {
                    dominio = memLayer.ML.CRS("defaultDomain"); // forzo a valore web.config per non incappare in errori successivi
                    utente = _username;
                    passwd = _pwd;
                    setupRigaByUsername();
                    setupLingua();
                    setupDirittiPermessiByUsername();
                    setupMappaSito();
                    salvaDatiAccessori();
                    risultato = true;
                }
                else
                {
                    risultato = false;
                }
            }
            return risultato;
        }
        /// <summary>
        /// controllo utente/pwd da tab
        /// </summary>
        /// <param name="_username"></param>
        /// <param name="_pwd"></param>
        /// <returns></returns>
        private bool checkUserPwd(string _username, string _pwd)
        {
            bool risultato = false;
            try
            {
                risultato = DataWrap.DW.taUserData.getByUserPwd(_username, _pwd).Rows.Count > 0;
            }
            catch
            { }
            return risultato;
        }
        /// <summary>
        /// Procedura da chiamare DOPO aver messo in session i dati utente/dominio x caricare gli altri dati CON I DIRITTI SOLO per il CDC indicato
        /// </summary>
        /// <param name="_dominio"></param>
        /// <param name="_username"></param>
        /// <param name="cdc"></param>
        /// <returns></returns>
        public bool startUpUtente(string _dominio, string _username, string cdc)
        {
            bool risultato = false;
            clearAllUserData();
            if (_username != "" && _dominio != "")
            {
                utente = _username;
                dominio = _dominio;
                setupRiga();
                setupLingua();
                setupDirittiPermessi(cdc);
                setupMappaSito();
                salvaDatiAccessori();
                risultato = true;
            }
            return risultato;
        }
        /// <summary>
        /// salva dati accessori quali il cdc dell'utente...
        /// </summary>
        protected virtual void salvaDatiAccessori()
        {
            // salvo il cdc utente...
            memLayer.ML.setSessionVal("CdCUser", rigaUtente.COD_CDC);
            // verifico se necessario fare echo lemmi e vado in runMode di echo dei termini tradotti
            bool echoLemmi = false;
            try
            {
                echoLemmi = memLayer.ML.CRB("echoLemmi");
            }
            catch
            { }
            if (echoLemmi)
            {
                currRunMode = runModes.echoLemmi;
            }
            else
            {
                currRunMode = runModes.normal;
            }
        }
        /// <summary>
        /// verifica nella tab diritti se l'utente abbia il right richiesto (come COD_FUNZIONE) e fornisce bool in risposta
        /// </summary>
        /// <param name="diritto"></param>
        /// <returns></returns>
        public bool userHasRight(string diritto)
        {
            bool _answ = false;
            try
            {
                if (diritti.Select(String.Format("COD_FUNZIONE ='{0}'", diritto)).Length > 0)
                {
                    _answ = true;
                }
            }
            catch (Exception exc)
            { }
            return _answ;
        }
        /// <summary>
        /// verifica le credenziali AD dell'utente...
        /// </summary>
        /// <param name="dominio"></param>
        /// <param name="username"></param>
        /// <returns></returns>
        public virtual bool ADuserOk(string dominio, string username)
        {
            bool isOk = false;
            // ...verifico sia in tabella utenti...
            bool isOkUser = false;
            // ...e che abbia diritti per l'applicativo...
            bool isOkPerm = false;
            // controllo se richiesta autenticazione completa dominio + username o solo username...
            bool authSenzaDominio = false;
            try
            {
                authSenzaDominio = memLayer.ML.CRB("authSenzaDominio");

                if (authSenzaDominio)
                {
                    isOkUser = (DataWrap.DW.taUtente.getByUserName(username).Rows.Count >= 1);
                    isOkPerm = (DataWrap.DW.taDiritti.GetByUserModulo(username, modulo).Rows.Count >= 1);
                }
                else
                {
                    isOkUser = (DataWrap.DW.taUtente.GetDataByUtenteDominio(username, dominio).Rows.Count >= 1);
                    isOkPerm = (DataWrap.DW.taDiritti.GetByUserDominioModulo(username, dominio, modulo).Rows.Count >= 1);
                }
            }
            catch (Exception exc)
            {
                logger.lg.scriviLog($"Exception during ADuserOk:{Environment.NewLine}{exc}");
            }
            // risultato...
            isOk = (isOkUser && isOkPerm);
            return isOk;
        }
        /// <summary>
        /// � un boolean che indica se in session ci siano user/dominio e quindi utente autenticato in precedenza...
        /// </summary>
        public bool isAuth
        {
            get
            {
                return (utente != "" && dominio != "");
            }
        }
        /// <summary>
        /// conta il numero di permessi utente per la pagina attuale e restituisce true se ne trova almeno 1
        /// </summary>
        /// <param name="pagina"></param>
        /// <returns></returns>
        public bool isPageEnabled(string pagina)
        {
            bool answ = false;
            // tolgo (se ci fosse) .aspx finale...
            pagina = pagina.Replace(".aspx", "");
            if (permessi != null)
            {
                try
                {
                    System.Data.DataRow[] righe = permessi.Select(string.Format("URL = '{0}.aspx' OR URL = '{0}'", pagina));
                    answ = (righe.Length >= 1);
                }
                catch
                { }
            }
            return answ;
        }
        /// <summary>
        /// verifica se il permesso utente per la pagina attuale sia write per almeno 1 diritto assegnato (restituisce true se ne trova almeno 1 con permessi2funzione.readwrite='S')
        /// </summary>
        /// <param name="pagina"></param>
        /// <returns></returns>
        public bool isPageWriteEnabled(string pagina)
        {
            bool answ = false;
            // tolgo (se ci fosse) .aspx finale...
            pagina = pagina.Replace(".aspx", "");
            try
            {
                System.Data.DataRow[] righe = permessiWrite.Select(string.Format("URL = '{0}.aspx' OR URL = '{0}'", pagina));
                answ = (righe.Length >= 1);
            }
            catch
            { }
            return answ;
        }
        /// <summary>
        /// ricarica e ri-traduce la mappa sito per l'utente...
        /// </summary>
        public void ricaricaMappaSito()
        {
            memLayer.ML.emptySessionVal("dirittiUtente");
            memLayer.ML.emptySessionVal("permessiUtente");
            setupDirittiPermessi();
            setupMappaSito();
        }
        /// <summary>
        /// retituisce il nome apgina dai permessi utente
        /// </summary>
        /// <param name="url"></param>
        public string nomePaginaDaPermessi(string url)
        {
            string answ = "";
            try
            {
                answ = permessi.Select(string.Format("URL = '{0}'", url))[0]["NOME"].ToString();
            }
            catch
            { }
            return answ;
        }
        /// <summary>
        /// restituisce cognome e nome di un utente dato username...
        /// </summary>
        /// <param name="userName">username</param>
        /// <returns></returns>
        public string CognomeNomeDaUsername(string userName)
        {
            string answ = "-";
            try
            {
                DataLayer_AnagGen.UTENTERow riga = DataWrap.DW.taUtente.getByUserName(userName)[0];
                answ = string.Format("{0} {1}", riga.COGNOME, riga.NOME);
            }
            catch
            {
            }
            return answ;
        }
        /// <summary>
        /// restituisce cognome e nome di un utente data la matricola...
        /// </summary>
        /// <param name="matricola">matricola</param>
        /// <returns></returns>
        public string CognomeNomeMatrDaMatricola(string matricola)
        {
            string answ = "-";
            try
            {
                DataLayer_AnagGen.UTENTERow riga = DataWrap.DW.taUtente.getByMatricola(matricola)[0];
                answ = string.Format("{0} {1} ({2})", riga.COGNOME, riga.NOME, riga.MATRICOLA);
            }
            catch
            {
            }
            return answ;
        }
        /// <summary>
        /// restituisce cognome e nome di un utente dato username e dominio...
        /// </summary>
        /// <param name="userName">username</param>
        /// <param name="dominio">dominio</param>
        /// <returns></returns>
        public string CognomeNomeDaUsername(string userName, String dominio)
        {
            string answ = "-";
            try
            {
                DataLayer_AnagGen.UTENTERow riga = DataWrap.DW.taUtente.GetDataByUtenteDominio(userName, dominio)[0];
                answ = string.Format("{0} {1}", riga.COGNOME, riga.NOME);
            }
            catch
            {
            }
            return answ;
        }
        /// <summary>
        /// restituisce cognome e nome di un utente dato username...
        /// </summary>
        /// <param name="userName">username</param>
        /// <returns></returns>
        public string emailDaUsername(string userName)
        {
            string answ = "-";
            try
            {
                DataLayer_AnagGen.UTENTERow riga = DataWrap.DW.taUtente.getByUserName(userName)[0];
                answ = riga.EMAIL;
            }
            catch
            {
            }
            return answ;
        }
        /// <summary>
        /// restituisce cognome e nome di un utente dato username e dominio...
        /// </summary>
        /// <param name="userName">username</param>
        /// <param name="dominio">dominio</param>
        /// <returns></returns>
        public string emailDaUsername(string userName, String dominio)
        {
            string answ = "-";
            try
            {
                DataLayer_AnagGen.UTENTERow riga = DataWrap.DW.taUtente.GetDataByUtenteDominio(userName, dominio)[0];
                answ = riga.EMAIL;
            }
            catch
            {
            }
            return answ;
        }
        /// <summary>
        /// restituisce cognome e nome di un utente dato username eventualmente comprensivo di dominio...
        /// </summary>
        /// <param name="userNameFull">{dominio\}userName</param>
        /// <returns></returns>
        public string CognomeNomeDaUser(string userNameFull)
        {
            string answ = "-";
            // se contiene "\" allora � con dominio...
            if (userNameFull.IndexOf('\\') > -1)
            {
                string[] userData = userNameFull.ToString().Split('\\');
                answ = CognomeNomeDaUsername(userData[1], userData[0]);
            }
            else
            {
                answ = CognomeNomeDaUsername(userNameFull);
            }
            return answ;
        }
        /// <summary>
        /// restituisce l'elenco delle funzioni abilitate dato modulo ed username partendo dalla radice dell'albero dei diritti
        /// </summary>
        /// <param name="user_name"></param>
        /// <param name="codModulo"></param>
        /// <returns></returns>
        public DataLayer_AnagGen.FUNZIONEDataTable funzioniUtente(string codModulo, string user_name)
        {
            return DataWrap.DW.taFunzione.getFunByDiritti_999(codModulo, user_name);
        }
        /// <summary>
        /// restituisce l'elenco degli utenti dato i diritti che devono avere come modulo/funzione
        /// </summary>
        /// <param name="codModulo">nome del modulo</param>
        /// <param name="codFunzione">nome della funzione</param>
        /// <returns>tabella utenti</returns>
        public DataLayer_AnagGen.UTENTEDataTable elencoDaDiritti(string codModulo, string codFunzione)
        {
            return DataWrap.DW.taUtente.getElencoByDiritti(codModulo, codFunzione);
        }
        /// <summary>
        /// restituisce l'elenco delle email degli utenti dato i diritti che devono avere come modulo/funzione
        /// </summary>
        /// <param name="codModulo">nome del modulo</param>
        /// <param name="codFunzione">nome della funzione</param>
        /// <returns>stringa di email separate da ","</returns>
        public string elencoEmailDaDiritti(string codModulo, string codFunzione)
        {
            char sep = ',';
            string answ = "";
            try
            {
                foreach (DataLayer_AnagGen.UTENTERow riga in elencoDaDiritti(codModulo, codFunzione))
                {
                    answ += string.Format("{0}{1} ", riga.EMAIL, sep);
                }
                if (answ.Length > 2)
                {
                    answ = answ.Substring(0, answ.Length - 2);
                }
            }
            catch
            {
            }
            return answ;
        }
        /// <summary>
        /// crea un nuovo utente con le credenziali indicate
        /// </summary>
        /// <param name="dominio">The dominio.</param>
        /// <param name="username">The username.</param>
        /// <param name="cognome">The cognome.</param>
        /// <param name="nome">The nome.</param>
        /// <param name="cod_cdc">The cod_cdc.</param>
        /// <param name="email">The email.</param>
        /// <param name="matricola">The matricola.</param>
        /// <param name="sigla">The sigla.</param>
        /// <returns></returns>
        public bool creaUtente(string dominio, string username, string cognome, string nome, string cod_cdc, string email, string matricola, string sigla)
        {
            bool answ = false;
            try
            {
                DataWrap.DW.taUtente.Insert(dominio, username, cognome, nome, "1", matricola, cod_cdc, email, sigla, "IT", "s");
                answ = true;
            }
            catch { }
            return answ;
        }
        /// <summary>
        /// assegna il diritto all'utente indicato
        /// </summary>
        /// <param name="username"></param>
        /// <param name="cod_cdc"></param>
        /// <param name="cod_modulo"></param>
        /// <param name="cod_funzione"></param>
        /// <returns></returns>
        public bool assegnaDirittoUtente(string username, string cod_cdc, string cod_modulo, string cod_funzione)
        {
            bool answ = false;
            try
            {
                DataWrap.DW.taDiritti.Insert(username, cod_cdc, cod_modulo, cod_funzione, "-1");
                answ = true;
            }
            catch (Exception exc)
            {
                logger.lg.scriviLog($"Exception during assegnaDirittoUtente:{Environment.NewLine}{exc}");
            }
            return answ;
        }
        /// <summary>
        /// toglier il diritto all'utente indicato
        /// </summary>
        /// <param name="username"></param>
        /// <param name="cod_cdc"></param>
        /// <param name="cod_modulo"></param>
        /// <param name="cod_funzione"></param>
        /// <returns></returns>
        public bool rimuoviDirittoUtente(string username, string cod_cdc, string cod_modulo, string cod_funzione)
        {
            bool answ = false;
            try
            {
                DataWrap.DW.taDiritti.DeleteQuery(username, cod_cdc, cod_modulo, cod_funzione);
                answ = true;
            }
            catch (Exception e)
            {
                logger.lg.scriviLog(String.Format("Eccezione: {0}", e));
            }
            return answ;
        }
        /// <summary>
        /// restituisce la tabella (per utente corrente) dei CDC abilitati per l'applicazione attuale da sessione (se non c'� salva...)
        /// </summary>
        /// <param name="cod_modulo">modulo di cui si testano i diritti</param>
        /// <returns></returns>
        public virtual DataLayer_AnagGen.CDCDataTable getEnabledCdc(string cod_modulo)
        {
            //init tabella
            DataLayer_AnagGen.CDCDataTable tabCdc = new DataLayer_AnagGen.CDCDataTable();
            // cerco in sessione elenco CDC
            if (memLayer.ML.isInSessionObject("CdcEnabled4user4module"))
            {
                if (memLayer.ML.serializeSession)
                {
                    tabCdc = DataSetAdapter<DataLayer_AnagGen.CDCDataTable>.convert(memLayer.ML.dsSessionObj("CdcEnabled4user4module"));
                }
                else
                {
                    tabCdc = (DataLayer_AnagGen.CDCDataTable)memLayer.ML.objSessionObj("CdcEnabled4user4module");
                }
            }
            else
            {
                tabCdc = DataWrap.DW.taCdc.getEnabledCDC(utente, cod_modulo);
                if (memLayer.ML.serializeSession)
                {
                    memLayer.ML.setSessionDataTable("CdcEnabled4user4module", tabCdc);
                }
                else
                {
                    memLayer.ML.setSessionVal("CdcEnabled4user4module", tabCdc);
                }
            }
            return tabCdc;
        }

        #endregion

        /// <summary>
        /// versione statica della classe utente come singleton UtenTeSignletoN
        /// </summary>
        public static user_std UtSn = new user_std();
        /// <summary>
        /// pagina correntemente visualizzata (URL in sessione)
        /// </summary>
        public static string pagCorrente
        {
            get
            {
                return memLayer.ML.StringSessionObj("pagCorrente");
            }
            set
            {
                memLayer.ML.setSessionVal("pagCorrente", value);
            }
        }
        /// <summary>
        /// pagina precedentemente visualizzata (URL in sessione)
        /// </summary>
        public static string pagPrecedente
        {
            get
            {
                return memLayer.ML.StringSessionObj("pagPrecedente");
            }
            set
            {
                memLayer.ML.setSessionVal("pagPrecedente", value);
            }
        }
    }

}