Samuele E. Locatelli
1303 lines
45 KiB
C#
1303 lines
45 KiB
C#
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);
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|