Samuele Locatelli
1092 lines
35 KiB
C#
1092 lines
35 KiB
C#
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
|
|
}
|
|
} |