Samuele Locatelli
1966 lines
65 KiB
C#
1966 lines
65 KiB
C#
using System;
|
|
using System.Configuration;
|
|
using System.Globalization;
|
|
using System.IO;
|
|
using System.Web;
|
|
using NLog;
|
|
using System.Net.Mail;
|
|
using System.Collections.Generic;
|
|
using StackExchange.Redis;
|
|
using System.Data;
|
|
using Newtonsoft.Json;
|
|
|
|
namespace ETS_Data
|
|
{
|
|
/// <summary>
|
|
/// definisce un intervalo di 2 date
|
|
/// </summary>
|
|
public struct intervalloDate
|
|
{
|
|
#region Public Fields
|
|
|
|
/// <summary>
|
|
/// data fine
|
|
/// </summary>
|
|
public DateTime fine;
|
|
|
|
/// <summary>
|
|
/// data inizio
|
|
/// </summary>
|
|
public DateTime inizio;
|
|
|
|
#endregion Public Fields
|
|
|
|
#region Public Properties
|
|
|
|
/// <summary>
|
|
/// indica se sia valido il dato, ovvero inizio e fine > 0 e FINE >= INIZIO
|
|
/// </summary>
|
|
public bool isValid
|
|
{
|
|
get
|
|
{
|
|
bool cond1 = false;
|
|
bool cond2 = false;
|
|
bool cond3 = false;
|
|
try
|
|
{
|
|
cond1 = inizio > Convert.ToDateTime("01/01/0001");
|
|
}
|
|
catch
|
|
{ }
|
|
try
|
|
{
|
|
cond2 = fine > Convert.ToDateTime("01/01/0001");
|
|
}
|
|
catch
|
|
{ }
|
|
try
|
|
{
|
|
cond3 = (fine.Subtract(inizio).TotalHours > 0);
|
|
}
|
|
catch
|
|
{ }
|
|
return (cond1 && cond2 && cond3);
|
|
}
|
|
}
|
|
|
|
#endregion Public Properties
|
|
}
|
|
|
|
/// <summary>
|
|
/// Helper methods e funzioni x gestione conversione dataset tipizzati e non
|
|
/// </summary>
|
|
/// <typeparam name="T">A strongly type DataTable.
|
|
/// A DataTable of type T will be returned from the DataSet.
|
|
/// </typeparam>
|
|
public static class DataSetAdapter<T>
|
|
where T : DataTable, new()
|
|
{
|
|
#region Public Methods
|
|
|
|
/// <summary>
|
|
/// Convert the first DataTable from a DataSet to a
|
|
/// strongly-typed data table.
|
|
/// </summary>
|
|
public static T convert(DataSet dataSet)
|
|
{
|
|
if (dataSet == null)
|
|
return null;
|
|
if (dataSet.Tables.Count == 0)
|
|
return null;
|
|
DataTable dataTable = dataSet.Tables[0];
|
|
return convert(dataTable);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Convert an ordinary DataTable to a strongly-typed
|
|
/// data table.
|
|
/// </summary>
|
|
public static T convert(DataTable dataTable)
|
|
{
|
|
if (dataTable == null)
|
|
return null;
|
|
T stronglyTyped = new T();
|
|
// add data from the regular DataTable to the
|
|
// strongly typed DataTable.
|
|
stronglyTyped.Merge(dataTable, true, MissingSchemaAction.Ignore);
|
|
return stronglyTyped;
|
|
}
|
|
|
|
#endregion Public Methods
|
|
}
|
|
|
|
/// <summary>
|
|
/// Struttura allocazione risorse / commessa
|
|
/// </summary>
|
|
public class allocRis
|
|
{
|
|
#region Public Constructors
|
|
|
|
/// <summary>
|
|
/// Inizializzazione oggetto
|
|
/// </summary>
|
|
/// <param name="commessa"></param>
|
|
/// <param name="risorsa"></param>
|
|
/// <param name="allocazione"></param>
|
|
public allocRis(string commessa, string risorsa, int allocazione)
|
|
{
|
|
this.commessa = commessa;
|
|
this.risorsa = risorsa;
|
|
this.allocazione = allocazione;
|
|
}
|
|
|
|
#endregion Public Constructors
|
|
|
|
#region Public Properties
|
|
|
|
/// <summary>
|
|
/// allocazione risorsa/commessa
|
|
/// </summary>
|
|
public int allocazione { get; set; }
|
|
|
|
/// <summary>
|
|
/// codice commessa
|
|
/// </summary>
|
|
public string commessa { get; set; }
|
|
|
|
/// <summary>
|
|
/// codice risorsa
|
|
/// </summary>
|
|
public string risorsa { get; set; }
|
|
|
|
#endregion Public Properties
|
|
}
|
|
|
|
/// <summary>
|
|
/// classe di funzioni inerenti le date
|
|
/// </summary>
|
|
public class datario
|
|
{
|
|
#region Public Fields
|
|
|
|
/// <summary>
|
|
/// oggetto singleton
|
|
/// </summary>
|
|
public static datario mngr = new datario();
|
|
|
|
#endregion Public Fields
|
|
|
|
#region Public Constructors
|
|
|
|
/// <summary>
|
|
/// inizializzazione empty
|
|
/// </summary>
|
|
public datario()
|
|
{
|
|
}
|
|
|
|
#endregion Public Constructors
|
|
|
|
#region Public Methods
|
|
|
|
/// <summary>
|
|
/// restituisce la prima data della settimana richiesta
|
|
/// </summary>
|
|
/// <param name="year"></param>
|
|
/// <param name="weekOfYear"></param>
|
|
/// <returns></returns>
|
|
public static DateTime FirstDateOfWeekISO8601(int year, int weekOfYear)
|
|
{
|
|
DateTime jan1 = new DateTime(year, 1, 1);
|
|
int daysOffset = DayOfWeek.Thursday - jan1.DayOfWeek;
|
|
|
|
DateTime firstThursday = jan1.AddDays(daysOffset);
|
|
var cal = CultureInfo.CurrentCulture.Calendar;
|
|
int firstWeek = cal.GetWeekOfYear(firstThursday, CalendarWeekRule.FirstFourDayWeek, DayOfWeek.Monday);
|
|
|
|
var weekNum = weekOfYear;
|
|
if (firstWeek <= 1)
|
|
{
|
|
weekNum -= 1;
|
|
}
|
|
var result = firstThursday.AddDays(weekNum * 7);
|
|
return result.AddDays(-3);
|
|
}
|
|
|
|
/// <summary>
|
|
/// calcola week number secondo ISO 8601
|
|
/// </summary>
|
|
/// <param name="date"></param>
|
|
/// <returns></returns>
|
|
public static int WeekOfYearISO8601(DateTime date)
|
|
{
|
|
var day = (int)CultureInfo.CurrentCulture.Calendar.GetDayOfWeek(date);
|
|
return CultureInfo.CurrentCulture.Calendar.GetWeekOfYear(date.AddDays(4 - (day == 0 ? 7 : day)), CalendarWeekRule.FirstFourDayWeek, DayOfWeek.Monday);
|
|
}
|
|
|
|
/// <summary>
|
|
/// restituisce l'intervallo dell'anno corrente per la data indicata
|
|
/// </summary>
|
|
/// <param name="data"></param>
|
|
/// <returns></returns>
|
|
public intervalloDate estremiAnno(DateTime data)
|
|
{
|
|
intervalloDate interv = new intervalloDate();
|
|
interv.inizio = data.AddDays(-(data.Day - 1)).AddMonths(-(data.Month - 1)).Subtract(data.TimeOfDay);
|
|
interv.fine = interv.inizio.AddMonths(12);
|
|
return interv;
|
|
}
|
|
|
|
/// <summary>
|
|
/// restituisce l'intervallo del mese che comprende la data indicata (dal primo all'ultimo giorno)
|
|
/// </summary>
|
|
/// <param name="data"></param>
|
|
/// <returns></returns>
|
|
public intervalloDate estremiMese(DateTime data)
|
|
{
|
|
intervalloDate interv = new intervalloDate();
|
|
interv.inizio = data.AddDays(-(data.Day - 1)).Subtract(data.TimeOfDay);
|
|
interv.fine = interv.inizio.AddMonths(1);
|
|
return interv;
|
|
}
|
|
|
|
/// <summary>
|
|
/// restituisce l'intervallo del giorno completo che comprende la data indicata
|
|
/// </summary>
|
|
/// <param name="data"></param>
|
|
/// <returns></returns>
|
|
public intervalloDate giornata(DateTime data)
|
|
{
|
|
intervalloDate interv = new intervalloDate();
|
|
interv.inizio = data.Subtract(data.TimeOfDay);
|
|
interv.fine = interv.inizio.AddDays(1);
|
|
return interv;
|
|
}
|
|
|
|
/// <summary>
|
|
/// effettua l'operazione di intersezione tra 2 intervali di date restituendo ulteriore intervallo: NB se sono intervali disgiunti restituisce 9/9/9999 x inizio e fine
|
|
/// </summary>
|
|
/// <param name="interv1"></param>
|
|
/// <param name="interv2"></param>
|
|
/// <returns></returns>
|
|
public intervalloDate intersecaIntervalli(intervalloDate interv1, intervalloDate interv2)
|
|
{
|
|
intervalloDate interv3;
|
|
// verifico non siano disgiunti...
|
|
if (interv1.fine < interv2.inizio || interv2.fine < interv1.inizio)
|
|
{
|
|
interv3.inizio = Convert.ToDateTime("9/9/9999");
|
|
interv3.fine = Convert.ToDateTime("9/9/9999");
|
|
}
|
|
else
|
|
{
|
|
interv3 = interv1;
|
|
if (interv2.inizio > interv1.inizio)
|
|
{
|
|
interv3.inizio = interv2.inizio;
|
|
}
|
|
if (interv2.fine < interv1.fine)
|
|
{
|
|
interv3.fine = interv2.fine;
|
|
}
|
|
}
|
|
return interv3;
|
|
}
|
|
|
|
/// <summary>
|
|
/// oggetto mese corrente fino alla dataLilmite
|
|
/// </summary>
|
|
/// <param name="dataLimite"></param>
|
|
public intervalloDate meseCorrente(DateTime dataLimite)
|
|
{
|
|
intervalloDate interv = new intervalloDate();
|
|
interv.inizio = dataLimite.AddDays(-(dataLimite.Day - 1)).Subtract(dataLimite.TimeOfDay);
|
|
interv.fine = dataLimite.Subtract(dataLimite.TimeOfDay);
|
|
return interv;
|
|
}
|
|
|
|
/// <summary>
|
|
/// oggetto mese precedente alla dataLilmite
|
|
/// </summary>
|
|
/// <param name="dataLimite"></param>
|
|
public intervalloDate mesePrecedente(DateTime dataLimite)
|
|
{
|
|
intervalloDate interv = new intervalloDate();
|
|
interv.inizio = dataLimite.AddMonths(-1).AddDays(-(dataLimite.Day - 1)).Subtract(dataLimite.TimeOfDay);
|
|
interv.fine = dataLimite.AddDays(-(dataLimite.Day - 1)).Subtract(dataLimite.TimeOfDay);
|
|
return interv;
|
|
}
|
|
|
|
/// <summary>
|
|
/// restituisce l'intervallo della settimana corrente per la data indicata
|
|
/// </summary>
|
|
/// <param name="data"></param>
|
|
/// <returns></returns>
|
|
public intervalloDate questaSett(DateTime data)
|
|
{
|
|
intervalloDate interv = new intervalloDate();
|
|
interv.fine = data.Subtract(data.TimeOfDay).AddDays(1);
|
|
DayOfWeek giorno = data.DayOfWeek;
|
|
int numGG = 0;
|
|
switch (giorno)
|
|
{
|
|
case DayOfWeek.Monday:
|
|
numGG = 1;
|
|
break;
|
|
|
|
case DayOfWeek.Tuesday:
|
|
numGG = 2;
|
|
break;
|
|
|
|
case DayOfWeek.Wednesday:
|
|
numGG = 3;
|
|
break;
|
|
|
|
case DayOfWeek.Thursday:
|
|
numGG = 4;
|
|
break;
|
|
|
|
case DayOfWeek.Friday:
|
|
numGG = 5;
|
|
break;
|
|
|
|
case DayOfWeek.Saturday:
|
|
numGG = 6;
|
|
break;
|
|
|
|
case DayOfWeek.Sunday:
|
|
numGG = 7;
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
interv.inizio = interv.fine.AddDays(-numGG);
|
|
return interv;
|
|
}
|
|
|
|
/// <summary>
|
|
/// restituisce l'intervallo del mese corrente per la data indicata (dal giorno 1 all'indomani delal data indicata)
|
|
/// </summary>
|
|
/// <param name="data"></param>
|
|
/// <returns></returns>
|
|
public intervalloDate questoMese(DateTime data)
|
|
{
|
|
intervalloDate interv = new intervalloDate();
|
|
interv.fine = data.Subtract(data.TimeOfDay).AddDays(1);
|
|
interv.inizio = interv.fine.AddDays(-data.Day);
|
|
return interv;
|
|
}
|
|
|
|
/// <summary>
|
|
/// costruisce un oggetto intervallo date
|
|
/// </summary>
|
|
/// <param name="inizio"></param>
|
|
/// <param name="fine"></param>
|
|
/// <returns></returns>
|
|
public intervalloDate setIntervallo(DateTime inizio, DateTime fine)
|
|
{
|
|
intervalloDate periodo = new intervalloDate();
|
|
periodo.inizio = inizio;
|
|
periodo.fine = fine;
|
|
return periodo;
|
|
}
|
|
|
|
/// <summary>
|
|
/// confronta le date e restituisce true se le date sono nello stesso mese
|
|
/// </summary>
|
|
/// <param name="data1"></param>
|
|
/// <param name="data2"></param>
|
|
/// <returns></returns>
|
|
public bool stessoMese(DateTime data1, DateTime data2)
|
|
{
|
|
bool stessoMese = false;
|
|
if ((data1.Year == data2.Year) && (data1.Month == data2.Month))
|
|
{
|
|
stessoMese = true;
|
|
}
|
|
return stessoMese;
|
|
}
|
|
|
|
/// <summary>
|
|
/// restituisce l'intervallo di N giorni fino alla data indicata
|
|
/// </summary>
|
|
/// <param name="data"></param>
|
|
/// <param name="numGiorniPrima"></param>
|
|
/// <returns></returns>
|
|
public intervalloDate ultimiGiorni(DateTime data, int numGiorniPrima)
|
|
{
|
|
intervalloDate interv = new intervalloDate();
|
|
interv.fine = data.Subtract(data.TimeOfDay).AddDays(1);
|
|
interv.inizio = interv.fine.AddDays(-numGiorniPrima);
|
|
return interv;
|
|
}
|
|
|
|
#endregion Public Methods
|
|
}
|
|
|
|
public class oreWeek
|
|
{
|
|
#region Public Constructors
|
|
|
|
/// <summary>
|
|
/// inizializzazione empty
|
|
/// </summary>
|
|
public oreWeek()
|
|
{
|
|
}
|
|
|
|
#endregion Public Constructors
|
|
|
|
#region Public Methods
|
|
|
|
/// <summary>
|
|
/// effettua una somma di ore dallo schema ore LMMGV facendo somma giorno per giorno
|
|
/// </summary>
|
|
/// <param name="addendo1">string LMMGV (se <> 5 char errore)</param>
|
|
/// <param name="addendo2">string LMMGV (se <> 5 char errore)</param>
|
|
/// <returns>Restituisce:
|
|
/// - somma giornaliera LMMGV
|
|
/// - "X" se nel singolo giorno > maxOre
|
|
/// - "?????" se secondo addendo nn di 5 char
|
|
/// - "#" se non può convertire un singolo char</returns>
|
|
public static string addOre(string addendo1, string addendo2, int MaxOre)
|
|
{
|
|
string answ = "";
|
|
int summa = 0;
|
|
// procedo SOLO se le 2 stringhe sono 5 char
|
|
if (addendo1.Length != 5 || addendo2.Length != 5)
|
|
{
|
|
answ = "?????";
|
|
}
|
|
else
|
|
{
|
|
// faccio somma 1 char alla volta e controllo lungh max
|
|
for (int i = 0; i < 5; i++)
|
|
{
|
|
try
|
|
{
|
|
// se già ho carattere "X" confermo "X"...
|
|
if (addendo1.Substring(i, 1) == "X" || addendo1.Substring(i, 1) == "X")
|
|
{
|
|
answ += "X";
|
|
}
|
|
else
|
|
{
|
|
summa = Convert.ToInt16(addendo1.Substring(i, 1)) + Convert.ToInt16(addendo2.Substring(i, 1));
|
|
if (summa > MaxOre)
|
|
{
|
|
answ += "X";
|
|
}
|
|
else
|
|
{
|
|
answ += summa.ToString();
|
|
}
|
|
}
|
|
}
|
|
catch
|
|
{
|
|
answ += "X";
|
|
}
|
|
}
|
|
}
|
|
return answ;
|
|
}
|
|
|
|
#endregion Public Methods
|
|
}
|
|
|
|
public class utils
|
|
{
|
|
#region Private Fields
|
|
|
|
/// <summary>
|
|
/// Connessione lazy a redis...
|
|
/// </summary>
|
|
private static Lazy<ConnectionMultiplexer> lazyConnection = new Lazy<ConnectionMultiplexer>(() =>
|
|
{
|
|
return ConnectionMultiplexer.Connect("127.0.0.1,abortConnect=false,ssl=false");
|
|
});
|
|
|
|
#endregion Private Fields
|
|
|
|
#region Protected Fields
|
|
|
|
protected AppSettingsReader configAppSetReader;
|
|
|
|
#endregion Protected Fields
|
|
|
|
#region Public Fields
|
|
|
|
public static Logger lg = LogManager.GetCurrentClassLogger();
|
|
|
|
/// <summary>
|
|
/// oggetto static per fare chiamate sul magazzino
|
|
/// </summary>
|
|
public static utils obj = new utils();
|
|
|
|
public DS_utilsTableAdapters.AnagSuggestTagsTableAdapter taAST;
|
|
public DS_utilsTableAdapters.stp_calcolaProtocolloTableAdapter taCalcProto;
|
|
public DS_WebScipTableAdapters.stp_userLoginRefreshDbTableAdapter taDBRefresh;
|
|
public DS_AnagraficaTableAdapters.DirittiTableAdapter taDiritti;
|
|
public DS_WebScipTableAdapters.tbDocumentiTableAdapter taDoc;
|
|
public DS_utilsTableAdapters.v_selEmailFornitoriTableAdapter taEmailForn;
|
|
public DS_utilsTableAdapters.v_selAutoriTableAdapter taSelAutori;
|
|
public DS_utilsTableAdapters.v_selCommesseTableAdapter taSelCommesse;
|
|
public DS_utilsTableAdapters.v_selFasiTableAdapter taSelFasi;
|
|
public DS_utilsTableAdapters.v_selFontiTableAdapter taSelFonti;
|
|
public DS_WebScipTableAdapters.Tags2DocTableAdapter taTags2Doc;
|
|
public DS_utilsTableAdapters.v_tbDocs_selCommesseTableAdapter taTDSelCommesse;
|
|
public DS_utilsTableAdapters.v_tbDocs_selFasiTableAdapter taTDSelFasi;
|
|
public DS_utilsTableAdapters.v_tbDocs_selFontiTableAdapter taTDSelFonti;
|
|
public DS_utilsTableAdapters.v_tbDocs_selOggettoTableAdapter taTDSelOggetti;
|
|
public DS_utilsTableAdapters.v_tbDocs_selRedattoreTableAdapter taTDSelRedattore;
|
|
public DS_WebScipTableAdapters.tbMetaDataSetTableAdapter taTMD;
|
|
public DS_AnagraficaTableAdapters.UtentiTableAdapter taUtenti;
|
|
public DS_utilsTableAdapters.v_selFonti_explTableAdapter taVSFE;
|
|
|
|
#endregion Public Fields
|
|
|
|
#region Protected Constructors
|
|
|
|
protected utils()
|
|
{
|
|
configAppSetReader = new AppSettingsReader();
|
|
initTA();
|
|
setupConnectionStringBase();
|
|
}
|
|
|
|
#endregion Protected Constructors
|
|
|
|
#region Public Properties
|
|
|
|
/// <summary>
|
|
/// Oggetto statico connessione redis
|
|
/// </summary>
|
|
public static ConnectionMultiplexer connRedis
|
|
{
|
|
get
|
|
{
|
|
return lazyConnection.Value;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// dim pagina desiderata
|
|
/// </summary>
|
|
public static int pageSize
|
|
{
|
|
get
|
|
{
|
|
int answ = 0;
|
|
try
|
|
{
|
|
answ = utils.obj.IntSessionObj("pageSize");
|
|
}
|
|
catch
|
|
{ }
|
|
if (answ <= 0)
|
|
{
|
|
answ = 20;
|
|
}
|
|
return answ;
|
|
}
|
|
set
|
|
{
|
|
utils.obj.setSessionVal("pageSize", value);
|
|
}
|
|
}
|
|
|
|
public static int pageSizeConf
|
|
{
|
|
get
|
|
{
|
|
return obj.confReadInt("pageSize");
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// WRAPPER utente correntemente connesso per utilizzo FileSystem (Formato dominio.username)
|
|
/// </summary>
|
|
public string currUser_FS
|
|
{
|
|
get
|
|
{
|
|
return user_std.UtSn.currUser_FS;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// WRAPPER utente correntemente connesso (Formato dominio\username)
|
|
/// </summary>
|
|
public string currUserAD
|
|
{
|
|
get
|
|
{
|
|
return user_std.UtSn.currUserAD;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// WRAPPER utente correntemente connesso (Formato Cognome nome)
|
|
/// </summary>
|
|
public string currUserCognomeNome
|
|
{
|
|
get
|
|
{
|
|
return user_std.UtSn.currUserCognomeNome;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// WRAPPER EMAIL utente correntemente connesso
|
|
/// </summary>
|
|
public string currUserEmail
|
|
{
|
|
get
|
|
{
|
|
return user_std.UtSn.currUserEmail;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// WRAPPER UserId (AD) utente correntemente connesso
|
|
/// </summary>
|
|
public string currUserId
|
|
{
|
|
get
|
|
{
|
|
return user_std.UtSn.currUserId;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// WRAPPER utente correntemente connesso (Formato Nome Cognome)
|
|
/// </summary>
|
|
public string currUserNomeCognome
|
|
{
|
|
get
|
|
{
|
|
return user_std.UtSn.currUserNomeCognome;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// risponde alla domanda se l'utente sia CapoCommessa
|
|
/// </summary>
|
|
/// <returns></returns>
|
|
public bool isCC
|
|
{
|
|
get
|
|
{
|
|
return user_std.UtSn.userHasRight("CC");
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// risponde alla domanda se l'utente sia ProjectManager
|
|
/// </summary>
|
|
/// <returns></returns>
|
|
public bool isPM
|
|
{
|
|
get
|
|
{
|
|
return user_std.UtSn.userHasRight("PM");
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// risponde alla domanda se l'utente sia PowerReader
|
|
/// </summary>
|
|
/// <returns></returns>
|
|
public bool isPowerReader
|
|
{
|
|
get
|
|
{
|
|
return user_std.UtSn.userHasRight("PowerReader");
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// risponde alla domanda se l'utente sia PowerUser
|
|
/// </summary>
|
|
/// <returns></returns>
|
|
public bool isPowerUser
|
|
{
|
|
get
|
|
{
|
|
return user_std.UtSn.userHasRight("PowerUser");
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// risponde alla domanda se l'utente sia User
|
|
/// </summary>
|
|
/// <returns></returns>
|
|
public bool isUser
|
|
{
|
|
get
|
|
{
|
|
return user_std.UtSn.userHasRight("User");
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Restituisce numero record in Redis DB
|
|
/// </summary>
|
|
public long numRecRedis
|
|
{
|
|
get
|
|
{
|
|
long answ = 0;
|
|
try
|
|
{
|
|
foreach (var ep in connRedis.GetEndPoints())
|
|
{
|
|
var server = connRedis.GetServer(ep);
|
|
answ += server.DatabaseSize();
|
|
}
|
|
}
|
|
catch
|
|
{ }
|
|
return answ;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Verifica se si debba serializzare ogni valore complesso (tabelle/righe) in sessione (per impiego di sessioni avanzate come Redis)
|
|
/// </summary>
|
|
public bool serializeSession
|
|
{
|
|
get
|
|
{
|
|
return confReadBool("serializeSession");
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// elenco dictionary delle tab in cache da aggiornare con update svuotando da cache...
|
|
/// </summary>
|
|
public Dictionary<string, string> tabelleInCache
|
|
{
|
|
get
|
|
{
|
|
try
|
|
{
|
|
return (Dictionary<string, string>)objCacheObj("tabelleInCache");
|
|
}
|
|
catch
|
|
{
|
|
return new Dictionary<string, string>();
|
|
}
|
|
}
|
|
set
|
|
{
|
|
setCacheVal("tabelleInCache", value);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// elenco dictionary dei valori in session da NON aggiornare con update...
|
|
/// </summary>
|
|
public Dictionary<string, string> valSess2SurvUpd
|
|
{
|
|
get
|
|
{
|
|
try
|
|
{
|
|
return (Dictionary<string, string>)objSessionObj("valoriInSession2Survive");
|
|
}
|
|
catch
|
|
{
|
|
return new Dictionary<string, string>();
|
|
}
|
|
}
|
|
set
|
|
{
|
|
setSessionVal("valoriInSession2Survive", value);
|
|
}
|
|
}
|
|
|
|
#endregion Public Properties
|
|
|
|
#region Protected Methods
|
|
|
|
/// <summary>
|
|
/// init dei table adapters
|
|
/// </summary>
|
|
protected void initTA()
|
|
{
|
|
taUtenti = new DS_AnagraficaTableAdapters.UtentiTableAdapter();
|
|
taDiritti = new DS_AnagraficaTableAdapters.DirittiTableAdapter();
|
|
taSelFonti = new DS_utilsTableAdapters.v_selFontiTableAdapter();
|
|
taSelCommesse = new DS_utilsTableAdapters.v_selCommesseTableAdapter();
|
|
taSelFasi = new DS_utilsTableAdapters.v_selFasiTableAdapter();
|
|
taSelAutori = new DS_utilsTableAdapters.v_selAutoriTableAdapter();
|
|
taTDSelFonti = new DS_utilsTableAdapters.v_tbDocs_selFontiTableAdapter();
|
|
taTDSelCommesse = new DS_utilsTableAdapters.v_tbDocs_selCommesseTableAdapter();
|
|
taTDSelFasi = new DS_utilsTableAdapters.v_tbDocs_selFasiTableAdapter();
|
|
taTDSelOggetti = new DS_utilsTableAdapters.v_tbDocs_selOggettoTableAdapter();
|
|
taTDSelRedattore = new DS_utilsTableAdapters.v_tbDocs_selRedattoreTableAdapter();
|
|
taCalcProto = new DS_utilsTableAdapters.stp_calcolaProtocolloTableAdapter();
|
|
taEmailForn = new DS_utilsTableAdapters.v_selEmailFornitoriTableAdapter();
|
|
taAST = new DS_utilsTableAdapters.AnagSuggestTagsTableAdapter();
|
|
taVSFE = new DS_utilsTableAdapters.v_selFonti_explTableAdapter();
|
|
taDoc = new DS_WebScipTableAdapters.tbDocumentiTableAdapter();
|
|
taTags2Doc = new DS_WebScipTableAdapters.Tags2DocTableAdapter();
|
|
taTMD = new DS_WebScipTableAdapters.tbMetaDataSetTableAdapter();
|
|
taDBRefresh = new DS_WebScipTableAdapters.stp_userLoginRefreshDbTableAdapter();
|
|
}
|
|
|
|
/// <summary>
|
|
/// effettua setup dei connection strings da web.config delal singola applicazione
|
|
/// </summary>
|
|
protected virtual void setupConnectionStringBase()
|
|
{
|
|
string connStringETS_WS = (string)configAppSetReader.GetValue("ETS_WSConnectionString", typeof(string));
|
|
string connStringETS_WAnagrafica = (string)configAppSetReader.GetValue("ETS_AnagraficaConnectionString", typeof(string));
|
|
// connections del db
|
|
taUtenti.Connection.ConnectionString = connStringETS_WAnagrafica;
|
|
taDiritti.Connection.ConnectionString = connStringETS_WAnagrafica;
|
|
|
|
taSelFonti.Connection.ConnectionString = connStringETS_WS;
|
|
taSelCommesse.Connection.ConnectionString = connStringETS_WS;
|
|
taSelFasi.Connection.ConnectionString = connStringETS_WS;
|
|
taSelAutori.Connection.ConnectionString = connStringETS_WS;
|
|
taTDSelFonti.Connection.ConnectionString = connStringETS_WS;
|
|
taTDSelCommesse.Connection.ConnectionString = connStringETS_WS;
|
|
taTDSelFasi.Connection.ConnectionString = connStringETS_WS;
|
|
taTDSelOggetti.Connection.ConnectionString = connStringETS_WS;
|
|
taTDSelRedattore.Connection.ConnectionString = connStringETS_WS;
|
|
taCalcProto.Connection.ConnectionString = connStringETS_WS;
|
|
taEmailForn.Connection.ConnectionString = connStringETS_WS;
|
|
taAST.Connection.ConnectionString = connStringETS_WS;
|
|
taVSFE.Connection.ConnectionString = connStringETS_WS;
|
|
taDoc.Connection.ConnectionString = connStringETS_WS;
|
|
taTags2Doc.Connection.ConnectionString = connStringETS_WS;
|
|
taTMD.Connection.ConnectionString = connStringETS_WS;
|
|
taDBRefresh.Connection.ConnectionString = connStringETS_WS;
|
|
}
|
|
|
|
#endregion Protected Methods
|
|
|
|
#region Public Methods
|
|
|
|
/// <summary>
|
|
/// ripulisce la stringa da eventuali caratteri non ammessi quali
|
|
/// [ .,;\/]
|
|
/// e OPZIONALMENTE toglie " " (spazi) sostituendoli con "_" (underscore)
|
|
/// </summary>
|
|
/// <param name="originalName">stringa originale</param>
|
|
/// <param name="keepSpaces">definisce se mantenere (true) o togliere (false) gli spazi (eventualmente sostituendo con underscore "_")</param>
|
|
/// <returns></returns>
|
|
public static string cleanPathName(string originalName, bool keepSpaces)
|
|
{
|
|
string answ = originalName.Trim().Replace("&", "e").Replace(".", "").Replace(",", "").Replace(";", "").Replace(":", "").Replace("/", "-").Replace(@"\", "-").Replace(@"'", "_").Replace("\"", "_").Replace("#", "_").Replace("?", "_").Replace("*", "_").Replace(" ", "_").Replace("__", "_").Replace("__", "_").Replace("__", "_").Replace("__", "_"); ;
|
|
if (keepSpaces)
|
|
{
|
|
answ = originalName.Trim().Replace("&", "e").Replace(".", "").Replace(",", "").Replace(";", "").Replace(":", "").Replace("/", "-").Replace(@"\", "-").Replace(@"'", "_").Replace("\"", "_").Replace("#", "_").Replace("?", "_").Replace("*", "_").Replace(" ", " ").Replace(" ", " ").Replace(" ", " ").Replace(" ", " ").Replace("__", "_").Replace("__", "_").Replace("__", "_").Replace("__", "_");
|
|
}
|
|
return answ;
|
|
}
|
|
|
|
/// <summary>
|
|
/// ripulisce la stringa da eventuali caratteri non ammessi quali
|
|
/// [ .,;\/]
|
|
/// e toglie " " (spazi) sostituendoli con "_" (underscore)
|
|
/// </summary>
|
|
/// <param name="originalName">stringa originale</param>
|
|
/// <returns></returns>
|
|
public static string cleanPathName(string originalName)
|
|
{
|
|
return cleanPathName(originalName, false);
|
|
}
|
|
|
|
/// <summary>
|
|
/// restituisce, in caso di null o stringa vuota, il carattere "*"
|
|
/// </summary>
|
|
/// <param name="original"></param>
|
|
/// <returns></returns>
|
|
public static string emptyToStar(string original)
|
|
{
|
|
string answ = original;
|
|
if ((original == null) || (original == ""))
|
|
{
|
|
answ = "*";
|
|
}
|
|
return answ;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Effettua shring di una stringa ricudendola in lunghezza (tiene inizio/fine + eventuale ".." centrale se lungh superiore a indicata)
|
|
/// </summary>
|
|
/// <param name="originalString">stringa originale</param>
|
|
/// <param name="maxLenght">lungh max desiderata</param>
|
|
/// <returns></returns>
|
|
public static string shrinkString(string originalString, int maxLenght)
|
|
{
|
|
string answ = originalString;
|
|
if (answ.Length > maxLenght)
|
|
{
|
|
string sep = utils.obj.confReadString("separatoreTrim");
|
|
int numChar = (maxLenght - sep.Length) / 2;
|
|
answ = string.Format("{0}{1}{2}", answ.Substring(0, numChar), sep, answ.Substring(answ.Length - (maxLenght - 3 - numChar)));
|
|
}
|
|
return answ;
|
|
}
|
|
|
|
/// <summary>
|
|
/// trimma una stringa per il num max di caratteri richiesti togliendo dal centro (tiene inizio/fine...)
|
|
/// </summary>
|
|
/// <param name="stringaIn"></param>
|
|
/// <param name="maxNum"></param>
|
|
/// <param name="ignoreRight">num caratteri da ignorare a dx</param>
|
|
/// <returns></returns>
|
|
public static string shrinkString(string stringaIn, int maxNum, int ignoreRight)
|
|
{
|
|
// elimino caratteri a dx.. se posso
|
|
string answ = stringaIn;
|
|
if (ignoreRight < stringaIn.Length)
|
|
{
|
|
answ = answ.Substring(0, stringaIn.Length - ignoreRight);
|
|
}
|
|
// effetuo shrink!
|
|
answ = shrinkString(answ, maxNum);
|
|
return answ;
|
|
}
|
|
|
|
/// <summary>
|
|
/// trimma una stringa per il num max di caratteri richiesti
|
|
/// </summary>
|
|
/// <param name="stringaIn"></param>
|
|
/// <returns></returns>
|
|
public static string trimChar(object stringaIn, object maxChar)
|
|
{
|
|
string answ = "";
|
|
int maxNum = 0;
|
|
try
|
|
{
|
|
answ = stringaIn.ToString();
|
|
maxNum = Convert.ToInt32(maxChar);
|
|
}
|
|
catch
|
|
{ }
|
|
if (maxNum < answ.Length)
|
|
{
|
|
answ = answ.Substring(0, maxNum) + "...";
|
|
}
|
|
return answ;
|
|
}
|
|
|
|
/// <summary>
|
|
/// aggiunge la stringa corrente nel dictionary delle tabelle messe in cache e da aggiornare su comando update
|
|
/// </summary>
|
|
/// <param name="nuovaTab"></param>
|
|
public void addTabInCache(string nuovaTab)
|
|
{
|
|
// provo ad aggiungere nuova tab in elenco...
|
|
Dictionary<string, string> _tabelleInCache = tabelleInCache;
|
|
try
|
|
{
|
|
_tabelleInCache.Add(nuovaTab, nuovaTab);
|
|
tabelleInCache = _tabelleInCache;
|
|
}
|
|
catch
|
|
{ }
|
|
}
|
|
|
|
/// <summary>
|
|
/// aggiunge la stringa corrente nel dictionary delle tabelle messe in session che vanno preservate da comando update (es: oggetto selezionato...)
|
|
/// </summary>
|
|
/// <param name="nomePar"></param>
|
|
/// <param name="valore"></param>
|
|
public void addValInSession(string nomePar, string valore)
|
|
{
|
|
// provo ad aggiungere nuova tab in elenco...
|
|
Dictionary<string, string> _valoriInSession2Survive = valSess2SurvUpd;
|
|
// verifico se fare update o insert...
|
|
if (_valoriInSession2Survive.ContainsKey(nomePar))
|
|
{
|
|
// update, rimuovo vecchio valore...
|
|
try
|
|
{
|
|
_valoriInSession2Survive.Remove(nomePar);
|
|
}
|
|
catch
|
|
{ }
|
|
}
|
|
// insert
|
|
try
|
|
{
|
|
_valoriInSession2Survive.Add(nomePar, valore);
|
|
valSess2SurvUpd = _valoriInSession2Survive;
|
|
}
|
|
catch
|
|
{ }
|
|
}
|
|
|
|
/// <summary>
|
|
/// carica dalla Cachee un dato di tipo boolean (se vuoto false)
|
|
/// </summary>
|
|
/// <param name="nomeVar"></param>
|
|
/// <returns></returns>
|
|
public bool BoolCacheObj(string nomeVar)
|
|
{
|
|
if (HttpContext.Current.Cache[nomeVar] != null)
|
|
{
|
|
return (bool)HttpContext.Current.Cache[nomeVar];
|
|
}
|
|
else
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// carica dalla sessione un dato di tipo boolean (se vuoto false)
|
|
/// </summary>
|
|
/// <param name="nomeVar"></param>
|
|
/// <returns></returns>
|
|
public bool BoolSessionObj(string nomeVar)
|
|
{
|
|
if (HttpContext.Current.Session[nomeVar] != null)
|
|
{
|
|
return (bool)HttpContext.Current.Session[nomeVar];
|
|
}
|
|
else
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// legge dalla config un valore bool
|
|
/// </summary>
|
|
/// <param name="nomeParam"></param>
|
|
/// <returns></returns>
|
|
public bool confReadBool(string nomeParam)
|
|
{
|
|
bool answ = false;
|
|
try
|
|
{
|
|
answ = (bool)configAppSetReader.GetValue(nomeParam, typeof(bool));
|
|
}
|
|
catch
|
|
{ }
|
|
return answ;
|
|
}
|
|
|
|
/// <summary>
|
|
/// legge dalla config un valore int
|
|
/// </summary>
|
|
/// <param name="nomeParam"></param>
|
|
/// <returns></returns>
|
|
public int confReadInt(string nomeParam)
|
|
{
|
|
int answ = -1;
|
|
try
|
|
{
|
|
answ = (int)configAppSetReader.GetValue(nomeParam, typeof(int));
|
|
}
|
|
catch
|
|
{ }
|
|
return answ;
|
|
}
|
|
|
|
/// <summary>
|
|
/// legge dalla config un valore string
|
|
/// </summary>
|
|
/// <param name="nomeParam"></param>
|
|
/// <returns></returns>
|
|
public string confReadString(string nomeParam)
|
|
{
|
|
string answ = "";
|
|
try
|
|
{
|
|
answ = (string)configAppSetReader.GetValue(nomeParam, typeof(string));
|
|
}
|
|
catch
|
|
{ }
|
|
return answ;
|
|
}
|
|
|
|
/// <summary>
|
|
/// carica dalla sessione un dato di tipo DataSet NON Tipizzato
|
|
/// </summary>
|
|
/// <param name="nomeVar"></param>
|
|
/// <returns></returns>
|
|
public DataSet dsSessionObj(string nomeVar)
|
|
{
|
|
if (HttpContext.Current.Session[nomeVar] != null)
|
|
{
|
|
string valSer = obj.StringSessionObj(nomeVar);
|
|
DataSet dataSet = JsonConvert.DeserializeObject<DataSet>(valSer);
|
|
return dataSet;
|
|
}
|
|
else
|
|
{
|
|
return null;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// svuota una variabile dalla Cache
|
|
/// </summary>
|
|
/// <param name="nome"></param>
|
|
public bool emptyCacheVal(string nome)
|
|
{
|
|
bool _done = false;
|
|
try
|
|
{
|
|
HttpContext.Current.Cache.Remove(nome);
|
|
_done = true;
|
|
}
|
|
catch
|
|
{ }
|
|
return _done;
|
|
}
|
|
|
|
/// <summary>
|
|
/// svuota una variabile dalla session
|
|
/// </summary>
|
|
/// <param name="nome"></param>
|
|
public bool emptySessionVal(string nome)
|
|
{
|
|
bool _done = false;
|
|
try
|
|
{
|
|
HttpContext.Current.Session.Remove(nome);
|
|
_done = true;
|
|
}
|
|
catch
|
|
{ }
|
|
return _done;
|
|
}
|
|
|
|
/// <summary>
|
|
/// forza lo svuotamento delle tabelle indicate come in cache...
|
|
/// </summary>
|
|
public void flushRegisteredCache()
|
|
{
|
|
// elimino tutte le tab nella pos tabInCache...
|
|
foreach (KeyValuePair<string, string> kvp in tabelleInCache)
|
|
{
|
|
HttpContext.Current.Cache.Remove(kvp.Value);
|
|
}
|
|
HttpContext.Current.Cache.Remove("tabelleInCache");
|
|
}
|
|
|
|
/// <summary>
|
|
/// Restituisce una chiave COUNTER in RedisCache
|
|
/// </summary>
|
|
/// <param name="chiave"></param>
|
|
/// <returns></returns>
|
|
public int getRCnt(string chiave)
|
|
{
|
|
int answInt = 0;
|
|
string answ = "";
|
|
try
|
|
{
|
|
IDatabase cache = connRedis.GetDatabase();
|
|
answ = cache.StringGet(chiave);
|
|
answInt = Convert.ToInt32(answ);
|
|
}
|
|
catch (Exception exc)
|
|
{
|
|
utils.lg.Error(string.Format("Errore in getRSV:{0}{1}", Environment.NewLine, exc));
|
|
}
|
|
return answInt;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Restituisce un set KVP (Key Value Pair) salvati in RedisCache
|
|
/// </summary>
|
|
/// <param name="chiavi"></param>
|
|
/// <returns></returns>
|
|
public RedisValue[] getRKeys(RedisKey[] chiavi)
|
|
{
|
|
RedisValue[] answ = null;
|
|
try
|
|
{
|
|
IDatabase cache = connRedis.GetDatabase();
|
|
answ = cache.StringGet(chiavi);
|
|
}
|
|
catch (Exception exc)
|
|
{
|
|
utils.lg.Error(string.Format("Errore in getRKeys:{0}{1}", Environment.NewLine, exc));
|
|
}
|
|
return answ;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Restituisce una chiave salvata in RedisCache
|
|
/// </summary>
|
|
/// <param name="chiave"></param>
|
|
/// <returns></returns>
|
|
public string getRSV(string chiave)
|
|
{
|
|
string answ = "";
|
|
try
|
|
{
|
|
IDatabase cache = connRedis.GetDatabase();
|
|
answ = cache.StringGet(chiave);
|
|
}
|
|
catch (Exception exc)
|
|
{
|
|
utils.lg.Error(string.Format("Errore in getRSV:{0}{1}", Environment.NewLine, exc));
|
|
}
|
|
return answ;
|
|
}
|
|
|
|
/// <summary>
|
|
/// carica dalla sessione un dato di tipo int
|
|
/// </summary>
|
|
/// <param name="nomeVar"></param>
|
|
/// <returns></returns>
|
|
public int IntSessionObj(string nomeVar)
|
|
{
|
|
if (HttpContext.Current.Session[nomeVar] != null)
|
|
{
|
|
return (int)Convert.ToInt32(HttpContext.Current.Session[nomeVar].ToString());
|
|
}
|
|
else
|
|
{
|
|
return -1;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// risponde alla domanda se l'utente sia CC della commessa indicata dalla fase
|
|
/// </summary>
|
|
/// <param name="idxFase"></param>
|
|
/// <returns></returns>
|
|
public bool isCurrentCC(int idxFase)
|
|
{
|
|
bool answ = false;
|
|
string CapoCommessa = "";
|
|
try
|
|
{
|
|
CapoCommessa = DataProxy_ProjEts.DP.taDC.GetData(idxFase)[0].CapoCommessa;
|
|
}
|
|
catch
|
|
{ }
|
|
if (user_std.UtSn.NomeCognome == CapoCommessa || user_std.UtSn.CognomeNome == CapoCommessa)
|
|
{
|
|
answ = true;
|
|
}
|
|
return answ;
|
|
}
|
|
|
|
/// <summary>
|
|
/// restituisce true se è presente in cache l'oggetto richiesto
|
|
/// </summary>
|
|
/// <param name="nomeVar"></param>
|
|
/// <returns></returns>
|
|
public bool isInCacheObject(string nomeVar)
|
|
{
|
|
bool answ = false;
|
|
bool stringAnsw = false;
|
|
// cerco di fare cast a stringa...
|
|
try
|
|
{
|
|
stringAnsw = (string)HttpContext.Current.Cache[nomeVar].ToString() != "";
|
|
}
|
|
catch
|
|
{ }
|
|
// infine condizione doppia...
|
|
try
|
|
{
|
|
answ = (HttpContext.Current.Cache[nomeVar] != null && stringAnsw);
|
|
}
|
|
catch
|
|
{ }
|
|
return answ;
|
|
}
|
|
|
|
/// <summary>
|
|
/// restituisce true se è presente in session l'oggetto richiesto
|
|
/// </summary>
|
|
/// <param name="nomeVar"></param>
|
|
/// <returns></returns>
|
|
public bool isInSessionObject(string nomeVar)
|
|
{
|
|
bool answ = false;
|
|
bool stringAnsw = false;
|
|
// cerco di fare cast a stringa...
|
|
try
|
|
{
|
|
if (HttpContext.Current.Session != null && HttpContext.Current.Session[nomeVar] != null)
|
|
{
|
|
stringAnsw = !string.IsNullOrEmpty($"{HttpContext.Current.Session[nomeVar]}");
|
|
//stringAnsw = (string)HttpContext.Current.Session[nomeVar].ToString() != "";
|
|
}
|
|
}
|
|
catch
|
|
{ }
|
|
// infine condizione doppia...
|
|
try
|
|
{
|
|
answ = (HttpContext.Current.Session[nomeVar] != null && stringAnsw);
|
|
}
|
|
catch
|
|
{ }
|
|
return answ;
|
|
}
|
|
|
|
/// <summary>
|
|
/// carica dalla sessione un dato di tipo long
|
|
/// </summary>
|
|
/// <param name="nomeVar"></param>
|
|
/// <returns></returns>
|
|
public long LongSessionObj(string nomeVar)
|
|
{
|
|
if (HttpContext.Current.Session[nomeVar] != null)
|
|
{
|
|
return (long)Convert.ToInt32(HttpContext.Current.Session[nomeVar].ToString());
|
|
}
|
|
else
|
|
{
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// carica dalla Cache un dato di tipo object generico
|
|
/// </summary>
|
|
/// <param name="nomeVar"></param>
|
|
/// <returns></returns>
|
|
public object objCacheObj(string nomeVar)
|
|
{
|
|
if (HttpContext.Current.Cache[nomeVar] != null)
|
|
{
|
|
return HttpContext.Current.Cache[nomeVar];
|
|
}
|
|
else
|
|
{
|
|
return "";
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// carica dalla sessione un dato di tipo object generico
|
|
/// </summary>
|
|
/// <param name="nomeVar"></param>
|
|
/// <returns></returns>
|
|
public object objSessionObj(string nomeVar)
|
|
{
|
|
if (HttpContext.Current.Session[nomeVar] != null)
|
|
{
|
|
return HttpContext.Current.Session[nomeVar];
|
|
}
|
|
else
|
|
{
|
|
return "";
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// recupera valore querystring BOOL
|
|
/// </summary>
|
|
/// <param name="nome"></param>
|
|
/// <returns>valore string</returns>
|
|
public bool QSB(string nome)
|
|
{
|
|
bool answ = false;
|
|
try
|
|
{
|
|
answ = Convert.ToBoolean(HttpContext.Current.Request.QueryString[nome]);
|
|
}
|
|
catch
|
|
{ }
|
|
return answ;
|
|
}
|
|
|
|
/// <summary>
|
|
/// recupera valore querystring DATE
|
|
/// </summary>
|
|
/// <param name="nome"></param>
|
|
/// <returns>valore DATE</returns>
|
|
public DateTime QSD(string nome)
|
|
{
|
|
DateTime answ = DateTime.Now;
|
|
try
|
|
{
|
|
answ = Convert.ToDateTime(HttpContext.Current.Request.QueryString[nome]);
|
|
}
|
|
catch
|
|
{ }
|
|
return answ;
|
|
}
|
|
|
|
/// <summary>
|
|
/// recupera valore querystring INT
|
|
/// </summary>
|
|
/// <param name="nome"></param>
|
|
/// <returns>valore INT</returns>
|
|
public int QSI(string nome)
|
|
{
|
|
int answ = 0;
|
|
try
|
|
{
|
|
answ = Convert.ToInt32(HttpContext.Current.Request.QueryString[nome]);
|
|
}
|
|
catch
|
|
{ }
|
|
return answ;
|
|
}
|
|
|
|
/// <summary>
|
|
/// recupera valore querystring STRING
|
|
/// </summary>
|
|
/// <param name="nome"></param>
|
|
/// <returns>valore string</returns>
|
|
public string QSS(string nome)
|
|
{
|
|
string answ = "";
|
|
try
|
|
{
|
|
answ = HttpContext.Current.Request.QueryString[nome].ToString().Trim();
|
|
}
|
|
catch
|
|
{ }
|
|
return answ;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Elimina una key (hash, string)
|
|
/// </summary>
|
|
/// <param name="key"></param>
|
|
/// <returns></returns>
|
|
public bool redDelKey(string key)
|
|
{
|
|
bool answ = false;
|
|
// cerco se ci sia valore in redis...
|
|
IDatabase cache = connRedis.GetDatabase();
|
|
try
|
|
{
|
|
RedisKey chiave = key;
|
|
cache.KeyDelete(chiave);
|
|
answ = true;
|
|
}
|
|
catch
|
|
{ }
|
|
return answ;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Flush completo cache redis
|
|
/// </summary>
|
|
/// <param name="keyPattern">** = tutti</param>
|
|
/// <returns></returns>
|
|
public bool redFlushKey(string keyPattern)
|
|
{
|
|
bool answ = false;
|
|
// cerco se ci sia valore in redis...
|
|
IDatabase cache = connRedis.GetDatabase();
|
|
// se vuoto = ALL...
|
|
keyPattern = keyPattern == "" ? "**" : keyPattern;
|
|
try
|
|
{
|
|
foreach (var ep in connRedis.GetEndPoints())
|
|
{
|
|
var server = connRedis.GetServer(ep);
|
|
foreach (var key in server.Keys(pattern: keyPattern))
|
|
{
|
|
cache.KeyDelete(key);
|
|
}
|
|
}
|
|
answ = true;
|
|
}
|
|
catch (Exception exc)
|
|
{
|
|
utils.lg.Error(string.Format("{0}", exc));
|
|
}
|
|
return answ;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Recupera tutti i valori dalla hash
|
|
/// </summary>
|
|
/// <param name="hashKey"></param>
|
|
/// <returns></returns>
|
|
public KeyValuePair<string, string>[] redGetHash(string hashKey)
|
|
{
|
|
KeyValuePair<string, string>[] answ = new KeyValuePair<string, string>[1];
|
|
// cerco se ci sia valore in redis...
|
|
IDatabase cache = connRedis.GetDatabase();
|
|
try
|
|
{
|
|
RedisKey chiave = hashKey;
|
|
HashEntry[] valori = cache.HashGetAll(chiave);
|
|
answ = new KeyValuePair<string, string>[valori.Length];
|
|
int i = 0;
|
|
foreach (HashEntry item in valori)
|
|
{
|
|
answ[i] = new KeyValuePair<string, string>(item.Name, item.Value);
|
|
i++;
|
|
}
|
|
}
|
|
catch
|
|
{ }
|
|
return answ;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Nome della variabile HASH da utilizzare dato CodModulo + keyName richiesto...
|
|
/// </summary>
|
|
public string redHash(string keyName)
|
|
{
|
|
string answ = keyName;
|
|
try
|
|
{
|
|
answ = $"{confReadString("CodModulo")}:{keyName}".Replace("\\", "_").Replace(" ", "_");
|
|
}
|
|
catch
|
|
{ }
|
|
return answ;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Verifica se ci siano valori nella hash indicata...
|
|
/// </summary>
|
|
/// <param name="key"></param>
|
|
/// <returns></returns>
|
|
public bool redHashPresent(RedisKey key)
|
|
{
|
|
bool answ = false;
|
|
// cerco se ci sia valore in redis...
|
|
IDatabase cache = connRedis.GetDatabase();
|
|
try
|
|
{
|
|
answ = cache.HashGetAll(key).Length > 0;
|
|
}
|
|
catch
|
|
{ }
|
|
return answ;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Salvataggio di una hash di valori
|
|
/// </summary>
|
|
/// <param name="hashKey"></param>
|
|
/// <param name="hashFields"></param>
|
|
/// <returns></returns>
|
|
public bool redSaveHash(string hashKey, KeyValuePair<string, string>[] hashFields)
|
|
{
|
|
bool answ = false;
|
|
// cerco se ci sia valore in redis...
|
|
IDatabase cache = connRedis.GetDatabase();
|
|
try
|
|
{
|
|
RedisKey chiave = hashKey;
|
|
HashEntry[] valori = new HashEntry[hashFields.Length];
|
|
int i = 0;
|
|
foreach (KeyValuePair<string, string> kvp in hashFields)
|
|
{
|
|
valori[i] = new HashEntry(kvp.Key, kvp.Value);
|
|
i++;
|
|
}
|
|
cache.HashSet(chiave, valori);
|
|
answ = true;
|
|
}
|
|
catch
|
|
{ }
|
|
return answ;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Resetta (elimina) un contatore in Redis
|
|
/// </summary>
|
|
/// <param name="chiave"></param>
|
|
/// <returns></returns>
|
|
public bool resetRCnt(string chiave)
|
|
{
|
|
bool answ = false;
|
|
try
|
|
{
|
|
IDatabase cache = connRedis.GetDatabase();
|
|
answ = cache.KeyDelete(chiave);
|
|
}
|
|
catch (Exception exc)
|
|
{
|
|
utils.lg.Error(string.Format("Errore in resetRCnt:{0}{1}", Environment.NewLine, exc));
|
|
}
|
|
return answ;
|
|
}
|
|
|
|
/// <summary>
|
|
/// inserisce in Cache un valore
|
|
/// </summary>
|
|
/// <param name="nome">nome della variabile</param>
|
|
/// <param name="valore">valore</param>
|
|
public bool setCacheVal(string nome, object valore)
|
|
{
|
|
bool _done = false;
|
|
try
|
|
{
|
|
HttpContext.Current.Cache[nome] = valore;
|
|
_done = true;
|
|
}
|
|
catch
|
|
{ }
|
|
return _done;
|
|
}
|
|
|
|
/// <summary>
|
|
/// inserisce in Cache un valore e su richiesta regitra tra le tab in cache da svuotare on update..
|
|
/// </summary>
|
|
/// <param name="nome">nome della variabile</param>
|
|
/// <param name="valore">valore</param>
|
|
/// <param name="setInTabInCache">da registrare come tabella da svuotare on update</param>
|
|
/// <returns></returns>
|
|
public bool setCacheVal(string nome, object valore, bool setInTabInCache)
|
|
{
|
|
bool _done = setCacheVal(nome, valore);
|
|
if (setInTabInCache)
|
|
{
|
|
addTabInCache(nome);
|
|
}
|
|
return _done;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Decrementa un contatore in Redis
|
|
/// </summary>
|
|
/// <param name="chiave"></param>
|
|
/// <returns></returns>
|
|
public long setRCntD(string chiave)
|
|
{
|
|
long answ = 0;
|
|
try
|
|
{
|
|
IDatabase cache = connRedis.GetDatabase();
|
|
answ = cache.StringDecrement(chiave, 1);
|
|
}
|
|
catch (Exception exc)
|
|
{
|
|
utils.lg.Error(string.Format("Errore in setRCD:{0}{1}", Environment.NewLine, exc));
|
|
}
|
|
return answ;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Incrementa un contatore in Redis
|
|
/// </summary>
|
|
/// <param name="chiave"></param>
|
|
/// <returns></returns>
|
|
public long setRCntI(string chiave)
|
|
{
|
|
long answ = 0;
|
|
try
|
|
{
|
|
IDatabase cache = connRedis.GetDatabase();
|
|
answ = cache.StringIncrement(chiave, 1);
|
|
}
|
|
catch (Exception exc)
|
|
{
|
|
utils.lg.Error(string.Format("Errore in setRCI:{0}{1}", Environment.NewLine, exc));
|
|
}
|
|
return answ;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Salva un set KVP (Key Value Pair) in RedisCache
|
|
/// </summary>
|
|
/// <param name="valori">Set KVP chiave-valore da salvare</param>
|
|
/// <returns></returns>
|
|
public bool setRKeys(KeyValuePair<RedisKey, RedisValue>[] valori)
|
|
{
|
|
bool answ = false;
|
|
try
|
|
{
|
|
IDatabase cache = connRedis.GetDatabase();
|
|
cache.StringSet(valori);
|
|
answ = true;
|
|
}
|
|
catch (Exception exc)
|
|
{
|
|
utils.lg.Error(string.Format("Errore in setRKeys:{0}{1}", Environment.NewLine, exc));
|
|
}
|
|
return answ;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Salva una chiave in RedisCache
|
|
/// </summary>
|
|
/// <param name="chiave"></param>
|
|
/// <param name="valore"></param>
|
|
/// <returns></returns>
|
|
public bool setRSV(string chiave, string valore)
|
|
{
|
|
bool answ = false;
|
|
try
|
|
{
|
|
IDatabase cache = connRedis.GetDatabase();
|
|
cache.StringSet(chiave, valore);
|
|
answ = true;
|
|
}
|
|
catch (Exception exc)
|
|
{
|
|
utils.lg.Error(string.Format("Errore in setRSV:{0}{1}", Environment.NewLine, exc));
|
|
}
|
|
return answ;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Salva una chiave in RedisCache
|
|
/// </summary>
|
|
/// <param name="chiave"></param>
|
|
/// <param name="valore"></param>
|
|
/// <param name="TTL_sec">in secondi</param>
|
|
/// <returns></returns>
|
|
public bool setRSV(string chiave, string valore, int TTL_sec)
|
|
{
|
|
bool answ = false;
|
|
try
|
|
{
|
|
TimeSpan expT = new TimeSpan(0, 0, TTL_sec);
|
|
// salvo con expiry...
|
|
IDatabase cache = connRedis.GetDatabase();
|
|
cache.StringSet(chiave, valore, expT);
|
|
answ = true;
|
|
}
|
|
catch (Exception exc)
|
|
{
|
|
utils.lg.Error($"Errore in setRSV | chiave: {chiave} | valore: {valore} | TTL: {TTL_sec}{Environment.NewLine}{exc}");
|
|
}
|
|
return answ;
|
|
}
|
|
|
|
/// <summary>
|
|
/// inserisce in session un valore
|
|
/// </summary>
|
|
/// <param name="nome"></param>
|
|
/// <param name="valore"></param>
|
|
public bool setSessionVal(string nome, object valore)
|
|
{
|
|
bool _done = false;
|
|
try
|
|
{
|
|
HttpContext.Current.Session[nome] = valore;
|
|
_done = true;
|
|
}
|
|
catch
|
|
{ }
|
|
return _done;
|
|
}
|
|
|
|
/// <summary>
|
|
/// carica dalla Cachee un dato di tipo string
|
|
/// </summary>
|
|
/// <param name="nomeVar"></param>
|
|
/// <returns></returns>
|
|
public string StringCacheObj(string nomeVar)
|
|
{
|
|
if (HttpContext.Current.Cache[nomeVar] != null)
|
|
{
|
|
return HttpContext.Current.Cache[nomeVar].ToString();
|
|
}
|
|
else
|
|
{
|
|
return "";
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// carica dalla sessione un dato di tipo string
|
|
/// </summary>
|
|
/// <param name="nomeVar"></param>
|
|
/// <returns></returns>
|
|
public string StringSessionObj(string nomeVar)
|
|
{
|
|
if (HttpContext.Current.Session[nomeVar] != null)
|
|
{
|
|
return HttpContext.Current.Session[nomeVar].ToString();
|
|
}
|
|
else
|
|
{
|
|
return "";
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// WRAPPER 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)
|
|
{
|
|
return user_std.UtSn.userHasRight(utenteAD, codModulo, codFunzione);
|
|
}
|
|
|
|
#endregion Public Methods
|
|
|
|
#region Public Classes
|
|
|
|
/// <summary>
|
|
/// classe di gestione delle email
|
|
/// </summary>
|
|
public class gestEmail
|
|
{
|
|
#region Protected Fields
|
|
|
|
/// <summary>
|
|
/// stringa pwd x server SMTP
|
|
/// </summary>
|
|
protected string _password;
|
|
|
|
/// <summary>
|
|
/// stringa del nome DNS o dell'ip del server SMTP
|
|
/// </summary>
|
|
protected string _smtpCli;
|
|
|
|
/// <summary>
|
|
/// stringa username x server SMTP
|
|
/// </summary>
|
|
protected string _username;
|
|
|
|
protected Logger lg = LogManager.GetCurrentClassLogger();
|
|
|
|
#endregion Protected Fields
|
|
|
|
#region Public Fields
|
|
|
|
/// <summary>
|
|
/// metodo singleton gestione email...
|
|
/// </summary>
|
|
public static gestEmail ge = new gestEmail(utils.obj.confReadString("_smtpCli"));
|
|
|
|
/// <summary>
|
|
/// metodo singleton gestione email CON AUTH utente...
|
|
/// </summary>
|
|
public static gestEmail geAuth = new gestEmail(utils.obj.confReadString("_smtpCli"), utils.obj.confReadString("_emailUser"), utils.obj.confReadString("_emailPwd"));
|
|
|
|
#endregion Public Fields
|
|
|
|
#region Public Constructors
|
|
|
|
/// <summary>
|
|
/// metodo static per la gestione delle email
|
|
/// </summary>
|
|
/// <param name="smtpCli"></param>
|
|
public gestEmail(string smtpCli)
|
|
{
|
|
lg.Info("[Modulo gestEmail]: avviato con parametro smtp {0}", smtpCli);
|
|
_smtpCli = smtpCli;
|
|
_username = "";
|
|
_password = "";
|
|
}
|
|
|
|
/// <summary>
|
|
/// metodo static per la gestione delle email
|
|
/// </summary>
|
|
/// <param name="smtpCli"></param>
|
|
/// <param name="user"></param>
|
|
/// <param name="pwd"></param>
|
|
public gestEmail(string smtpCli, string user, string pwd)
|
|
{
|
|
lg.Info("[Modulo gestEmail]: avviato con parametro smtp {0} ed utente {1}", smtpCli, user);
|
|
_smtpCli = smtpCli;
|
|
_username = user;
|
|
_password = pwd;
|
|
}
|
|
|
|
/// <summary>
|
|
/// metodo static per la gestione delle email
|
|
/// </summary>
|
|
/// <param name="smtpCli"></param>
|
|
/// <param name="logDir"></param>
|
|
public gestEmail(string smtpCli, string logDir)
|
|
{
|
|
lg.Info("[Modulo gestEmail]: avviato con parametro smtp {0} e logdir {1}", smtpCli, logDir);
|
|
_smtpCli = smtpCli;
|
|
_username = "";
|
|
_password = "";
|
|
}
|
|
|
|
#endregion Public Constructors
|
|
|
|
#region Public Methods
|
|
|
|
/// <summary>
|
|
/// procedura invio email + scrittura in log!
|
|
/// </summary>
|
|
/// <param name="_mailFrom">email mittente</param>
|
|
/// <param name="_mailTo">email destinatario</param>
|
|
/// <param name="_oggetto">oggetto dell'email</param>
|
|
/// <param name="_corpo">corpo del messaggio</param>
|
|
public bool mandaEmail(string _mailFrom, string _mailTo, string _oggetto, string _corpo)
|
|
{
|
|
bool fatto = false;
|
|
//manda email...
|
|
try
|
|
{
|
|
fatto = mandaEmailNoLog(_mailFrom, _mailTo, _oggetto, _corpo);
|
|
lg.Info("Email inviata: oggetto: {0}, corpo: {1}", _oggetto, _corpo);
|
|
}
|
|
catch (Exception exc)
|
|
{
|
|
lg.Error($"ERRORE! Email NON INVIATA!oggetto: {_oggetto} corpo: {_corpo} eccezione:{Environment.NewLine}{exc}");
|
|
}
|
|
return fatto;
|
|
}
|
|
|
|
/// <summary>
|
|
/// procedura invio email
|
|
/// </summary>
|
|
/// <param name="_mailFrom">email mittente</param>
|
|
/// <param name="_mailTo">email destinatario</param>
|
|
/// <param name="_oggetto">oggetto dell'email</param>
|
|
/// <param name="_corpo">corpo del messaggio</param>
|
|
public bool mandaEmailNoLog(string _mailFrom, string _mailTo, string _oggetto, string _corpo)
|
|
{
|
|
//manda email...
|
|
MailMessage messaggio = new MailMessage(_mailFrom, _mailTo, _oggetto, _corpo);
|
|
messaggio.IsBodyHtml = true;
|
|
SmtpClient _smtpClient = new SmtpClient(_smtpCli);
|
|
// se ci sono credenziali utente...
|
|
if (_username != "")
|
|
{
|
|
_smtpClient.Credentials = new System.Net.NetworkCredential(_username, _password);
|
|
_smtpClient.EnableSsl = utils.obj.confReadBool("_enableSSL");
|
|
}
|
|
try
|
|
{
|
|
_smtpClient.Send(messaggio);
|
|
return true;
|
|
}
|
|
catch (SmtpException esmtp)
|
|
{
|
|
Console.WriteLine("{0}", esmtp.Message);
|
|
Console.WriteLine("Here is the full error message output");
|
|
Console.Write("{0}", esmtp.ToString());
|
|
lg.Error($"{esmtp.Message}{Environment.NewLine}full error message:{Environment.NewLine}{esmtp}");
|
|
return false;
|
|
}
|
|
}
|
|
|
|
#endregion Public Methods
|
|
}
|
|
|
|
#endregion Public Classes
|
|
}
|
|
} |