using System;
using System.Collections.Generic;
using System.Text;
using ETS_Data;
using System.IO;
using System.Web;
using NLog;

namespace ETS_Data
{
    /// <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 Protected Fields

        protected Logger lg = LogManager.GetCurrentClassLogger();

        #endregion Protected Fields

        #region Public Fields

        /// <summary>
        /// versione statica della classe utente come singleton UtenTeSignletoN
        /// </summary>
        public static user_std UtSn = new user_std();

        #endregion Public Fields

        #region Public Constructors

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

        #endregion Public Constructors

        #region Public Properties

        /// <summary>
        /// pagina correntemente visualizzata (URL in sessione)
        /// </summary>
        public static string pagCorrente
        {
            get
            {
                return utils.obj.StringSessionObj("pagCorrente");
            }
            set
            {
                utils.obj.setSessionVal("pagCorrente", value);
            }
        }

        /// <summary>
        /// pagina precedentemente visualizzata (URL in sessione)
        /// </summary>
        public static string pagPrecedente
        {
            get
            {
                return utils.obj.StringSessionObj("pagPrecedente");
            }
            set
            {
                utils.obj.setSessionVal("pagPrecedente", value);
            }
        }

        /// <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 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, nome e matricola
        /// </summary>
        public string CognomeNomeMatr
        {
            get
            {
                return string.Format("{0} {1} ({2})", rigaUtente.COGNOME, rigaUtente.NOME, rigaUtente.MATRICOLA);
            }
        }

        /// <summary>
        /// utente correntemente connesso per utilizzo FileSystem (Formato dominio.username)
        /// </summary>
        public string currUser_FS
        {
            get
            {
                return currUserAD.Replace(@"\", ".");
            }
        }

        /// <summary>
        /// utente correntemente connesso (Formato dominio\username)
        /// </summary>
        public string currUserAD
        {
            get
            {
                string answ = "";
                try
                {
                    if (HttpContext.Current.User.Identity.IsAuthenticated)
                    {
                        answ = HttpContext.Current.User.Identity.Name;
                    }
                }
                catch
                { }
                return answ;
            }
        }

        /// <summary>
        /// utente correntemente connesso (Formato Cognome nome)
        /// </summary>
        public string currUserCognomeNome
        {
            get
            {
                string answ = "-";
                try
                {
                    // controllo in sessione...
                    if (utils.obj.isInSessionObject("currUserCognomeNome"))
                    {
                        answ = utils.obj.StringSessionObj("currUserCognomeNome");
                    }
                    else
                    {
                        // cerco user da elenco...
                        DS_Anagrafica.UtentiRow riga = (DS_Anagrafica.UtentiRow)utils.obj.taUtenti.getByKey(currUserAD)[0];
                        answ = string.Format("{0} {1}", riga.Cognome, riga.Nome);
                        utils.obj.setSessionVal("currUserCognomeNome", answ);
                    }
                }
                catch
                { }
                return answ;
            }
        }

        /// <summary>
        /// EMAIL utente correntemente connesso
        /// </summary>
        public string currUserEmail
        {
            get
            {
                string answ = "info@ets.it";
                try
                {
                    // controllo in sessione...
                    if (utils.obj.isInSessionObject("currUserEmail"))
                    {
                        answ = utils.obj.StringSessionObj("currUserEmail");
                    }
                    else
                    {
                        // cerco user da elenco...
                        DS_Anagrafica.UtentiRow riga = (DS_Anagrafica.UtentiRow)utils.obj.taUtenti.getByKey(currUserAD)[0];
                        answ = riga.email;
                        utils.obj.setSessionVal("currUserEmail", answ);
                    }
                }
                catch
                {
                    answ = "info@ets.it";
                }
                return answ;
            }
        }

        /// <summary>
        /// UserId (AD) utente correntemente connesso
        /// </summary>
        public string currUserId
        {
            get
            {
                // controllo e salvo in sessione se necessario...
                if (!utils.obj.isInSessionObject("currUserId"))
                {
                    utils.obj.setSessionVal("currUserId", currUserAD);
                }
                return currUserAD;
            }
        }

        /// <summary>
        /// utente correntemente connesso (Formato Nome Cognome)
        /// </summary>
        public string currUserNomeCognome
        {
            get
            {
                string answ = "-";
                try
                {
                    // controllo in sessione...
                    if (utils.obj.isInSessionObject("currUserNomeCognome"))
                    {
                        answ = utils.obj.StringSessionObj("currUserNomeCognome");
                    }
                    else
                    {
                        // cerco user da elenco...
                        DS_Anagrafica.UtentiRow riga = (DS_Anagrafica.UtentiRow)utils.obj.taUtenti.getByKey(currUserAD)[0];
                        answ = string.Format("{0} {1}", riga.Nome, riga.Cognome);
                        utils.obj.setSessionVal("currUserNomeCognome", answ);
                    }
                }
                catch
                { }
                return answ;
            }
        }

        /// <summary>
        /// restituisce la tabella diritti da session
        /// </summary>
        public DataLayer_AnagGen.DIRITTIDataTable diritti
        {
            get
            {
                return (DataLayer_AnagGen.DIRITTIDataTable)utils.obj.objSessionObj("dirittiUtente");
            }
            set
            {
                utils.obj.setSessionVal("dirittiUtente", value);
            }
        }

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

        /// <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>
        /// restituisce true se utente forzato da forceUser.aspx
        /// </summary>
        public bool isForcedUser
        {
            get
            {
                return utils.obj.BoolSessionObj("isForcedUser");
            }
            set
            {
                utils.obj.setSessionVal("isForcedUser", value);
            }
        }

        /// <summary>
        /// oggetto lingua utente con metodi get/set
        /// </summary>
        public string lingua
        {
            get
            {
                return utils.obj.StringSessionObj("Lingua").ToUpper();
            }
            set
            {
                utils.obj.setSessionVal("Lingua", value);
            }
        }

        /// <summary>
        /// fornisce un file XML della mappa del sito abilitato per l'utente...
        /// </summary>
        public string mappaSito
        {
            get
            {
                return utils.obj.StringSessionObj("mappaSito");
            }
            set
            {
                utils.obj.setSessionVal("mappaSito", value);
            }
        }

        /// <summary>
        /// oggetto modulo (applicazione) con metodi get/set
        /// </summary>
        public string modulo
        {
            get
            {
                return utils.obj.confReadString("CodModulo");
            }
        }

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

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

        /// <summary>
        /// oggetto password con metodi get/set
        /// </summary>
        public string passwd
        {
            get
            {
                return utils.obj.StringSessionObj("passwd");
            }
            set
            {
                utils.obj.setSessionVal("passwd", value);
            }
        }

        /// <summary>
        /// tabella dei permessi utente
        /// </summary>
        public DataLayer_AnagGen.PermessiDataTable permessi
        {
            get
            {
                DataLayer_AnagGen.PermessiDataTable tabPermessi = null;
                try
                {
                    tabPermessi = (DataLayer_AnagGen.PermessiDataTable)utils.obj.objSessionObj("permessiUtente");
                }
                catch (Exception exc)
                {
                    lg.Error($"Errore recupero permessi!{Environment.NewLine}{exc}");
                }
                return tabPermessi;
            }
            set
            {
                utils.obj.setSessionVal("permessiUtente", value);
            }
        }

        /// <summary>
        /// tabella dei permessi utente di tipo "WRITE" enabled
        /// </summary>
        public DataLayer_AnagGen.PermessiDataTable permessiWrite
        {
            get
            {
                return (DataLayer_AnagGen.PermessiDataTable)utils.obj.objSessionObj("permessiUtenteWrite");
            }
            set
            {
                utils.obj.setSessionVal("permessiUtenteWrite", value);
            }
        }

        /// <summary>
        /// restituisce i valori della riga utente da db
        /// </summary>
        public DataLayer_AnagGen.UTENTERow rigaUtente
        {
            get
            {
                return (DataLayer_AnagGen.UTENTERow)utils.obj.objSessionObj("rigaUtente");
            }
            set
            {
                utils.obj.setSessionVal("rigaUtente", value);
            }
        }

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

        /// <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 utils.obj.StringSessionObj("USER_NAME");
            }
            set
            {
                utils.obj.setSessionVal("USER_NAME", value);
            }
        }

        #endregion Public Properties

        #region Protected Methods

        /// <summary>
        /// cancella da session l'utente
        /// </summary>
        protected void clearAllUserData()
        {
            utils.obj.emptySessionVal("USER_NAME");
            utils.obj.emptySessionVal("DOMINIO");
            utils.obj.emptySessionVal("permessiUtente");
        }

        /// <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
                    {
                    }
                }
            }
            if (filtroPerm == " COD_PERMESSO IN  (")
            {
                filtroPerm += "'PermessiNonTrovati' ";
            }
            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);
            }
            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);
                }
            }
            permessiWrite = _permessiUtenteWrite;
        }

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

        /// <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;
        }

        #endregion Protected Methods

        #region Public Methods

        /// <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 = utils.obj.confReadBool("authSenzaDominio");
            }
            catch
            { }
            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);
            }
            // risultato...
            isOk = (isOkUser && isOkPerm);
            return isOk;
        }

        /// <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>
        /// <param name="value"></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)
            {
                lg.Error($"Eccezione:{Environment.NewLine}{exc}");
            }
            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 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 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 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>
        /// crea un nuovo utente con le credenziali indicate
        /// </summary>
        /// <param name="dominio"></param>
        /// <param name="username"></param>
        /// <param name="cognome"></param>
        /// <param name="nome"></param>
        /// <param name="email"></param>
        /// <param name="matricola"></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>
        /// 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>
        /// restituisce email di un utente dato username e dominio...
        /// </summary>
        /// <param name="CognomeNome">Cognome Nome</param>
        /// <returns></returns>
        public string emailDaCognomeNome(string CognomeNome)
        {
            string answ = "-";
            try
            {
                DataLayer_AnagGen.UTENTERow riga = DataWrap.DW.taUtente.getByCognomeNome(CognomeNome)[0];
                answ = riga.EMAIL;
            }
            catch
            {
            }
            return answ;
        }

        /// <summary>
        /// restituisce email 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 email 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 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 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 (utils.obj.isInSessionObject("CdcEnabled4user4module"))
            {
                tabCdc = (DataLayer_AnagGen.CDCDataTable)utils.obj.objSessionObj("CdcEnabled4user4module");
            }
            else
            {
                tabCdc = DataWrap.DW.taCdc.getEnabledCDC(utente, cod_modulo);
                utils.obj.setSessionVal("CdcEnabled4user4module", tabCdc);
            }
            return tabCdc;
        }

        /// <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;
            try
            {
                System.Data.DataRow[] righe = permessi.Select(string.Format("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;
            try
            {
                System.Data.DataRow[] righe = permessiWrite.Select(string.Format("URL = '{0}'", pagina));
                answ = (righe.Length >= 1);
            }
            catch
            { }
            return answ;
        }

        /// <summary>
        /// LogOff utente con reset dati
        /// </summary>
        /// <param name="_dominio"></param>
        /// <param name="_username"></param>
        /// <returns></returns>
        public bool logOffUtente()
        {
            bool risultato = false;
            clearAllUserData();
            utente = "";
            dominio = "";
            risultato = true;
            return risultato;
        }

        /// <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 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
            { }
            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>
        /// <param name="value"></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 exc)
            {
                lg.Error($"Eccezione:{Environment.NewLine}{exc}");
            }
            return answ;
        }

        /// <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 utenteAD)
        {
            bool risultato = false;
            clearAllUserData();
            if (utenteAD != "")
            {
                char[] delimiters = new char[] { '\\' };
                string[] datiUt = currUserAD.Split(delimiters, StringSplitOptions.RemoveEmptyEntries);
                utente = datiUt[1];
                dominio = datiUt[0];
                setupRiga();
                setupDirittiPermessi();
                risultato = true;
            }
            return risultato;
        }

        /// <summary>
        /// calcola se l'utente abbia il diritto x la funzione indicata
        /// </summary>
        /// <param name="utenteAD">username formato AD</param>
        /// <param name="codModulo">codice modulo</param>
        /// <param name="codFunzione">codice funzione</param>
        /// <returns></returns>
        public bool userHasRight(string utenteAD, string codModulo, string codFunzione)
        {
            bool answ = false;
            try
            {
                answ = utils.obj.taDiritti.getByUserModFun(utenteAD, codModulo, codFunzione).Rows.Count > 0;
            }
            catch
            { }
            return answ;
        }

        /// <summary>
        /// verifica nella tab diritti se l'utente abbia il right richiesto e fornisce bool in risposta
        /// </summary>
        /// <param name="diritto"></param>
        /// <returns></returns>
        public bool userHasRight(string diritto)
        {
            bool _answ = false;
            if (diritti.Select(String.Format("COD_FUNZIONE ='{0}'", diritto)).Length > 0)
            {
                _answ = true;
            }
            return _answ;
        }

        #endregion Public Methods
    }
}