Samuele E. Locatelli
1464 lines
52 KiB
C#
1464 lines
52 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.Data;
|
|
using System.IO;
|
|
|
|
namespace SteamWare
|
|
{
|
|
/// <summary>
|
|
/// Base class for every user control in the application, containing some common
|
|
/// behaviour and utility methods.
|
|
/// It is not meant to be be used directly.
|
|
/// </summary>
|
|
public class ApplicationUserControl : System.Web.UI.UserControl
|
|
{
|
|
/// <summary>
|
|
/// tipo id controllo con classi di base comune da cui derivare gli *.asmx
|
|
/// </summary>
|
|
public ApplicationUserControl()
|
|
{ }
|
|
/*
|
|
* Definizioni generali:
|
|
* SteamWare: codice scritto manualmente da SteamWare
|
|
* webForm: codice autogenerato da VisualStudio
|
|
* =c= : codice costante (non serve modifica)
|
|
* <c> : codice variabile (va modificato x ogni controllo / pagina)
|
|
*
|
|
* Notazione
|
|
* _ : se posto all'inizio del nome indica una variabile/oggetto caricato in memoria da input pagina e/o session
|
|
* MAIUS : le procedure / metodi con prima lettera in MAIUSCOLO indicano codice COSTANTE
|
|
* minus : le procedure / metodi con prima lettera in minuscolo indicano codice variabile da verificare/modificare
|
|
*/
|
|
|
|
|
|
/// <summary>
|
|
/// imposto il tipo di anagrafica del controlloS
|
|
/// </summary>
|
|
public tipoAnagrafica TipoAnagControllo
|
|
{
|
|
get
|
|
{
|
|
return _tipoAnagrafica;
|
|
}
|
|
set
|
|
{
|
|
_tipoAnagrafica = value;
|
|
}
|
|
}
|
|
|
|
#region dati utente e sessione =c=
|
|
|
|
/// <summary>
|
|
/// nome della pagina correntemente caricata
|
|
/// </summary>
|
|
public string _paginaCorrente;
|
|
/// <summary>
|
|
/// memorizza la pagina precedente (ovvero la corrente ma non da page-object ma in session...
|
|
/// </summary>
|
|
public string _paginaPrecedente;
|
|
/// <summary>
|
|
/// stringa con CDC in (...) dei cdc abilitati (da permesso gerarchicamente a discendere...)
|
|
/// </summary>
|
|
protected string _AuthCdC;
|
|
/// <summary>
|
|
/// stringa con elenco CDC abilitati (da permesso gerarchicamente a discendere...)
|
|
/// </summary>
|
|
protected string _CdCUser;
|
|
|
|
#endregion
|
|
|
|
#region tabelle dati
|
|
|
|
/// <summary>
|
|
/// tabella diritti
|
|
/// </summary>
|
|
protected DataLayer_AnagGen.DIRITTIDataTable _Diritti;
|
|
/// <summary>
|
|
/// tabella di tutti i cdc
|
|
/// </summary>
|
|
protected DataLayer_AnagGen.CDCDataTable _allCdC;
|
|
|
|
#endregion
|
|
|
|
#region altri dati
|
|
|
|
/// <summary>
|
|
/// tipo di anagrafica usata
|
|
/// </summary>
|
|
protected tipoAnagrafica _tipoAnagrafica = tipoAnagrafica.Standard;
|
|
/// <summary>
|
|
/// importo il tipo di vista del modulo
|
|
/// </summary>
|
|
protected tipoVistaMod _vistaModulo = tipoVistaMod.editing;
|
|
|
|
/// <summary>
|
|
/// elenco testuale csv dei cdc accessibili all'utente (x filtri tipo IN(...))
|
|
/// </summary>
|
|
protected string _elencoCdC;
|
|
/// <summary>
|
|
/// numero di righe standard x i datagrid
|
|
/// </summary>
|
|
protected int _righeDataGrid;
|
|
/// <summary>
|
|
/// numero di righe standard x i datagrid di anagrafica
|
|
/// </summary>
|
|
protected int _righeDataGridAnagr;
|
|
/// <summary>
|
|
/// numero di righe standard x i datagrid lunghi
|
|
/// </summary>
|
|
protected int _righeDataGridLong;
|
|
/// <summary>
|
|
/// numero di righe standard x i datagrid medi
|
|
/// </summary>
|
|
protected int _righeDataGridMed;
|
|
/// <summary>
|
|
/// numero di righe standard x i datagrid su mezza pagina
|
|
/// </summary>
|
|
protected int _righeDataGridShort;
|
|
/// <summary>
|
|
/// numero di righe standard x i selettori popup
|
|
/// </summary>
|
|
protected int _righeSelettore;
|
|
/// <summary>
|
|
/// indirizzo email dell'admin applicativo cui vanno le email in caso di anomalie...
|
|
/// </summary>
|
|
protected string _adminEmail;
|
|
/// <summary>
|
|
/// indirizzo email dell'applicativo da cui partono le email in caso di anomalie...
|
|
/// </summary>
|
|
protected string _fromEmail;
|
|
/// <summary>
|
|
/// indirizzo server SMTP
|
|
/// </summary>
|
|
protected string _smtpCli;
|
|
/// <summary>
|
|
/// elenco delle pagine "safe" ovvero da non autorizzare - da web.config
|
|
/// </summary>
|
|
protected string _safePages;
|
|
/// <summary>
|
|
/// elenco delle pagine "common" ovvero da autorizzare ma senza bisogno diritti in anagrafica - da web.config
|
|
/// </summary>
|
|
protected string _commonPages;
|
|
/// <summary>
|
|
/// valore che determina se è possibile forzare impersonificazioen utente...
|
|
/// </summary>
|
|
protected bool _allowForceUser;
|
|
/// <summary>
|
|
/// livello di log (1-->5)
|
|
/// </summary>
|
|
protected int _logLevel;
|
|
/// <summary>
|
|
/// dir di logging
|
|
/// </summary>
|
|
protected string _logBaseDir;
|
|
|
|
#endregion
|
|
|
|
#region flusso creazione pagina =c=
|
|
|
|
/// <summary>
|
|
/// MAIN: esecuzione al caricamento del modulo delle routines di controllo utente e creazione pagina
|
|
/// </summary>
|
|
/// <param name="sender"></param>
|
|
/// <param name="e"></param>
|
|
protected virtual void Page_Load(object sender, System.EventArgs e)
|
|
{
|
|
// carico i dati...
|
|
LoadUserData();
|
|
SetUpByUserRight();
|
|
loadSessionData();
|
|
PredisponiDati();
|
|
bindControlli();
|
|
}
|
|
|
|
/// <summary>
|
|
/// predisposizione dati x pagina da cache/database a seconda della disponibilità in cache o refresh (B.1.4)
|
|
/// </summary>
|
|
protected void PredisponiDati()
|
|
{
|
|
if (!datiDisponibili())
|
|
{
|
|
resetUpdate();
|
|
forza_Update();
|
|
}
|
|
else
|
|
{
|
|
caricaDati();
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// popola gli oggetti e le labels... (B.1.6)
|
|
/// </summary>
|
|
protected virtual void bindControlli()
|
|
{
|
|
// IsPostBack è TRUE se utilizzo javascript ovvero confermo cancellazioni o modifico i controlli...
|
|
if (!IsPostBack)
|
|
{
|
|
DisegnaPagina();
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// disegna la pagina: prima i controlli poi il datagrid
|
|
/// </summary>
|
|
protected void DisegnaPagina()
|
|
{
|
|
sistemaControlli();
|
|
aggiungiLink();
|
|
aggiornaControlliDataGL();
|
|
traduciObj();
|
|
}
|
|
/// <summary>
|
|
/// aggiunge i link x i selettori
|
|
/// </summary>
|
|
protected virtual void aggiungiLink()
|
|
{
|
|
}
|
|
|
|
/// <summary>
|
|
/// sistema i vari controlli della pagina
|
|
/// </summary>
|
|
protected virtual void sistemaControlli()
|
|
{ }
|
|
/// <summary>
|
|
/// aggiorna eventuali datalist e datagrid
|
|
/// </summary>
|
|
protected virtual void aggiornaControlliDataGL()
|
|
{
|
|
}
|
|
|
|
/// <summary>
|
|
/// sistema tutte le labels traducendo i lemmi nella lingua utente ed in inglese
|
|
/// </summary>
|
|
protected virtual void traduciObj()
|
|
{ }
|
|
|
|
|
|
|
|
#endregion
|
|
|
|
#region utility =c=
|
|
|
|
/// <summary>
|
|
/// calcola come percentuale la radio dividendo/divisore
|
|
/// </summary>
|
|
/// <param name="dividendo"></param>
|
|
/// <param name="divisore"></param>
|
|
/// <returns></returns>
|
|
public string percentuale(object dividendo, object divisore)
|
|
{
|
|
string answ = "";
|
|
double _dividendo = Convert.ToDouble(dividendo);
|
|
double _divisore = Convert.ToDouble(divisore);
|
|
try
|
|
{
|
|
answ = string.Format("{0:p}", _dividendo / _divisore);
|
|
}
|
|
catch
|
|
{ }
|
|
return answ;
|
|
}
|
|
|
|
/// <summary>
|
|
/// limita una stringa al numero max di caratteri imposto
|
|
/// </summary>
|
|
/// <param name="original"></param>
|
|
/// <param name="maxChar"></param>
|
|
/// <returns></returns>
|
|
public string limitString(string original, int maxChar)
|
|
{
|
|
string outString = original;
|
|
if (outString.Length > maxChar)
|
|
{
|
|
outString = string.Format("{0}...", original.Substring(0, maxChar - 3));
|
|
}
|
|
return outString;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Reads data from a stream until the end is reached. The
|
|
/// data is returned as a byte array. An IOException is
|
|
/// thrown if any of the underlying IO calls fail.
|
|
/// </summary>
|
|
/// <param name="stream">The stream to read data from</param>
|
|
/// <param name="initialLength">The initial buffer length</param>
|
|
public static byte[] ReadFully(Stream stream, int initialLength)
|
|
{
|
|
// If we've been passed an unhelpful initial length, just
|
|
// use 32K.
|
|
if (initialLength < 1)
|
|
{
|
|
initialLength = 32768;
|
|
}
|
|
|
|
byte[] buffer = new byte[initialLength];
|
|
int read = 0;
|
|
|
|
int chunk;
|
|
while ((chunk = stream.Read(buffer, read, buffer.Length - read)) > 0)
|
|
{
|
|
read += chunk;
|
|
|
|
// If we've reached the end of our buffer, check to see if there's
|
|
// any more information
|
|
if (read == buffer.Length)
|
|
{
|
|
int nextByte = stream.ReadByte();
|
|
|
|
// End of stream? If so, we're done
|
|
if (nextByte == -1)
|
|
{
|
|
return buffer;
|
|
}
|
|
|
|
// Nope. Resize the buffer, put in the byte we've just
|
|
// read, and continue
|
|
byte[] newBuffer = new byte[buffer.Length * 2];
|
|
Array.Copy(buffer, newBuffer, buffer.Length);
|
|
newBuffer[read] = (byte)nextByte;
|
|
buffer = newBuffer;
|
|
read++;
|
|
}
|
|
}
|
|
// Buffer is now too big. Shrink it.
|
|
byte[] ret = new byte[read];
|
|
Array.Copy(buffer, ret, read);
|
|
return ret;
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
/// converte una data in formato aaaammgg in stringa gg/mm/aaaa
|
|
/// </summary>
|
|
/// <param name="val"></param>
|
|
/// <returns></returns>
|
|
public string data2string(object val)
|
|
{
|
|
string dataFormattata = "";
|
|
try
|
|
{
|
|
string data = val.ToString();
|
|
dataFormattata = data.Substring(6, 2) + "/" + data.Substring(4, 2) + "/" + data.Substring(0, 4);
|
|
}
|
|
catch
|
|
{
|
|
}
|
|
return dataFormattata;
|
|
}
|
|
/// <summary>
|
|
/// converte una data in formato aaaammgg in stringa aaaa-mm-gg
|
|
/// </summary>
|
|
/// <param name="val"></param>
|
|
/// <returns></returns>
|
|
public string data2IsoString(object val)
|
|
{
|
|
string dataFormattata = "";
|
|
try
|
|
{
|
|
string data = val.ToString();
|
|
dataFormattata = data.Substring(0, 4) + "-" + data.Substring(4, 2) + "-" + data.Substring(6, 2);
|
|
}
|
|
catch
|
|
{
|
|
}
|
|
return dataFormattata;
|
|
}/// <summary>
|
|
/// converte una stringa in formato gg/mm/aaaa in stringa(intero data) in formato aaaammgg
|
|
/// </summary>
|
|
/// <param name="val"></param>
|
|
/// <returns></returns>
|
|
public string string2data(object val)
|
|
{
|
|
DateTime data = Convert.ToDateTime(val);
|
|
return (data.Year).ToString() + (data.Month).ToString().PadLeft(2, '0') + (data.Day).ToString().PadLeft(2, '0');
|
|
}
|
|
/// <summary>
|
|
/// converte una datetime in un intero tipo yyyymmddhhmmss
|
|
/// </summary>
|
|
/// <param name="_data"></param>
|
|
/// <returns></returns>
|
|
public long datetime2int(DateTime _data)
|
|
{
|
|
long valore_data = 0;
|
|
long valore_time = 0;
|
|
long valore = 0;
|
|
valore_data = (_data).Year * 10000 + (_data).Month * 100 + (_data).Day;
|
|
valore_time = (_data).Hour * 10000 + (_data).Minute * 100 + (_data).Second;
|
|
valore = valore_data * 1000000 + valore_time;
|
|
return valore;
|
|
}
|
|
/// <summary>
|
|
/// formatta la data in formato dateTime in una data formato italiano come stringa gg/mm/aaaa
|
|
/// </summary>
|
|
/// <param name="dataRichiesta"></param>
|
|
/// <returns></returns>
|
|
public string dataItaliana(DateTime dataRichiesta)
|
|
{
|
|
string dataFormattata;
|
|
dataFormattata = dataRichiesta.Day.ToString().PadLeft(2, '0') + "/" + dataRichiesta.Month.ToString().PadLeft(2, '0') + "/" + dataRichiesta.Year.ToString();
|
|
return dataFormattata;
|
|
}
|
|
|
|
|
|
|
|
/// <summary>
|
|
/// invia un alert jscript con messaggio indicato...
|
|
/// </summary>
|
|
/// <param name="_messaggio">messaggio dell'alert da mandare</param>
|
|
public void mandaAlert(string _messaggio)
|
|
{
|
|
string comando = "<script language='JavaScript'>";
|
|
comando += "alert('" + _messaggio + "')";
|
|
comando += "</script>";
|
|
Response.Write(comando);
|
|
}
|
|
/// <summary>
|
|
/// scrive immediatamente sulla pagina web il messaggio di avanzamento...
|
|
/// </summary>
|
|
/// <param name="_messaggio"></param>
|
|
public void scriviAvanzamento(string _messaggio)
|
|
{
|
|
Response.Write(_messaggio);
|
|
Response.Flush();
|
|
}
|
|
|
|
/// <summary>
|
|
/// restituisce una scringa formattata in testa e coda x essere un corretto comando javascript
|
|
/// </summary>
|
|
/// <param name="comando"></param>
|
|
/// <returns></returns>
|
|
public string jscriptFormat(string comando)
|
|
{
|
|
return "<script language='JavaScript'>" + comando + "</script>";
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region gestione email & log...
|
|
|
|
/// <summary>
|
|
/// invio email senza log
|
|
/// </summary>
|
|
/// <param name="_mailFrom"></param>
|
|
/// <param name="_mailTo"></param>
|
|
/// <param name="_oggetto"></param>
|
|
/// <param name="_corpo"></param>
|
|
/// <returns></returns>
|
|
protected bool mandaEmailNoLog(string _mailFrom, string _mailTo, string _oggetto, string _corpo)
|
|
{
|
|
bool answ = false;
|
|
try
|
|
{
|
|
answ = SteamWare.gestEmail.ge.mandaEmailNoLog(_mailFrom, _mailTo, _oggetto, _corpo);
|
|
}
|
|
catch { }
|
|
return answ;
|
|
}
|
|
/// <summary>
|
|
/// invio email con log
|
|
/// </summary>
|
|
/// <param name="_mailFrom"></param>
|
|
/// <param name="_mailTo"></param>
|
|
/// <param name="_oggetto"></param>
|
|
/// <param name="_corpo"></param>
|
|
/// <returns></returns>
|
|
protected bool mandaEmail(string _mailFrom, string _mailTo, string _oggetto, string _corpo)
|
|
{
|
|
return SteamWare.gestEmail.ge.mandaEmailNoLog(_mailFrom, _mailTo, _oggetto, _corpo);
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region gestione dati
|
|
|
|
/// <summary>
|
|
/// caricamento dati applicazione da sessione (B.1.3)
|
|
/// </summary>
|
|
protected virtual void loadSessionData()
|
|
{
|
|
}
|
|
/// <summary>
|
|
/// setup datamanagers...
|
|
/// </summary>
|
|
protected virtual void setupUserDataMan()
|
|
{
|
|
}
|
|
/// <summary>
|
|
/// reset update del modulo corrente
|
|
/// </summary>
|
|
protected virtual void resetUpdate()
|
|
{ }
|
|
/// <summary>
|
|
/// (ri)carica i dataset del modulo
|
|
/// </summary>
|
|
protected virtual void forza_Update()
|
|
{ }
|
|
/// <summary>
|
|
/// verifica se tutti i dataset richiesti sono disponibili i cache
|
|
/// </summary>
|
|
/// <returns></returns>
|
|
protected virtual bool datiDisponibili()
|
|
{
|
|
return true;
|
|
}
|
|
/// <summary>
|
|
/// salva nella cache i dataset caricati
|
|
/// </summary>
|
|
protected virtual void salvaDati()
|
|
{ }
|
|
/// <summary>
|
|
/// carica dalla cache i dataset necessari
|
|
/// </summary>
|
|
protected virtual void caricaDati()
|
|
{ }
|
|
|
|
|
|
#endregion
|
|
|
|
#region lettura dataset standard
|
|
|
|
/// <summary>
|
|
/// legge i valori standard x dataset e parametri
|
|
/// </summary>
|
|
protected void StandardDataLoad()
|
|
{
|
|
try
|
|
{
|
|
loadAuthCdC();
|
|
}
|
|
catch
|
|
{ }
|
|
}
|
|
/// <summary>
|
|
/// leggi i parametri di configurazione standard dell'applicativo
|
|
/// </summary>
|
|
protected void loadDefaultsWebConfig()
|
|
{
|
|
_righeDataGrid = memLayer.ML.CRI("_righeDataGrid");
|
|
_righeDataGridAnagr = memLayer.ML.CRI("_righeDataGridAnagr");
|
|
_righeDataGridLong = memLayer.ML.CRI("_righeDataGridLong");
|
|
_righeDataGridMed = memLayer.ML.CRI("_righeDataGridMed");
|
|
_righeDataGridShort = memLayer.ML.CRI("_righeDataGridShort");
|
|
//_righeSelettore = (int)confRead.GetValue("_righeSelettore", typeof(int));
|
|
//_ewServer = (string)confRead.GetValue("_ewServer", typeof(string));
|
|
//_ewMap = (string)confRead.GetValue("_ewMap", typeof(string));
|
|
_adminEmail = memLayer.ML.confReadString("_adminEmail");
|
|
_fromEmail = memLayer.ML.confReadString("_fromEmail");
|
|
_smtpCli = memLayer.ML.confReadString("_smtpCli");
|
|
_logLevel = memLayer.ML.confReadInt("_logLevel");
|
|
_safePages = memLayer.ML.confReadString("_safePages");
|
|
_commonPages = memLayer.ML.confReadString("_commonPages");
|
|
}
|
|
/// <summary>
|
|
/// genera la stringa dei cdc autorizzati dell'utente
|
|
/// </summary>
|
|
protected void loadAuthCdC()
|
|
{
|
|
if (!memLayer.ML.isInSessionObject("_AuthCdC"))
|
|
{
|
|
_CdCUser = elencoCdC;
|
|
memLayer.ML.setSessionVal("_CdCUser", _CdCUser);
|
|
_AuthCdC = string.Format(" COD_CDC IN ({0})", _CdCUser);
|
|
memLayer.ML.setSessionVal("_AuthCdC", _AuthCdC);
|
|
}
|
|
else
|
|
{
|
|
_AuthCdC = memLayer.ML.StringSessionObj("_AuthCdC");
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// legge il dataset dei CdC
|
|
/// </summary>
|
|
protected void loadAllCdC()
|
|
{
|
|
if (!memLayer.ML.isInCacheObject("_allCdC"))
|
|
{
|
|
_allCdC = DataWrap.DW.taCdc.GetData();
|
|
//Cache["_allCdC"] = _allCdC;
|
|
memLayer.ML.setCacheVal("_allCdC", _allCdC, true);
|
|
}
|
|
else
|
|
{
|
|
_allCdC = (DataLayer_AnagGen.CDCDataTable)Cache["_allCdC"];
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region autenticazione / autorizzazione =c=
|
|
|
|
/// <summary>
|
|
/// caricamento dati user da sessione (B.1.1)
|
|
/// </summary>
|
|
protected void LoadUserData()
|
|
{
|
|
_paginaPrecedente = memLayer.ML.StringSessionObj("_paginaPrecedente");
|
|
setupUserDataMan();
|
|
loadDefaultsWebConfig();
|
|
if (user_std.UtSn.utente != "")
|
|
{
|
|
StandardDataLoad();
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// verifica che l'utente abbia almeno un permesso per la pagina corrente altrimenti redirect ad unauthorized
|
|
/// </summary>
|
|
protected virtual void SetUpByUserRight()
|
|
{
|
|
PagCorrente();
|
|
// verifica la pagina NON sia di quelle "libere"
|
|
if (_safePages.IndexOf(_paginaCorrente) == -1)
|
|
{
|
|
// verifica l'utente sia autorizzato (in session...)
|
|
if (!user_std.UtSn.isAuth)
|
|
{
|
|
if (_paginaCorrente != "" && _paginaCorrente != "login.aspx")
|
|
{
|
|
Session["nextPage"] = _paginaCorrente;
|
|
}
|
|
|
|
Response.Redirect("login.aspx");
|
|
}
|
|
// verifica i permessi dell'utente per almeno vedere la pagina corrente SSE non è una common page...
|
|
if (!user_std.UtSn.isPageEnabled(_paginaCorrente) && _commonPages.IndexOf(_paginaCorrente) == -1)
|
|
{
|
|
logger.lg.scriviLog(string.Format("Errore in SetUpByUserRight: utente {0} non autorizzato per la pagina {1}", user_std.UtSn.utente, _paginaCorrente), tipoLog.STARTUP);
|
|
Response.Redirect("~/unauthorized.aspx");
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// salva in variabile pagina il nome della pagina corrente
|
|
/// </summary>
|
|
protected virtual void PagCorrente()
|
|
{
|
|
Uri MyUrl = Request.Url;
|
|
string delimStr = "/";
|
|
char[] delimiter = delimStr.ToCharArray();
|
|
string[] finalUrl = MyUrl.LocalPath.ToString().Split(delimiter);
|
|
int n = finalUrl.Length;
|
|
_paginaCorrente = finalUrl[n - 1].ToString();
|
|
// tolgo .aspx!
|
|
_paginaCorrente = _paginaCorrente.Replace(".aspx", "");
|
|
if (_paginaPrecedente == "" || _paginaPrecedente == null)
|
|
{
|
|
_paginaPrecedente = _paginaCorrente;
|
|
memLayer.ML.setSessionVal("_paginaPrecedente", _paginaPrecedente);
|
|
}
|
|
if (_paginaCorrente != _paginaPrecedente)
|
|
{
|
|
// in questo caso tolgo i vari filtering e gli indici...
|
|
memLayer.ML.emptySessionVal("_indexFilt");
|
|
memLayer.ML.emptySessionVal("valoreCercato");
|
|
_paginaPrecedente = _paginaCorrente;
|
|
memLayer.ML.setSessionVal("_paginaPrecedente", _paginaPrecedente);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// selezione delle posizioni cdc autorizzate come stringa di filtraggio su POSIZIONE LIKE, se non ce ne fossero redirige su unauthorized.aspx
|
|
/// </summary>
|
|
/// <returns></returns>
|
|
protected string filtroPosizioneCdC()
|
|
{
|
|
string Filtraggio;
|
|
Filtraggio = " (";
|
|
DataLayer_AnagGen.CDCDataTable tblCdc = DataWrap.DW.taCdc.GetTopCdC(user_std.UtSn.utente, user_std.UtSn.dominio, user_std.UtSn.modulo);
|
|
if (tblCdc.Rows.Count == 0 && _safePages.IndexOf(_paginaCorrente) == -1)
|
|
{
|
|
logger.lg.scriviLog(string.Format("Errore in filtroPosizioneCdC: utente {0} non autorizzato per la pagina {1}", user_std.UtSn.utente, _paginaCorrente), tipoLog.STARTUP);
|
|
Response.Redirect("~/unauthorized.aspx");
|
|
}
|
|
foreach (DataLayer_AnagGen.CDCRow riga in tblCdc)
|
|
{
|
|
// aggiongo solo se non è contenuta la posizione...
|
|
if (Filtraggio.IndexOf(riga.POSIZIONE) == -1)
|
|
{
|
|
// controllo se posizione termina col punto...
|
|
if (riga.POSIZIONE.EndsWith("."))
|
|
{
|
|
Filtraggio += String.Format("(POSIZIONE LIKE '{0}%') OR ", riga.POSIZIONE);
|
|
}
|
|
else
|
|
{
|
|
Filtraggio += String.Format("(POSIZIONE LIKE '{0}.%') OR ", riga.POSIZIONE);
|
|
}
|
|
}
|
|
}
|
|
int lungFiltr = Filtraggio.Length;
|
|
Filtraggio = Filtraggio.Remove(lungFiltr - 3, 3);
|
|
Filtraggio += ") ";
|
|
return Filtraggio;
|
|
}
|
|
|
|
/// <summary>
|
|
/// risponde alla domanda se l'utente abbia permesso tipo writable (S) nel permessi2funzione
|
|
/// </summary>
|
|
/// <returns></returns>
|
|
public bool isWritable()
|
|
{
|
|
bool answ = false;
|
|
if (_paginaCorrente == null)
|
|
{
|
|
PagCorrente();
|
|
}
|
|
answ = user_std.UtSn.isPageWriteEnabled(_paginaCorrente);
|
|
return answ;
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region funzioni x sorting & filtering =c=
|
|
|
|
/// <summary>
|
|
/// verifica la condizione booleana e formatta di conseguenza la stringa di filtraggio da accodare al filtro x CdC autorizzati
|
|
/// </summary>
|
|
/// <param name="_condizione">condizione</param>
|
|
/// <param name="_tipoEqual">tipo di eguaglianza</param>
|
|
/// <param name="_nomeParam">nome parametro</param>
|
|
/// <param name="_valParam">valore parametro</param>
|
|
/// <returns></returns>
|
|
protected string condFilter(bool _condizione, string _tipoEqual, string _nomeParam, string _valParam)
|
|
{
|
|
string outFilter = "";
|
|
if (_condizione && _valParam != "")
|
|
{
|
|
if (_tipoEqual == "=")
|
|
{
|
|
outFilter = " AND (" + _nomeParam.Replace("'", "''") + " = '" + _valParam.Replace("'", "''") + "')";
|
|
}
|
|
else if (_tipoEqual == "IN")
|
|
{
|
|
outFilter = String.Format(" AND ({0} IN ({1}))", _nomeParam.Replace("'", "''"), _valParam.Replace("'", "''"));
|
|
}
|
|
|
|
else
|
|
{
|
|
outFilter = " AND (" + _nomeParam.Replace("'", "''") + " LIKE '%" + _valParam.Replace("'", "''") + "%')";
|
|
}
|
|
}
|
|
return outFilter;
|
|
}
|
|
/// <summary>
|
|
/// crea la stringa di filtraggio x data secondo modalità tipo inizio/fine/durante...
|
|
/// </summary>
|
|
/// <returns></returns>
|
|
protected string dataFilter(bool _condizione, string _tipoPeriodo, string _nomeFrom, string _dataFrom, string _nomeTo, string _dataTo)
|
|
{
|
|
string outFilter = "";
|
|
if (_condizione)
|
|
{
|
|
// carica i valori dalle textbox... se non ci sono li imposta a:
|
|
// start = 01/01/1900
|
|
// end = 01/01/2200
|
|
try
|
|
{
|
|
_dataFrom = _dataFrom.Replace(".", "/");
|
|
if (_dataFrom == "")
|
|
{
|
|
_dataFrom = "01/01/1900";
|
|
}
|
|
}
|
|
catch
|
|
{
|
|
_dataFrom = "01/01/1900";
|
|
}
|
|
try
|
|
{
|
|
_dataTo = _dataTo.Replace(".", "/");
|
|
if (_dataTo == "")
|
|
{
|
|
_dataTo = "01/01/2200";
|
|
}
|
|
}
|
|
catch
|
|
{
|
|
_dataTo = "01/01/2200";
|
|
}
|
|
switch (_tipoPeriodo)
|
|
{
|
|
case "1":
|
|
// filtro su inizio
|
|
outFilter += " AND (" + _nomeFrom + " >= '" + _dataFrom + "' AND " + _nomeFrom + " <= '" + _dataTo + "') ";
|
|
break;
|
|
case "2":
|
|
// filtro su scadenza
|
|
outFilter += " AND (" + _nomeTo + " >= '" + _dataFrom + "' AND " + _nomeTo + " <= '" + _dataTo + "') ";
|
|
break;
|
|
case "3":
|
|
// filtro su "in corso"
|
|
outFilter += " AND NOT (" + _nomeFrom + " > '" + _dataTo + "' OR " + _nomeTo + " < '" + _dataFrom + "') ";
|
|
break;
|
|
}
|
|
}
|
|
return outFilter;
|
|
}
|
|
|
|
/// <summary>
|
|
/// crea la stringa di filtraggio x data secondo modalità tipo minoreUguale / uguale / maggioreUguale...
|
|
/// </summary>
|
|
/// <returns></returns>
|
|
protected string dataFilter(bool _condizione, string _tipoPeriodo, string _nome, string _data)
|
|
{
|
|
string outFilter = "";
|
|
if (_condizione)
|
|
{
|
|
// carica i valori dalle textbox... se non ci sono li imposta a:
|
|
// start = 01/01/1900
|
|
// end = 01/01/2200
|
|
try
|
|
{
|
|
_data = _data.Replace(".", "/");
|
|
if (_data == "")
|
|
{
|
|
_data = "01/01/1900";
|
|
}
|
|
}
|
|
catch
|
|
{
|
|
_data = "01/01/1900";
|
|
}
|
|
switch (_tipoPeriodo)
|
|
{
|
|
case "<=":
|
|
// filtro su inizio
|
|
outFilter += " AND (" + _nome + " <= '" + _data + "') ";
|
|
break;
|
|
case "=":
|
|
// filtro su scadenza
|
|
outFilter += " AND (" + _nome + " = '" + _data + "') ";
|
|
break;
|
|
case ">=":
|
|
// filtro su "in corso"
|
|
outFilter += " AND (" + _nome + " >= '" + _data + "') ";
|
|
break;
|
|
}
|
|
}
|
|
return outFilter;
|
|
}
|
|
/// <summary>
|
|
/// verifica la condizione booleana e formatta di conseguenza la stringa di filtraggio tipo LIKE x i campi inseriti separati da # SE valParam !=""
|
|
/// </summary>
|
|
/// <param name="_elencoCampi"></param>
|
|
/// <param name="_valParam"></param>
|
|
/// <returns></returns>
|
|
protected string likeFilter(string _elencoCampi, string _valParam)
|
|
{
|
|
string outFilter = "";
|
|
if (_valParam != "")
|
|
{
|
|
outFilter = " AND ( ";
|
|
string comandoCompleto = _elencoCampi;
|
|
string[] comando = comandoCompleto.Split('#');
|
|
int numCampi = comando.GetLength(0);
|
|
for (int i = 1; i <= numCampi; i++)
|
|
{
|
|
outFilter += "(" + comando[i - 1] + " LIKE '%" + _valParam + "%')";
|
|
outFilter += " OR ";
|
|
}
|
|
outFilter = outFilter.Remove(outFilter.Length - 3, 3);
|
|
outFilter += " ) ";
|
|
}
|
|
return outFilter;
|
|
}
|
|
|
|
/// <summary>
|
|
/// variabile salvata in view state x la stringa di sorting - dg 2
|
|
/// </summary>
|
|
protected string SortField2
|
|
{
|
|
//registra nella viewState la stringa di sorting
|
|
//(nome campo + scritta desc o nulla che equivale ad ascending...)
|
|
//si può impropriamente usare x + controlli... al max serve 1 click in +...
|
|
get
|
|
{
|
|
object o = ViewState["SortField2"];
|
|
if (o == null)
|
|
{
|
|
return String.Empty;
|
|
}
|
|
return (string)o;
|
|
}
|
|
|
|
set
|
|
{
|
|
if (value == SortField2)
|
|
{
|
|
// same as current sort file, toggle sort direction
|
|
SortAscending = !SortAscending;
|
|
}
|
|
ViewState["SortField2"] = value;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// variabile salvata in view state x la stringa di sorting - dg 2
|
|
/// </summary>
|
|
protected string SortField
|
|
{
|
|
//registra nella viewState la stringa di sorting
|
|
//(nome campo + scritta desc o nulla che equivale ad ascending...)
|
|
//si può impropriamente usare x + controlli... al max serve 1 click in +...
|
|
get
|
|
{
|
|
object o = ViewState["SortField"];
|
|
if (o == null)
|
|
{
|
|
return String.Empty;
|
|
}
|
|
return (string)o;
|
|
}
|
|
|
|
set
|
|
{
|
|
if (value == SortField)
|
|
{
|
|
// same as current sort file, toggle sort direction
|
|
SortAscending = !SortAscending;
|
|
}
|
|
ViewState["SortField"] = value;
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// legge e scrive in viewState la stringa di filtraggio...
|
|
/// </summary>
|
|
protected string FiltString
|
|
{
|
|
get
|
|
{
|
|
object o = ViewState["FiltString"];
|
|
if (o == null)
|
|
{
|
|
return String.Empty;
|
|
}
|
|
return (string)o;
|
|
}
|
|
|
|
set
|
|
{
|
|
ViewState["FiltString"] = value;
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// variabile salvata in viewstate x la direzione del sorting
|
|
/// </summary>
|
|
protected bool SortAscending
|
|
{
|
|
//memorizza l'ultima direzione di sort x poterla invertire
|
|
get
|
|
{
|
|
object o = ViewState["SortAscending"];
|
|
if (o == null)
|
|
{
|
|
return true;
|
|
}
|
|
return (bool)o;
|
|
}
|
|
|
|
set
|
|
{
|
|
ViewState["SortAscending"] = value;
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// genera la stringa filtro x i cdc autorizzati x l'user
|
|
/// </summary>
|
|
/// <returns></returns>
|
|
protected string elencoCdC
|
|
{
|
|
get
|
|
{
|
|
// messo qui caricamento dei cdc...
|
|
loadAllCdC();
|
|
//filtro sui CdC -- ATTENZIONE!!! possibile stack overflow se si supera un filtro con oltre 5000 char di posizioni... loop! vedi 647 mantis
|
|
string filtroCompleto = filtroPosizioneCdC();
|
|
string filtroCorrente = "";
|
|
string Filtraggio;
|
|
//dall'elenco dei CdC compone filtro x tabella corrente...
|
|
Filtraggio = "";
|
|
// setta a 0 il cdc precedente... poi inserisce il cdc SE E SOLO SE è diverso dal precedente: è distinct!!!
|
|
string _cdcPrec = "000";
|
|
string _cdcCurr = "";
|
|
int currPos = 0;
|
|
int filtLenght = filtroCompleto.Length;
|
|
int currLenght = 0;
|
|
// workaround: separo la ricerca in + tranches, andando a prendere solo (circa) 2000 char alla volta...
|
|
if (filtroCompleto.Length < 2000)
|
|
{
|
|
// uso il filtro completo...
|
|
Filtraggio = recuperaCdC_daFiltro(filtroCompleto, ref Filtraggio, ref _cdcPrec, ref _cdcCurr);
|
|
}
|
|
else
|
|
{
|
|
while (currPos < filtLenght)
|
|
{
|
|
// se non trova significa che siamo all'ultimo "tratto" da meno di 1900 char...
|
|
if (filtLenght - currPos < 2100)
|
|
{
|
|
currLenght = filtLenght - currPos;
|
|
}
|
|
else
|
|
{
|
|
// cerco l'i-esima occorrenza di "(POSIZIONE LIKE" dopo circa 2000 dalla currPos...
|
|
currLenght = filtroCompleto.IndexOf("(POSIZIONE", currPos + 1900) - currPos;
|
|
}
|
|
filtroCorrente = filtroCompleto.Substring(currPos, currLenght);
|
|
// se termina con "OR " tolgo...
|
|
if (filtroCorrente.EndsWith("OR "))
|
|
{
|
|
filtroCorrente = filtroCorrente.Remove(currLenght - 3, 3);
|
|
}
|
|
Filtraggio = recuperaCdC_daFiltro(filtroCorrente, ref Filtraggio, ref _cdcPrec, ref _cdcCurr);
|
|
// sposto la posizione corrente...
|
|
currPos = currPos + currLenght;
|
|
}
|
|
}
|
|
return Filtraggio;
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// esegue la ricerca dei cdc nelle posizioni indicate dal filtro e restituisce elenco distinct degli stessi
|
|
/// </summary>
|
|
/// <param name="filtroCorrente">filtro con cui cercare i cdc (del tipo " (POSIZIONE LIKE 'T.1.2.3%') OR ... " </param>
|
|
/// <param name="Filtraggio">stringa di filtraggio ricostruita per l'elenco dei cdc fino a quel momento trovati</param>
|
|
/// <param name="_cdcPrec">ultimo cdc trovato</param>
|
|
/// <param name="_cdcCurr">cdc corrente</param>
|
|
/// <returns></returns>
|
|
private string recuperaCdC_daFiltro(string filtroCorrente, ref string Filtraggio, ref string _cdcPrec, ref string _cdcCurr)
|
|
{
|
|
// esegue ciclo ricerca
|
|
DataView dv = new DataView(_allCdC, filtroCorrente, "COD_CDC", DataViewRowState.CurrentRows);
|
|
foreach (DataRowView rowView in dv)
|
|
{
|
|
_cdcCurr = rowView.Row[0].ToString();
|
|
if (_cdcCurr != _cdcPrec && (Filtraggio.IndexOf(_cdcCurr) < 0)) // aggiunta verifica non ci siano duplicati visto che si fa in + tranches la ricerca cdc...
|
|
{
|
|
Filtraggio += "'" + _cdcCurr + "' , ";
|
|
}
|
|
_cdcPrec = _cdcCurr;
|
|
}
|
|
int lungFiltr = Filtraggio.Length;
|
|
if (Filtraggio.EndsWith("' , "))
|
|
{
|
|
Filtraggio = Filtraggio.Remove(lungFiltr - 3, 3);
|
|
}
|
|
return Filtraggio;
|
|
}
|
|
|
|
|
|
#endregion
|
|
|
|
#region funzioni di conversione da Id dati anagrafici
|
|
|
|
/// <summary>
|
|
/// restituisce il cdc dell'utente data la sua matricola
|
|
/// </summary>
|
|
/// <param name="val"></param>
|
|
/// <returns></returns>
|
|
public string cdcUtente(object val)
|
|
{
|
|
DataLayer_AnagGen.UTENTERow riga = (DataLayer_AnagGen.UTENTERow)DataWrap.DW.taUtente.getByMatricola(val.ToString())[0];
|
|
return riga.COD_CDC;
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
/// restituisce l'utente AS dall'utente win
|
|
/// </summary>
|
|
/// <param name="utenteWin"></param>
|
|
/// <returns></returns>
|
|
public string siglaDaUserWin(string utenteWin)
|
|
{
|
|
string sigla = "__";
|
|
try
|
|
{
|
|
DataLayer_AnagGen.UTENTERow riga = (DataLayer_AnagGen.UTENTERow)DataWrap.DW.taUtente.getByUserName(utenteWin)[0];
|
|
sigla = riga.SIGLA;
|
|
}
|
|
catch
|
|
{ }
|
|
return sigla;
|
|
}
|
|
|
|
/// <summary>
|
|
/// restituisce la descr del CdC
|
|
/// </summary>
|
|
/// <param name="val"></param>
|
|
/// <returns></returns>
|
|
public string descrCdcDaId(object val)
|
|
{
|
|
// cambio sena obj completo in cache
|
|
string label = "-";
|
|
try
|
|
{
|
|
label = (DataWrap.DW.taCdc.getByCdc(val.ToString())[0]).DESCRIZIONE;
|
|
}
|
|
catch
|
|
{ }
|
|
return label;
|
|
}
|
|
|
|
|
|
|
|
#endregion
|
|
|
|
#region funzioni di concatenamento stringhe x comandi hyperlink & help
|
|
|
|
/// <summary>
|
|
/// invia la stringa jscript di conferma pre-cancellazione
|
|
/// </summary>
|
|
/// <returns></returns>
|
|
public string confermaCancellazione()
|
|
{
|
|
return string.Format("return confirm(\"{0}\");", user_std.UtSn.Traduci("confermaDel"));
|
|
}
|
|
/// <summary>
|
|
/// restituisce la stringa del path corretto per l'immagine richiesta nel formato "~/images/{0}{1}"
|
|
/// </summary>
|
|
/// <param name="_tipo">verrà usato x posizione {0}, tipo "view"</param>
|
|
/// <param name="_dimensione">verrà usato x posizione {1}, tipo "_s.png"</param>
|
|
/// <returns></returns>
|
|
public string imgPath(tipoImg _tipo, dimImg _dimensione)
|
|
{
|
|
return imgPath(_tipo, _dimensione, tipoFileImg.png);
|
|
}
|
|
|
|
/// <summary>
|
|
/// restituisce la stringa del path corretto per l'immagine richiesta nel formato "~/images/{0}{1}"
|
|
/// </summary>
|
|
/// <param name="_tipo">verrà usato x posizione {0}, tipo "view"</param>
|
|
/// <param name="_dimensione">verrà usato x posizione {1}, tipo "_s.png"</param>
|
|
/// <param name="_tipoFile">tipo del file richiesto..."</param>
|
|
/// <returns></returns>
|
|
public string imgPath(tipoImg _tipo, dimImg _dimensione, tipoFileImg _tipoFile)
|
|
{
|
|
string _imgName = "unknown";
|
|
string _imgDim = "_s";
|
|
string _imgType = "png";
|
|
switch (_tipo)
|
|
{
|
|
case tipoImg.annulla:
|
|
_imgName = "cancel";
|
|
break;
|
|
case tipoImg.approva:
|
|
_imgName = "approva";
|
|
break;
|
|
case tipoImg.barcode:
|
|
_imgName = "barcode_white";
|
|
break;
|
|
case tipoImg.barcodeArancio:
|
|
_imgName = "barcode_orange";
|
|
break;
|
|
case tipoImg.clona:
|
|
_imgName = "clonaObj";
|
|
break;
|
|
case tipoImg.conferma:
|
|
_imgName = "apply";
|
|
break;
|
|
case tipoImg.elimina:
|
|
_imgName = "elimina";
|
|
break;
|
|
case tipoImg.modifica:
|
|
_imgName = "edit";
|
|
break;
|
|
case tipoImg.notepad:
|
|
_imgName = "notepad";
|
|
break;
|
|
case tipoImg.notepadPdf:
|
|
_imgName = "notepadPdf";
|
|
break;
|
|
case tipoImg.nuovo:
|
|
_imgName = "new";
|
|
break;
|
|
case tipoImg.seleziona:
|
|
_imgName = "view";
|
|
break;
|
|
case tipoImg.semaforoGiallo:
|
|
_imgName = "semaGiallo";
|
|
break;
|
|
case tipoImg.semaforoRosso:
|
|
_imgName = "semaRosso";
|
|
break;
|
|
case tipoImg.semaforoVerde:
|
|
_imgName = "semaVerde";
|
|
break;
|
|
case tipoImg.stampa:
|
|
_imgName = "print";
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
switch (_dimensione)
|
|
{
|
|
case dimImg.small:
|
|
_imgDim = "_s";
|
|
break;
|
|
case dimImg.medium:
|
|
_imgDim = "_m";
|
|
break;
|
|
case dimImg.large:
|
|
_imgDim = "_l";
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
switch (_tipoFile)
|
|
{
|
|
case tipoFileImg.gif:
|
|
_imgType = "gif";
|
|
break;
|
|
case tipoFileImg.jpg:
|
|
_imgType = "jpg";
|
|
break;
|
|
case tipoFileImg.png:
|
|
_imgType = "png";
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
return string.Format("~/images/{0}{1}.{2}", _imgName, _imgDim, _imgType);
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region funzioni dummy x traduzione
|
|
|
|
/// <summary>
|
|
/// effettua traduzione del lemma
|
|
/// </summary>
|
|
/// <param name="lemma"></param>
|
|
/// <returns></returns>
|
|
public string traduci(string lemma)
|
|
{
|
|
return user_std.UtSn.Traduci(lemma);
|
|
}
|
|
/// <summary>
|
|
/// effettua traduzione in inglese del lemma
|
|
/// </summary>
|
|
/// <param name="lemma"></param>
|
|
/// <returns></returns>
|
|
public string traduciEn(string lemma)
|
|
{
|
|
return user_std.UtSn.TraduciEn(lemma);
|
|
}
|
|
|
|
#endregion
|
|
|
|
# region gestione visibilità da tipo modulo
|
|
|
|
/// <summary>
|
|
/// definisce visibilità
|
|
/// </summary>
|
|
/// <param name="cosa"></param>
|
|
/// <returns></returns>
|
|
public bool isVisible(object cosa)
|
|
{
|
|
bool visibile;
|
|
switch (cosa.ToString())
|
|
{
|
|
case "Select":
|
|
visibile = (_vistaModulo == tipoVistaMod.selezione);
|
|
break;
|
|
case "Edit":
|
|
visibile = (_vistaModulo == tipoVistaMod.editing);
|
|
break;
|
|
case "Delete":
|
|
visibile = (_vistaModulo == tipoVistaMod.editing);
|
|
break;
|
|
default:
|
|
visibile = false;
|
|
break;
|
|
}
|
|
return visibile;
|
|
}
|
|
/// <summary>
|
|
/// tipo di vista del modulo
|
|
/// </summary>
|
|
public tipoVistaMod vistaModulo
|
|
{
|
|
get
|
|
{
|
|
return _vistaModulo;
|
|
}
|
|
set
|
|
{
|
|
_vistaModulo = value;
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
#region gestione eventi e logging
|
|
|
|
/// <summary>
|
|
/// effettua la registrazione degli eventi
|
|
/// </summary>
|
|
public void registraEventi()
|
|
{
|
|
// controllo: loggin SOLO se la scheda ha logging abilitato nella riga del db...
|
|
bool logEn = memLayer.ML.BoolSessionObj("logEn");
|
|
memLayer.ML.emptySessionVal("logEn");
|
|
if (logEn)
|
|
{
|
|
// leggo e svuoto info x logging
|
|
string ev2log = memLayer.ML.StringSessionObj("ev2log");
|
|
memLayer.ML.emptySessionVal("ev2log");
|
|
string valOrig = memLayer.ML.StringSessionObj("valOrig");
|
|
memLayer.ML.emptySessionVal("valOrig");
|
|
string valNew = memLayer.ML.StringSessionObj("valNew");
|
|
memLayer.ML.emptySessionVal("valNew");
|
|
string filtEv = memLayer.ML.StringSessionObj("filtEv");
|
|
memLayer.ML.emptySessionVal("filtEv");
|
|
// solo se almeno uno dei due valori orig e new sono diversi da zero...)
|
|
if (valNew != "" || valOrig != "")
|
|
{
|
|
insEvento(ev2log, valOrig, valNew, filtEv);
|
|
}
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// effettua l'inserimento vero e proprio dell'evento letto dai valori in session x l'utente corrente...
|
|
/// </summary>
|
|
/// <param name="ev2log">evento da loggare</param>
|
|
/// <param name="valOrig">valori originali</param>
|
|
/// <param name="valNew">nuovi valori</param>
|
|
/// <param name="filtEv">filtro associato</param>
|
|
public virtual void insEvento(string ev2log, string valOrig, string valNew, string filtEv)
|
|
{
|
|
// effettuo logging evento
|
|
log2note.l2n.insEvento(user_std.UtSn.utente, _paginaCorrente, valOrig, valNew, ev2log, filtEv);
|
|
}
|
|
/// <summary>
|
|
/// salva in sessione i valori indicati
|
|
/// </summary>
|
|
/// <param name="oldVal">dictionary dei valori vecchi</param>
|
|
/// <param name="newVal">dictionary dei valori nuovi</param>
|
|
/// <param name="logEnabled">bool su abilitazione al log dell'oggetto</param>
|
|
/// <param name="ev2log">descrizione evento da loggare</param>
|
|
/// <param name="filtroEv">filtro associato all'evento</param>
|
|
/// <returns>restituisce il numero di elementi contenuti, -1 significa nessuna differenza...</returns>
|
|
public static int setLogValueToSession(Dictionary<string, string> oldVal, Dictionary<string, string> newVal, bool logEnabled, string ev2log, string filtroEv)
|
|
{
|
|
int answ = -1;
|
|
// salvo i valori x logging
|
|
confrontoValori.obj.paramOld = oldVal;
|
|
confrontoValori.obj.paramNew = newVal;
|
|
// faccio generare il diff...
|
|
confrontoValori.obj.doDiff();
|
|
// logging modifica
|
|
memLayer.ML.setSessionVal("ev2log", ev2log);
|
|
memLayer.ML.setSessionVal("logEn", logEnabled);
|
|
memLayer.ML.setSessionVal("filtEv", filtroEv);
|
|
memLayer.ML.setSessionVal("valOrig", confrontoValori.obj.valOld);
|
|
memLayer.ML.setSessionVal("valNew", confrontoValori.obj.valNew);
|
|
// se ci sono differenze allora restituisco posizione della prima differenza, cercando <BR> nella stringa...
|
|
try
|
|
{
|
|
if (confrontoValori.obj.valNew != "")
|
|
{
|
|
string[] righe = confrontoValori.obj.valNew.Split('<');
|
|
answ = righe.Length;
|
|
}
|
|
}
|
|
catch
|
|
{ }
|
|
return answ;
|
|
}
|
|
|
|
/// <summary>
|
|
/// salva in sessione i valori per un oggetto che sta x essere eliminato
|
|
/// </summary>
|
|
/// <param name="oldVal">dictionary dei valori vecchi</param>
|
|
/// <param name="logEnabled">bool su abilitazione al log dell'oggetto</param>
|
|
/// <param name="ev2log">descrizione evento da loggare</param>
|
|
/// <param name="filtroEv">filtro associato all'evento</param>
|
|
/// <returns>restituisce il numero di elementi contenuti, -1 significa nessuna differenza...</returns>
|
|
public static int setLogValueToSession4del(Dictionary<string, string> oldVal, bool logEnabled, string ev2log, string filtroEv)
|
|
{
|
|
int answ = -1;
|
|
// salvo i valori x logging
|
|
confrontoValori.obj.paramOld = oldVal;
|
|
// faccio generare il diff...
|
|
confrontoValori.obj.calcOldVal();
|
|
// logging modifica
|
|
memLayer.ML.setSessionVal("ev2log", ev2log);
|
|
memLayer.ML.setSessionVal("logEn", logEnabled);
|
|
memLayer.ML.setSessionVal("filtEv", filtroEv);
|
|
memLayer.ML.setSessionVal("valOrig", confrontoValori.obj.valOld);
|
|
memLayer.ML.setSessionVal("valNew", "-");
|
|
// se ci sono differenze allora restituisco posizione della prima differenza, cercando <BR> nella stringa...
|
|
try
|
|
{
|
|
string[] righe = confrontoValori.obj.valNew.Split('<');
|
|
answ = righe.Length;
|
|
}
|
|
catch
|
|
{ }
|
|
return answ;
|
|
}
|
|
|
|
/// <summary>
|
|
/// wrapper per log con salvataggio dell'IP del chiamante
|
|
/// </summary>
|
|
/// <param name="_testoPre"></param>
|
|
/// <returns></returns>
|
|
public bool httpLog(string _testoPre)
|
|
{
|
|
bool answ = false;
|
|
string postazione_IP = "";
|
|
try
|
|
{
|
|
postazione_IP = string.Format(" | {0} | ", Request.UserHostName);
|
|
}
|
|
catch
|
|
{ }
|
|
logger.lg.scriviLog(postazione_IP + _testoPre);
|
|
return answ;
|
|
}
|
|
/// <summary>
|
|
/// wrapper per log con salvataggio dell'IP del chiamante
|
|
/// </summary>
|
|
/// <param name="testoLog">The testo log.</param>
|
|
/// <param name="tipo">The tipo.</param>
|
|
/// <returns></returns>
|
|
public bool httpLog(string testoLog, tipoLog tipo)
|
|
{
|
|
bool answ = false;
|
|
string postazione_IP = "";
|
|
try
|
|
{
|
|
postazione_IP = string.Format(" | {0} | ", Request.UserHostName);
|
|
}
|
|
catch
|
|
{ }
|
|
logger.lg.scriviLog(postazione_IP + testoLog, tipo);
|
|
return answ;
|
|
}
|
|
|
|
/// <summary>
|
|
/// event handler generico
|
|
/// </summary>
|
|
public event EventHandler eh_ucev;
|
|
/// <summary>
|
|
/// sollevo evento selezione
|
|
/// </summary>
|
|
protected void raiseEvent(ucEvType evType)
|
|
{
|
|
// sollevo evento nuovo valore...
|
|
if (eh_ucev != null)
|
|
{
|
|
ucEvent evento = new ucEvent(evType);
|
|
eh_ucev(this, evento);
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
|
|
}
|
|
}
|