using System;
using System.Data;
using System.Data.OracleClient;
using System.Data.Common;
using System.Collections.Generic;
using Microsoft.Practices.EnterpriseLibrary.Data;
using Microsoft.Practices.EnterpriseLibrary.Data.Oracle;
using Microsoft.Practices.EnterpriseLibrary.Data.Sql;
using System.Data.SqlClient;
using NLog;
using DataAccessLayer;
using System.Globalization;
using System.Linq;
using System.Collections.Concurrent;
using System.Configuration;
using System.IO;
using System.Net;
using System.Dynamic;
using System.Reflection;
using System.Runtime.InteropServices;
using System.Diagnostics;
using System.Threading;
using System.Drawing.Imaging;
using System.Drawing;
using System.Text;
using System.Security.Cryptography;
using ceTe.DynamicPDF.PageElements;
using System.ComponentModel;
namespace NLog
{
#pragma warning disable CS0168
public static class NLogEx
{
public static void WriteToConsole(this Logger logger, string msg)
{
try
{
if (msg != null && msg.Trim() != string.Empty)
Console.WriteLine(msg);
}
catch (Exception ex2)
{
}
}
public static void Infos(this Logger logger, string msg)
{
if (!CACHE.OnlyError)
{
try
{
//var s = Pre();
if (msg != null && msg.Trim() != string.Empty)
{
//if (CACHE.LANCIO != "") msg = CACHE.LANCIO + "|" + msg;
logger.Info(msg);
}
}
catch (Exception ex1)
{
}
}
}
public static void Errors(this Logger logger, Exception ex)
{
try
{
//var s = Pre();
if (ex != null)
{
//string msg = ex.Message;
//if (CACHE.LANCIO != "") msg = CACHE.LANCIO + "|" + msg;
logger.Error(ex.Message + "|" + ex.StackTrace);
}
}
catch (Exception ex1)
{
}
}
public static void Errors(this Logger logger, string msg)
{
try
{
//var s = Pre();
if (msg != null && msg.Trim().Length > 0)
{
//if (CACHE.LANCIO != "") msg = CACHE.LANCIO + "|" + msg;
logger.Error(msg);
}
}
catch (Exception ex1)
{
}
}
public static void Debugs(this Logger logger, string msg)
{
if (!CACHE.OnlyError)
{
try
{
//var s = Pre();
if (msg != null && msg.Trim() != string.Empty)
{
//if (CACHE.LANCIO != "") msg = CACHE.LANCIO + "|" + msg;
logger.Debug(msg);
}
}
catch (Exception ex1)
{
}
}
}
public static void Traces(this Logger logger, string msg)
{
if (!CACHE.OnlyError)
{
try
{
//var s = Pre();
if (msg != null && msg.Trim() != string.Empty)
{
//if (CACHE.LANCIO != "") msg = CACHE.LANCIO + "|" + msg;
logger.Trace(msg);
}
}
catch (Exception ex1)
{
}
}
}
private static string Pre()
{
string ret = string.Empty;
//var a1 = Assembly.GetCallingAssembly();
//var a2 = Assembly.GetExecutingAssembly();
var a3 = Assembly.GetEntryAssembly();
//ret += a3.GetName().Name;
var expt = a3.GetExportedTypes();
if (expt != null && expt.Length > 0)
{
var st1 = expt[0].FullName;
ret += st1;
StackTrace st = new StackTrace(true);
var st2 = st.GetFrames();
int l = (st2!=null ? st2.Length : 0);
StackFrame mx = null;
if (l>0)
{
mx = st.GetFrame(l - 1);
MethodBase ml = mx.GetMethod();
ret += "." + ml.Name;
ret += "(" + mx.GetFileLineNumber() + ")";
}
//MethodBase m = st.GetFrame(1).GetMethod();
//var clc = m.DeclaringType.FullName;
}
return ret;
}
}
}
namespace System
{
#pragma warning disable CS0168
public struct StructColor
{
private Int16 _red;
private Int16 _blue;
private Int16 _green;
private string _tipo;
private string _codice;
private string _descrizione;
// Red
public Int16 Red
{
get { return _red; }
set { _red = value; }
}
// Green
public Int16 Green
{
get { return _green; }
set { _green = value; }
}
// Blue
public Int16 Blue
{
get { return _blue; }
set { _blue = value; }
}
// Tipo
public string Tipo
{
get { return _tipo; }
set { _tipo = value; }
}
// Codice
public string Codice
{
get { return _codice; }
set { _codice = value; }
}
// Descrizione
public string Descrizione
{
get { return _descrizione; }
set { _descrizione = value; }
}
}
public enum TipoContratto:Int32
{
[Category("Sei")]
[Description("Old")]
Old = 0,
[Category("Sei")]
[Description("Affluent")]
Affluent = 1,
[Category("Sei")]
[Description("Private")]
Private = 2,
[Category("DA")]
[Description("Dadvisory")]
Dadvisory = 3
}
///
/// Enumeratore del tipo di Report.
///
public enum TipologiaReport
{
DIAGNOSI,
PROPOSTA,
PIANIFICAZIONE,
MONITORAGGIO
}
public class ReportTipo
{
#region private member
private int _idReport;
private int _idModello;
private string _descrizione;
private TipologiaReport _tipoReport;
#endregion
#region public member
public int IdReport
{
get { return _idReport; }
set { _idReport = value; }
}
public int IdModello
{
get { return _idModello; }
set { _idModello = value; }
}
public string Descrizione
{
get { return _descrizione; }
set { _descrizione = value; }
}
public TipologiaReport TipoReport
{
get { return _tipoReport; }
set { _tipoReport = value; }
}
#endregion
public ReportTipo(int idReport, int idModello, string descrizione, TipologiaReport tipoReport)
{
_idReport = idReport;
_idModello = idModello;
_descrizione = descrizione;
_tipoReport = tipoReport;
}
public ReportTipo()
: this(-1, -1, "", TipologiaReport.DIAGNOSI)
{
}
}
public class DataThreadModel : ICloneable
{
#region private members
private string _rete;
private string _nomeRete;
private string _agente;
private string _cognomeAgente;
private string _nomeAgente;
private string _indirizzoAgente;
private string _capAgente;
private string _cittaAgente;
private string _telefonoAgente;
private string _codiceFiscale;
private string _cognomeCliente;
private string _nomeCliente;
private string _tipoReport;
private string _dataLotto;
private bool _profiloIsAct;
private string _intermediario;
private string _area;
private string _areaestesa;
private string _progetto;
private int _idReportPDFDiagnosi;
private int _idReportPDFMonitoraggio;
private decimal _patrimoniocomplessivototalectv;
private decimal _patrimoniofinanziarioctv;
private decimal _patrimoniobancafideuramctv;
private decimal _patrimoniobancafideuramctvalnettocontocorrente;
private decimal _patrimonioterzictv;
private decimal _patrimonioterzicontocorrente;
private decimal _patrimonioterzictvalnettocontocorrente;
private decimal _patrimonioimmobiliarectv;
private decimal _patrimonioaltroctv;
private decimal _contoCorrente;
private decimal _partiteviaggiantiinvestimento;
private decimal _partiteviaggiantidisinvestimento;
private decimal _patrimonioNonRappresentabileAI;
private decimal _patrimonioNonRappresentabileCompl;
private decimal _patrimonioNonRappresentabileFI;
private decimal _patrimonioNonRappresentabile;
private decimal _risorseNonAssociate;
private int _numeroIntermediari;
private bool adesioneSuccessivaAvanzato;
private bool generaDiagnosi;
private decimal _totaleS6;
private decimal _totaleS57;
private bool periodico;
private string _CodiceContratto;
private decimal _varrisorsenonassociate;
private decimal _coperturarisorsenonassociate;
private decimal _vartotalerisorsefinanziarie;
private decimal _coperturatotalerisorsefinanziarie;
private string _flgprof;
private decimal _totalNegativeCurrentAccountValue;
private decimal _totalSelfNegCurrentAccountValue;
private decimal _GPEligoFondi;
private decimal _GPEligoTitoli;
private decimal _GradoCoperturaMacroAssetInterno;
private decimal _GradoCoperturaMacroAssetTotale;
private decimal _GradoCoperturaMacroAssetAltri;
private string _codice;
private bool _HasProdottiAltaComplessita;
private DateTime _datafinetrimestrecorrente;
private DateTime _dataFineTrimestreCorrente_LetteraAccompagnamento;
//private List> _selfNegativeValue;
private string _ultimaSezioneStampata;
#endregion
public DataThreadModel()
{
Agente = "";
Area = "";
AreaEstesa = "";
CapAgente = "";
CittaAgente = "";
CodiceFiscale = "";
CognomeAgente = "";
CognomeCliente = "";
IndirizzoAgente = "";
Intermediario = "";
NomeAgente = "";
NomeCliente = "";
NomeRete = "";
Rete = "";
TelefonoAgente = "";
TipoReport = "";
VaRRisorseNonAssociate = 0;
CoperturaRisorseNonAssociate = 0;
PatrimonioTerziContoCorrente = 0;
IsAdequatezza = null;
IsSavingMap = false;
IsAPC103 = false;
}
#region public members
public int NumeroIntermediari
{
get { return _numeroIntermediari; }
set { _numeroIntermediari = value; }
}
///
/// Imposta o recupera il controvalore totale delle risorse non associate.
///
public decimal RisorseNonAssociate
{
get { return _risorseNonAssociate; }
set { _risorseNonAssociate = value; }
}
public decimal TotaleS57
{
get { return _totaleS57; }
set { _totaleS57 = value; }
}
public decimal TotaleS6
{
get { return _totaleS6; }
set { _totaleS6 = value; }
}
public bool HasProdottiAltaComplessita
{
get { return _HasProdottiAltaComplessita; }
set { _HasProdottiAltaComplessita = value; }
}
///
/// Imposta o recupera un indicatore booleano che indica se va generato anche il report di DIAGNOSI per la fase2.
///
public bool GeneraDiagnosi
{
get { return generaDiagnosi; }
set { generaDiagnosi = value; }
}
public string Flgprof
{
get { return _flgprof; }
set { _flgprof = value; }
}
///
/// Imposta o recupera il nome del progetto d'investimento.
///
public String Progetto
{
get { return _progetto; }
set { _progetto = value; }
}
public bool ProfiloIsAct
{
get { return _profiloIsAct; }
set { _profiloIsAct = value; }
}
///
/// Imposta o recupera il controvalore del PatrimonioNonRappresentabile
///
public decimal PatrimonioNonRappresentabileAI
{
get { return _patrimonioNonRappresentabileAI; }
set { _patrimonioNonRappresentabileAI = value; }
}
public decimal PatrimonioNonRappresentabileCompl
{
get { return _patrimonioNonRappresentabileCompl; }
set { _patrimonioNonRappresentabileCompl = value; }
}
public decimal PatrimonioNonRappresentabileFI
{
get { return _patrimonioNonRappresentabileFI; }
set { _patrimonioNonRappresentabileFI = value; }
}
///
/// Imposta o recupera la somma delle Partite Viaggianti in investimento.
///
public decimal PartiteViaggiantiInvestimento
{
get { return _partiteviaggiantiinvestimento; }
set { _partiteviaggiantiinvestimento = value; }
}
///
/// Imposta o recupera la somma delle Partite Viaggianti in disinvestimento.
///
public decimal PartiteViaggiantiDisinvestimento
{
get { return _partiteviaggiantidisinvestimento; }
set { _partiteviaggiantidisinvestimento = value; }
}
///
/// Imposta o recupera il controvalore del Conto corrente.
///
public decimal ContoCorrente
{
get { return _contoCorrente; }
set { _contoCorrente = value; }
}
public decimal Patrimonioaltroctv
{
get { return _patrimonioaltroctv; }
set { _patrimonioaltroctv = value; }
}
///
/// Imposta o recupera il controvalore immobiliare totale.
///
public decimal Patrimonioimmobiliarectv
{
get { return _patrimonioimmobiliarectv; }
set { _patrimonioimmobiliarectv = value; }
}
///
/// Patrimonio terzi al netto del CC
///
public decimal PatrimonioterzictvAlNettoContoCorrente
{
get { return _patrimonioterzictvalnettocontocorrente; }
set { _patrimonioterzictvalnettocontocorrente = value; }
}
///
/// Imposta o recupera il controvalore totale detenuto presso istituti terzi.
///
public decimal Patrimonioterzictv
{
get { return _patrimonioterzictv; }
set { _patrimonioterzictv = value; }
}
///
/// Contocorrente altri istituti.
///
public decimal PatrimonioTerziContoCorrente
{
get { return _patrimonioterzicontocorrente; }
set { _patrimonioterzicontocorrente = value; }
}
public bool AdesioneSuccessivaAvanzato
{
get { return adesioneSuccessivaAvanzato; }
set { adesioneSuccessivaAvanzato = value; }
}
///
/// Imposta o recupera il controvalore totale del patrimonio detenuto presso BF o SPI
///
public decimal Patrimoniobancafideuramctv
{
get { return _patrimoniobancafideuramctv; }
set { _patrimoniobancafideuramctv = value; }
}
///
/// Patrimonio BF al netto del CC
///
public decimal PatrimonioBancaFideuramCtvAlNettoContoCorrente
{
get { return _patrimoniobancafideuramctvalnettocontocorrente; }
set { _patrimoniobancafideuramctvalnettocontocorrente = value; }
}
///
/// Imposta o recupera il controvalore del patrimonio finanziario
///
public decimal Patrimoniofinanziarioctv
{
get { return _patrimoniofinanziarioctv; }
set { _patrimoniofinanziarioctv = value; }
}
///
/// Imposta o recupera il controvalore del patrimonio complessivo
///
public decimal Patrimoniocomplessivototalectv
{
get { return _patrimoniocomplessivototalectv; }
set { _patrimoniocomplessivototalectv = value; }
}
///
/// Imposta o recupera la descrizione estesa dell'area di bisogno
///
public string AreaEstesa
{
get { return _areaestesa; }
set { _areaestesa = value; }
}
///
/// Imposta o recupera il codice di area di bisogno
///
public string Area
{
get { return _area; }
set { _area = value; }
}
///
/// Imposta o recupera il codice della rete
///
public string Rete
{
get { return _rete; }
set { _rete = value; }
}
///
/// Imposta o recupera la descrizione estesa della rete
///
public string NomeRete
{
get { return _nomeRete; }
set { _nomeRete = value; }
}
///
/// Imposta o recupera l'agente
///
public string Agente
{
get { return _agente; }
set { _agente = value; }
}
public string Flagnqp { get; set; }
public string Flagprlrde { get; set; }
public int Flagpg { get; set; }
public int RiskArea { get; set; }
///
/// Imposta o recupera il cognome dell'agente
///
public string CognomeAgente
{
get { return _cognomeAgente; }
set { _cognomeAgente = value; }
}
///
/// Imposta o recupera il nome dell'agente
///
public string NomeAgente
{
get { return _nomeAgente; }
set { _nomeAgente = value; }
}
///
/// Imposta o recupera l'indirizzo dell'agente
///
public string IndirizzoAgente
{
get { return _indirizzoAgente; }
set { _indirizzoAgente = value; }
}
///
/// Imposta o recupera il cap dell'agente
///
public string CapAgente
{
get { return _capAgente; }
set { _capAgente = value; }
}
///
/// Imposta o recupera la città dell'agente
///
public string CittaAgente
{
get { return _cittaAgente; }
set { _cittaAgente = value; }
}
///
/// Imposta o recupera la il telefono dell'agente
///
public string TelefonoAgente
{
get { return _telefonoAgente; }
set { _telefonoAgente = value; }
}
public string CodiceFiscale
{
get { return _codiceFiscale; }
set { _codiceFiscale = value; }
}
///
/// IdReport di Diagnosi del PdF generato su ReportManager
///
public int IdReportPDFDiagnosi
{
get { return _idReportPDFDiagnosi; }
set { _idReportPDFDiagnosi = value; }
}
///
/// IdReport di Monitoraggio del PdF generato su ReportManager
///
public int IdReportPDFMonitoraggio
{
get { return _idReportPDFMonitoraggio; }
set { _idReportPDFMonitoraggio = value; }
}
///
/// Imposta o recupera il cognome del cliente
///
public string CognomeCliente
{
get { return _cognomeCliente; }
set { _cognomeCliente = value; }
}
///
/// Imposta o recupera il nome del cliente
///
public string NomeCliente
{
get { return _nomeCliente; }
set { _nomeCliente = value; }
}
///
/// Imposta o recupera il tipo di report.
/// Attualemente si produzcono solo report per DIAGNOSI e MONITORAGGIO
///
public string TipoReport
{
get { return _tipoReport; }
set { _tipoReport = value; }
}
//public TipoContratto _tipoContratto;
//public TipoContratto TipoContratto
//{
// get { return _tipoContratto; }
// set { _tipoContratto = value; }
//}
private bool _contrattoOld;
public bool ContrattoOld
{
get { return _contrattoOld; }
set { _contrattoOld = value; }
}
private bool _noMonitoraggio;
public bool NoMonitoraggio
{
get { return _noMonitoraggio; }
set { _noMonitoraggio = value; }
}
public string Intermediario
{
get { return _intermediario; }
set { _intermediario = value; }
}
public string CodiceContratto
{
get { return _CodiceContratto; }
set { _CodiceContratto = value; }
}
public bool Periodico
{
get { return periodico; }
set { periodico = value; }
}
public string NomeFilePdf
{
get
{
return TipoReport + "_" + CodiceFiscale + "_" + Rete;
}
}
public string NomeFileReport
{
get
{
DateTime data = DateTime.Now;
return String.Concat(CodiceContratto, "_", data.ToString("yyyyMMdd", CultureInfo.InvariantCulture));
}
}
public string DataLotto
{
set { _dataLotto = value; }
get
{
if (_dataLotto == string.Empty)
_dataLotto = DateTime.Now.ToString("yyyyMMdd", CultureInfo.InvariantCulture);
return _dataLotto;
}
}
public bool SavedMap { get; set; } = false;
public decimal VaRRisorseNonAssociate
{
get { return _varrisorsenonassociate; }
set { _varrisorsenonassociate = value; }
}
public decimal CoperturaRisorseNonAssociate
{
get { return _coperturarisorsenonassociate; }
set { _coperturarisorsenonassociate = value; }
}
public decimal VaRTotaleRisorseFinanziarie
{
get { return _vartotalerisorsefinanziarie; }
set { _vartotalerisorsefinanziarie = value; }
}
public decimal CoperturaTotaleRisorseFinanziarie
{
get { return _coperturatotalerisorsefinanziarie; }
set { _coperturatotalerisorsefinanziarie = value; }
}
public DateTime DataFineTrimestreCorrente
{
get { return _datafinetrimestrecorrente; }
set { _datafinetrimestrecorrente = value; }
}
public DateTime DataFineTrimestreCorrente_LetteraAccompagnamento
{
get { return _dataFineTrimestreCorrente_LetteraAccompagnamento; }
set { _dataFineTrimestreCorrente_LetteraAccompagnamento = value; }
}
public decimal TotalNegativeCurrentAccountValue
{
get { return _totalNegativeCurrentAccountValue; }
set { _totalNegativeCurrentAccountValue = value; }
}
public decimal TotalSelfNegCurrentAccountValue
{
get { return _totalSelfNegCurrentAccountValue; }
set { _totalSelfNegCurrentAccountValue = value; }
}
public string UltimaSezioneStampata
{
get { return _ultimaSezioneStampata; }
set { _ultimaSezioneStampata = value; }
}
public decimal GPEligoFondi
{
get { return _GPEligoFondi; }
set { _GPEligoFondi = value; }
}
public decimal GPEligoTitoli
{
get { return _GPEligoTitoli; }
set { _GPEligoTitoli = value; }
}
public decimal GradoCoperturaMacroAssetTotale
{
get { return _GradoCoperturaMacroAssetTotale; }
set { _GradoCoperturaMacroAssetTotale = value; }
}
public decimal GradoCoperturaMacroAssetAltri
{
get { return _GradoCoperturaMacroAssetAltri; }
set { _GradoCoperturaMacroAssetAltri = value; }
}
public decimal GradoCoperturaMacroAssetInterno
{
get { return _GradoCoperturaMacroAssetInterno; }
set { _GradoCoperturaMacroAssetInterno = value; }
}
public string codice
{
get { return _codice; }
set { _codice = value; }
}
public bool IsCompleted { get; set; } = false;
public DataTable DtDSS6Intermediari { get; set; }
public bool? IsAdequatezza { get; set; }
public bool IsSavingMap { get; set; }
public bool IsAPC103 { get; set; }
public int Scaduto { get; set; }
public int TotalePagine { get; set; }
public byte[] Stream { get; set; }
#endregion
#region ICloneable Members
public object Clone()
{
return this.MemberwiseClone();
}
public decimal PatrimonioNonRappresentabile { get => _patrimonioNonRappresentabile; set => _patrimonioNonRappresentabile = value; }
public bool IsProfessionalClient
{
get
{
try
{
return (this.Flgprof == "S");
}
catch
{
return false;
}
}
}
#endregion
}
public class DataTemplate
{
public string rete { get; set; }
public int contracttype { get; set; }
public int reporttypefontcolor_r { get; set; }
public int reporttypefontcolor_g { get; set; }
public int reporttypefontcolor_b { get; set; }
public int chapterbackground_r { get; set; }
public int chapterbackground_g { get; set; }
public int chapterbackground_b { get; set; }
public int chapterfontcolor_r { get; set; }
public int chapterfontcolor_g { get; set; }
public int chapterfontcolor_b { get; set; }
public int tableheaderfontcolor_r { get; set; }
public int tableheaderfontcolor_g { get; set; }
public int tableheaderfontcolor_b { get; set; }
public string templatereportpath { get; set; }
public string templatecopertinapath { get; set; }
public string templateglossariopath { get; set; }
public string templatewelcomeletterpath { get; set; }
}
public class MinimalTrack
{
public string codicefiscale { get; set; }
public string rete { get; set; }
public string tipocontratto { get; set; }
public string SeiDa { get; set; }
}
public class RecuperoPDF
{
public string CodiceContratto { get; set; }
public string Rete { get; set; }
public string CodiceFiscale { get; set; }
public string NomeCliente { get; set; }
public string CognomeCliente { get; set; }
public string CodicePB { get; set; }
public string NomePB { get; set; }
public string CognomePB { get; set; }
public int numeroPagine { get; set; }
public byte[] Bytes { get; set; }
}
public static class SystemEx
{
public static List ConvertToList(this DataTable dt)
{
if (dt == null) return null;
const BindingFlags flags = BindingFlags.Public | BindingFlags.Instance;
var columnNames = dt.Columns.Cast()
.Select(c => c.ColumnName)
.ToList();
var objectProperties = typeof(T).GetProperties(flags);
var listrows = dt.Rows.Cast();
var targetList = listrows.Select(dataRow =>
{
var instanceOfT = Activator.CreateInstance();
foreach (var properties in objectProperties.Where(properties => columnNames.Contains(properties.Name) && dataRow[properties.Name] != DBNull.Value))
{
properties.SetValue(instanceOfT, dataRow[properties.Name], null);
}
return instanceOfT;
}).ToList();
return targetList;
}
[DllImport("Kernel32", EntryPoint = "GetCurrentThreadId", ExactSpelling = true)]
public static extern Int32 GetCurrentWin32ThreadId();
public static void SetThreadProcessorAffinity(this object th, int mId, int core, int cores) // params int[] cpus)
{
//https://www.codeproject.com/Articles/35679/Parallel-computing-and-processor-affinity-Never-un
if (mId > 0 && core < cores)
{
// Supports up to 64 processors
//double cpuMask = Math.Pow(2, logicalcpu);
//core = core ^ (1 << core);
long cpuMask = 0;
cpuMask |= 1L << core;
// Ensure managed thread is linked to OS thread; does nothing on default host in current .Net versions
Thread.BeginThreadAffinity();
// Find the ProcessThread for this thread.
var threads = Process.GetCurrentProcess().Threads.Cast();
ProcessThread thread = threads.Where(t => t.Id == mId).FirstOrDefault();
if (thread != null)
{
thread.ProcessorAffinity = new IntPtr(Convert.ToInt64(cpuMask));
thread.IdealProcessor = core;
}
Thread.EndThreadAffinity();
// Set the thread's processor affinity
}
}
public static int PageCount(this int elementscount, int pagesize)
{
return (int)Math.Ceiling((double)elementscount / pagesize);
}
public static string ToDBString(this object o)
{
if (!(o is System.DBNull) && (o != null))
return o.ToString();
else
return string.Empty;
}
public static uint ToUInt32(this object o, UInt32 defaultvalue = 0)
{
if (o == null) o = (object)defaultvalue;
try
{
Int32 io = Convert.ToInt32(o);
return (UInt32)(Math.Abs(io));
}
catch
{
return defaultvalue;
}
}
public static ulong ToUInt64(this object o, UInt64 defaultvalue = 0)
{
if (o == null) o = (object)defaultvalue;
try
{
Int64 io = Convert.ToInt64(o);
return (UInt64)(Math.Abs(io));
}
catch
{
return defaultvalue;
}
}
public static int ToInt32(this object o, int defaultvalue = 0)
{
if (o == null) o = (object)defaultvalue;
try
{
return Convert.ToInt32(o);
}
catch
{
return defaultvalue;
}
}
public static int ToByte(this object o, int defaultvalue = 0)
{
if (o == null) o = (object)defaultvalue;
try
{
return (Byte)(Convert.ToInt32(o) / 255);
}
catch
{
return defaultvalue;
}
}
public static int ToInt32(this string s, int defaultvalue = 0)
{
int ret = defaultvalue;
int.TryParse(s, out ret);
return ret;
}
public static double ToDouble(this string s, double defaultvalue = 0)
{
double ret = defaultvalue;
double.TryParse(s, out ret);
return ret;
}
public static string FilterNumericString(this string s, char[] ce)
{
string ret = string.Empty;
foreach (char c in s.ToCharArray())
{
int code = Convert.ToInt32(c);
if (code > 47 && code < 58)
ret += c;
foreach (char x in ce)
if ((char)code == x)
ret += (char)code;
}
return ret;
}
public static string FilterNumericString(this string s)
{
string ret = string.Empty;
foreach (char c in s.ToCharArray())
{
int code = Convert.ToInt32(c);
if (code > 47 && code < 58)
ret += c;
}
return ret;
}
public static int ToInt32b(this string s)
{
return s.FilterNumericString().ToInt32();
}
public static Int64 ToInt64b(this string s)
{
return s.FilterNumericString().ToInt64();
}
public static int uInt(this bool b)
{
if (b)
return 1;
else
return 0;
}
public static bool ToBool(this object o, bool defaultvalue = false)
{
bool ret = defaultvalue;
if (o != null)
try
{
ret = Convert.ToBoolean(o);
}
catch
{
ret = defaultvalue;
}
return ret;
}
public static Int64 ToInt64(this object o)
{
if (o == null) o = (object)0;
try
{
return Convert.ToInt64(o);
}
catch
{
return 0;
}
}
public static string TOString(this object o)
{
if (o == null) return "";
return o.ToString();
}
public static double ToDouble(this object o, double defaultvalue = 0)
{
if (o == null) o = (object)0;
try
{
return Convert.ToDouble(o);
}
catch
{
return defaultvalue;
}
}
public static decimal ToDecimal(this object o, decimal defaultvalue = 0)
{
if (o == null) o = (object)0;
try
{
return Convert.ToDecimal(o);
}
catch
{
return defaultvalue;
}
}
public static decimal ToDecimal(this double o)
{
return Convert.ToDecimal(o);
}
public static string LeftStr(this string value, int maxLength)
{
if (string.IsNullOrEmpty(value)) return value;
maxLength = Math.Abs(maxLength);
return (value.Length <= maxLength
? value
: value.Substring(0, maxLength)
);
}
public static string RightStr(this string value, int maxLength)
{
if (string.IsNullOrEmpty(value)) return value;
maxLength = Math.Abs(maxLength);
return (value.Length <= maxLength
? value
: value.Substring(value.Length - maxLength, maxLength)
);
}
public static string Serialize(this DataThreadModel model)
{
if (model == null) return string.Empty;
StringBuilder sb = new StringBuilder();
sb.Append("Agente" + "=" + model.Agente.TOString() + ";");
sb.Append("NomeAgente" + "=" + model.NomeAgente.TOString() + ";");
sb.Append("CognomeAgente" + "=" + model.CognomeAgente.TOString() + ";");
sb.Append("IndirizzoAgente" + "=" + model.IndirizzoAgente.TOString() + ";");
sb.Append("CittaAgente" + "=" + model.CittaAgente.TOString() + ";");
sb.Append("CapAgente" + "=" + model.CapAgente.TOString() + ";");
sb.Append("TelefonoAgente" + "=" + model.TelefonoAgente.TOString() + ";");
sb.Append("NomeCliente" + "=" + model.NomeCliente.TOString() + ";");
sb.Append("CognomeCliente" + "=" + model.CognomeCliente.TOString() + ";");
sb.Append("CodiceFiscale" + "=" + model.CodiceFiscale.TOString() + ";");
sb.Append("Rete" + "=" + model.Rete.TOString() + ";");
sb.Append("TipoReport" + "=" + model.TipoReport.TOString() + ";");
sb.Append("NomeRete" + "=" + model.NomeRete.TOString() + ";");
sb.Append("NomeFilePdf" + "=" + model.NomeFilePdf.TOString() + ";");
sb.Append("NomeFileReport" + "=" + model.NomeFileReport.TOString() + ";");
sb.Append("DataLotto" + "=" + model.DataLotto.TOString() + ";");
sb.Append("Intermediario" + "=" + model.Intermediario.TOString() + ";");
sb.Append("Scaduto" + "=" + model.Scaduto.TOString() + ";");
sb.Append("TotalePagine" + "=" + model.TotalePagine.TOString() + ";");
string ch = sb.ToString();
sb = null;
return ((new XDS(CACHE.PASSKEY)).Encrypt(ch));
}
public static IEnumerable ConvertToListT(this DataTable table)
{
if (table == null)
{
yield break;
}
foreach (DataRow row in table.Rows)
{
IDictionary dRow = new ExpandoObject();
foreach (DataColumn column in table.Columns)
{
var value = row[column.ColumnName];
dRow[column.ColumnName] = Convert.IsDBNull(value) ? null : value;
}
yield return dRow;
}
}
public static string InCommand(this string[] args, string command)
{
string ret = string.Empty;
if (args != null && args.Length > 0)
{
foreach (var arg in args)
{
if (arg.Contains("="))
{
var valori = arg.Split('=');
if (valori.Length == 2)
{
if (valori[0].ToLower() == command.ToLower())
{
ret = valori[1];
break;
}
}
}
}
}
return ret;
}
public static List GetPage(this List list, int page, int pagesize)
{
return list.Skip(page * pagesize).Take(pagesize).ToList();
}
public static string ChangeExtension(this string s, string newExtension)
{
if (newExtension.Length > 0)
{
return System.IO.Path.GetDirectoryName(s) + "\\" + System.IO.Path.GetFileNameWithoutExtension(s) + (newExtension.StartsWith(".") ? newExtension : (newExtension.Length > 0 ? "." : "") + newExtension);
}
else
{
return s;
}
}
public static class EnumHelper
{
public static string GetEnumDescription(int valore)
{
// string levelexp = EnumHelper.GetEnumDescription(l.ToInt32()).ToUpper();
Type type = typeof(T);
string value = Enum.GetName(type, valore);
var name = Enum.GetNames(type).Where(f => f.Equals(value, StringComparison.CurrentCultureIgnoreCase)).Select(d => d).FirstOrDefault();
if (name == null)
{
return string.Empty;
}
var field = type.GetField(name);
var customAttribute = field.GetCustomAttributes(typeof(DescriptionAttribute), false);
return customAttribute.Length > 0 ? ((DescriptionAttribute)customAttribute[0]).Description : name;
}
public static string GetEnumCategory(int valore)
{
// string levelexp = EnumHelper.GetEnumCategory(l.ToInt32()).ToUpper();
Type type = typeof(T);
string value = Enum.GetName(type, valore);
var name = Enum.GetNames(type).Where(f => f.Equals(value, StringComparison.CurrentCultureIgnoreCase)).Select(d => d).FirstOrDefault();
if (name == null)
{
return string.Empty;
}
var field = type.GetField(name);
var customAttribute = field.GetCustomAttributes(typeof(CategoryAttribute), false);
return customAttribute.Length > 0 ? ((CategoryAttribute)customAttribute[0]).Category : name;
}
}
}
public class KeyValue
{
public string key { get; set; }
public string value { get; set; }
public KeyValue()
{
}
public KeyValue(string Key, string Value)
{
key = Key;
value = Value;
}
}
public class dIMAGES
{
public const string IMAGESFILE = "IMAGES";
private Dictionary images = null;// new Dictionary();
public string FileImages { get; set; }
private string _defaultpath = System.IO.Path.Combine(Environment.CurrentDirectory, IMAGESFILE);
public dIMAGES()
{
if (File.Exists(_defaultpath))
{
FileImages = _defaultpath;
Read();
}
}
private void Read()
{
images = FileImages.ConvertToDictionary();
}
public System.IO.Stream Get(string key)
{
key = key.ToLower();
//key = key.Replace(".png", "");
try
{
return images[key];
}
catch (Exception ex)
{
return null;
}
}
}
public static class UtilityManager
{
public static string getAppSetting(string chiave)
{
if (ConfigurationManager.AppSettings[chiave] != null)
return ConfigurationManager.AppSettings[chiave];
return String.Empty;
}
}
}
namespace System.Drawing
{
public static class ImageExtender
{
public static string ImagePathToBase64(this string path, System.Drawing.Imaging.ImageFormat format)
{
var imagedata = File.ReadAllBytes(path);
var ms = new MemoryStream(imagedata);
System.Drawing.Image image = Image.FromStream(ms);
return image.ImageToBase64(format);
}
public static string ImageToBase64(this Image image, System.Drawing.Imaging.ImageFormat format)
{//Questo è il sistema corretto per trasformare una image passando da bitmap altrimenti si ha l'errore GDI+
using (var ms = new MemoryStream())
{
Bitmap bmp = new Bitmap(image);
bmp.Save(ms, format);
string base64String = Convert.ToBase64String(ms.ToArray());
return base64String;
}
}
public static Stream ImageToStream(this Image img, System.Drawing.Imaging.ImageFormat format)
{
var ms = new MemoryStream();
img.Save(ms, format);
return ms;
}
public static string Base64ToString(this string base64EncodedData)
{
var base64EncodedBytes = System.Convert.FromBase64String(base64EncodedData);
return System.Text.Encoding.UTF8.GetString(base64EncodedBytes);
}
public static string StringToBase64(this string plainText)
{
var plainTextBytes = System.Text.Encoding.UTF8.GetBytes(plainText);
return System.Convert.ToBase64String(plainTextBytes);
}
public static Image Base64ToImage(this string base64String)
{
try
{
byte[] imageBytes = Convert.FromBase64String(base64String);
// Convert byte[] to Image
using (var ms = new MemoryStream(imageBytes, 0, imageBytes.Length))
{
Image image = Image.FromStream(ms, true);
return image;
}
}
catch //(Exception ex)
{
return null;
}
}
public static string Image64(this object obj)
{
try
{
System.Drawing.Image bImg = obj as System.Drawing.Image;
System.Drawing.ImageConverter converter = new System.Drawing.ImageConverter();
return "data:image/png;base64, " + Convert.ToBase64String((byte[])converter.ConvertTo(bImg, typeof(byte[])));
}
catch //(Exception ex)
{
return string.Empty;
}
}
public static Dictionary ConvertToDictionary(this string filename)
{
Func ifmt = f =>
{
Imaging.ImageFormat retf = Imaging.ImageFormat.Gif;
string extension = System.IO.Path.GetExtension(f);
switch (extension.ToLower())
{
case ".jpg":
case ".jpeg":
retf = Imaging.ImageFormat.Jpeg;
break;
case ".bmp":
retf = Imaging.ImageFormat.Bmp;
break;
case ".png":
retf = Imaging.ImageFormat.Png;
break;
default:
break;
}
return retf;
};
var list = File.ReadAllLines(filename).ToList().OrderBy(y => y);
var ret = list.Distinct().Select((a) => new { a }).ToDictionary(x => x.a.Split(';')[0], x => x.a.Split(';')[1].Base64ToImage().ImageToStream(ifmt(x.a.Split(';')[0])));
return ret;
}
}
}
namespace System.Security.Cryptography
{
///
/// USO string c = (new XDS("passkey")).Encrypt("testo");
///
public class XDS : IDisposable
{
#region IDisposable Support
private bool disposedValue = false; // To detect redundant calls
protected virtual void Dispose(bool disposing)
{
if (!disposedValue)
{
if (disposing)
{
// dispose managed state (managed objects).
}
// free unmanaged resources (unmanaged objects) and override a finalizer below.
// set large fields to null.
disposedValue = true;
}
}
// override a finalizer only if Dispose(bool disposing) above has code to free unmanaged resources.
// ~Xds() {
// // Do not change this code. Put cleanup code in Dispose(bool disposing) above.
// Dispose(false);
// }
// This code added to correctly implement the disposable pattern.
public void Dispose()
{
// Do not change this code. Put cleanup code in Dispose(bool disposing) above.
Dispose(true);
// uncomment the following line if the finalizer is overridden above.
// GC.SuppressFinalize(this);
}
#endregion
public XDS(string keY)
{
key = keY;
}
public string key { get; set; }
public string Encrypt(string toEncrypt, bool useHashing = true)
{
byte[] keyArray;
byte[] toEncryptArray = UTF8Encoding.UTF8.GetBytes(toEncrypt);
//System.Configuration.AppSettingsReader settingsReader =
// new AppSettingsReader();
// Get the key from config file
//string key = (string)settingsReader.GetValue("SecurityKey",
// typeof(String));
//System.Windows.Forms.MessageBox.Show(key);
//If hashing use get hashcode regards to your key
if (useHashing)
{
MD5CryptoServiceProvider hashmd5 = new MD5CryptoServiceProvider();
keyArray = hashmd5.ComputeHash(UTF8Encoding.UTF8.GetBytes(key));
//Always release the resources and flush data
// of the Cryptographic service provide. Best Practice
hashmd5.Clear();
}
else
keyArray = UTF8Encoding.UTF8.GetBytes(key);
TripleDESCryptoServiceProvider tdes = new TripleDESCryptoServiceProvider();
//set the secret key for the tripleDES algorithm
tdes.Key = keyArray;
//mode of operation. there are other 4 modes.
//We choose ECB(Electronic code Book)
tdes.Mode = CipherMode.ECB;
//padding mode(if any extra byte added)
tdes.Padding = PaddingMode.PKCS7;
ICryptoTransform cTransform = tdes.CreateEncryptor();
//transform the specified region of bytes array to resultArray
byte[] resultArray =
cTransform.TransformFinalBlock(toEncryptArray, 0,
toEncryptArray.Length);
//Release resources held by TripleDes Encryptor
tdes.Clear();
//Return the encrypted data into unreadable string format
return Convert.ToBase64String(resultArray, 0, resultArray.Length);
}
public string Decrypt(string cipherString, bool useHashing = true)
{
byte[] toEncryptArray = Convert.FromBase64String(cipherString);
return InternalDecrypt(toEncryptArray, useHashing);
}
public string InternalDecrypt(byte[] toEncryptArray, bool useHashing = true)
{
byte[] keyArray;
if (useHashing)
{
//if hashing was used get the hash code with regards to your key
MD5CryptoServiceProvider hashmd5 = new MD5CryptoServiceProvider();
keyArray = hashmd5.ComputeHash(UTF8Encoding.UTF8.GetBytes(key));
//release any resource held by the MD5CryptoServiceProvider
hashmd5.Clear();
}
else
{
//if hashing was not implemented get the byte code of the key
keyArray = UTF8Encoding.UTF8.GetBytes(key);
}
TripleDESCryptoServiceProvider tdes = new TripleDESCryptoServiceProvider();
//set the secret key for the tripleDES algorithm
tdes.Key = keyArray;
//mode of operation. there are other 4 modes.
//We choose ECB(Electronic code Book)
tdes.Mode = CipherMode.ECB;
//padding mode(if any extra byte added)
tdes.Padding = PaddingMode.PKCS7;
ICryptoTransform cTransform = tdes.CreateDecryptor();
byte[] resultArray = cTransform.TransformFinalBlock(
toEncryptArray, 0, toEncryptArray.Length);
//Release resources held by TripleDes Encryptor
tdes.Clear();
//return the Clear decrypted TEXT
return UTF8Encoding.UTF8.GetString(resultArray);
}
public void EncryptBitmap(string inputfile, string outputfile, bool useHashing = true)
{
byte[] toEncryptArray = File.ReadAllBytes(inputfile);
byte[] keyArray;
if (useHashing)
{
MD5CryptoServiceProvider hashmd5 = new MD5CryptoServiceProvider();
keyArray = hashmd5.ComputeHash(UTF8Encoding.UTF8.GetBytes(key));
hashmd5.Clear();
}
else
keyArray = UTF8Encoding.UTF8.GetBytes(key);
TripleDESCryptoServiceProvider tdes = new TripleDESCryptoServiceProvider();
tdes.Key = keyArray;
tdes.Mode = CipherMode.ECB;
tdes.Padding = PaddingMode.PKCS7;
ICryptoTransform cTransform = tdes.CreateEncryptor();
byte[] resultArray = cTransform.TransformFinalBlock(toEncryptArray, 0, toEncryptArray.Length);
tdes.Clear();
File.WriteAllBytes(outputfile, resultArray);
}
private Bitmap ByteArrayToBitmap(byte[] source)
{
using (var ms = new MemoryStream(source))
{
return new Bitmap(ms);
}
}
public Bitmap DecryptBitmap(string inputfile, bool useHashing = true)
{
byte[] toEncryptArray = File.ReadAllBytes(inputfile);
byte[] keyArray;
if (useHashing)
{
MD5CryptoServiceProvider hashmd5 = new MD5CryptoServiceProvider();
keyArray = hashmd5.ComputeHash(UTF8Encoding.UTF8.GetBytes(key));
hashmd5.Clear();
}
else
keyArray = UTF8Encoding.UTF8.GetBytes(key);
TripleDESCryptoServiceProvider tdes = new TripleDESCryptoServiceProvider();
tdes.Key = keyArray;
tdes.Mode = CipherMode.ECB;
tdes.Padding = PaddingMode.PKCS7;
ICryptoTransform cTransform = tdes.CreateDecryptor();
byte[] resultArray = cTransform.TransformFinalBlock(toEncryptArray, 0, toEncryptArray.Length);
tdes.Clear();
return ByteArrayToBitmap(resultArray);
}
//private static readonly RNGCryptoServiceProvider _generator = new RNGCryptoServiceProvider();
public static int Random(int minimumValue, int maximumValue)
{
RNGCryptoServiceProvider _generator = new RNGCryptoServiceProvider();
byte[] randomNumber = new byte[1];
_generator.GetBytes(randomNumber);
double asciiValueOfRandomCharacter = Convert.ToDouble(randomNumber[0]);
// We are using Math.Max, and substracting 0.00000000001,
// to ensure "multiplier" will always be between 0.0 and .99999999999
// Otherwise, it's possible for it to be "1", which causes problems in our rounding.
double multiplier = Math.Max(0, (asciiValueOfRandomCharacter / 255d) - 0.00000000001d);
// We need to add one to the range, to allow for the rounding done with Math.Floor
int range = maximumValue - minimumValue + 1;
double randomValueInRange = Math.Floor(multiplier * range);
return (int)(minimumValue + randomValueInRange);
}
}
}