Samuele E. Locatelli
481 lines
16 KiB
C#
481 lines
16 KiB
C#
using Microsoft.Reporting.WinForms;
|
|
using SteamWare.IO;
|
|
using SteamWare.Logger;
|
|
using SteamWare.Reports;
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.Data;
|
|
using System.Drawing.Imaging;
|
|
using System.Drawing.Printing;
|
|
using System.IO;
|
|
using System.Text;
|
|
|
|
|
|
namespace MagData
|
|
{
|
|
/// <summary>
|
|
/// Classe che si occupa di stampare report da reportViewer via printer remota
|
|
/// </summary>
|
|
public class reportPrinter
|
|
{
|
|
#region area codice da non modificare
|
|
|
|
private int m_currentPageIndex;
|
|
protected int logLevel = 0;
|
|
protected bool doPdfCopy = false;
|
|
/// <summary>
|
|
/// stream del report...
|
|
/// </summary>
|
|
private IList<Stream> m_streams;
|
|
/// <summary>
|
|
/// ciclo da fornire al renderizzatore dei report, per salvare 1 immagine da ogni pagina del report
|
|
/// </summary>
|
|
/// <param name="name"></param>
|
|
/// <param name="fileNameExtension"></param>
|
|
/// <param name="encoding"></param>
|
|
/// <param name="mimeType"></param>
|
|
/// <param name="willSeek"></param>
|
|
/// <returns></returns>
|
|
private Stream CreateStream(string name, string fileNameExtension, Encoding encoding, string mimeType, bool willSeek)
|
|
{
|
|
// creo files con nomi univoci...
|
|
string filePathName = string.Format(@"~\temp\{0}_{1:HHmmss}_{1:ffff}.{2}", name, DateTime.Now, fileNameExtension);
|
|
Stream stream = new FileStream(fileMover.getFilePath(filePathName), FileMode.Create);
|
|
//Stream stream = new FileStream(fileMover.getFilePath(@"~\temp\" + name + "." + fileNameExtension), FileMode.Create);
|
|
m_streams.Add(stream);
|
|
return stream;
|
|
}
|
|
/// <summary>
|
|
/// ciclo da fornire al renderizzatore dei report, per salvare 1 pdf da ogni pagina del report
|
|
/// </summary>
|
|
/// <param name="name"></param>
|
|
/// <param name="fileNameExtension"></param>
|
|
/// <param name="encoding"></param>
|
|
/// <param name="mimeType"></param>
|
|
/// <param name="willSeek"></param>
|
|
/// <returns></returns>
|
|
private Stream CreateStreamPdf(string name, string fileNameExtension, Encoding encoding, string mimeType, bool willSeek)
|
|
{
|
|
// creo Directory se non c'è
|
|
fileMover fm = new fileMover(string.Format(@"{0}\{1:yyyy}\{1:MM}\{1:dd}\", memLayer.ML.confReadString("PdfFolder"), DateTime.Now), "");
|
|
fm.checkDir();
|
|
string pdfPathName = string.Format(@"{0}\{1:yyyy}\{1:MM}\{1:dd}\{2}_{1:HHmmss}_{1:ffff}.{3}", memLayer.ML.confReadString("PdfFolder"), DateTime.Now, name, fileNameExtension);
|
|
//Stream stream = new FileStream(fileMover.getFilePath(@"~\temp\" + name + "." + fileNameExtension), FileMode.Create);
|
|
Stream stream = new FileStream(fileMover.getFilePath(pdfPathName), FileMode.Create);
|
|
m_streams.Add(stream);
|
|
return stream;
|
|
}
|
|
/// <summary>
|
|
/// Handler per PrintPageEvents
|
|
/// </summary>
|
|
/// <param name="sender"></param>
|
|
/// <param name="ev"></param>
|
|
private void PrintPage(object sender, PrintPageEventArgs ev)
|
|
{
|
|
Metafile pageImage = new Metafile(m_streams[m_currentPageIndex]);
|
|
ev.Graphics.DrawImage(pageImage, ev.PageBounds);
|
|
m_currentPageIndex++;
|
|
ev.HasMorePages = (m_currentPageIndex < m_streams.Count);
|
|
}
|
|
/// <summary>
|
|
/// funzione di stampa...
|
|
/// </summary>
|
|
private void Print(string printerName)
|
|
{
|
|
//const string printerName = "Microsoft Office Document Image Writer";
|
|
//const string printerName = "Brother HL-2170W series";
|
|
if (m_streams == null || m_streams.Count == 0)
|
|
{
|
|
return;
|
|
}
|
|
|
|
PrintDocument printDoc = new PrintDocument();
|
|
printDoc.PrinterSettings.PrinterName = printerName;
|
|
if (!printDoc.PrinterSettings.IsValid)
|
|
{
|
|
Logging.Instance.Error($"Impostazioni non valide per la stampante {printerName}");
|
|
return;
|
|
}
|
|
printDoc.PrintPage += new PrintPageEventHandler(PrintPage);
|
|
printDoc.Print();
|
|
}
|
|
/// <summary>
|
|
/// Export del report come EMF (Enhanced Metafile) file.
|
|
/// </summary>
|
|
/// <param name="report"></param>
|
|
private void Export(LocalReport report, string deviceInfo)
|
|
{
|
|
Warning[] warnings;
|
|
m_streams = new List<Stream>();
|
|
report.Render("Image", deviceInfo, CreateStream, out warnings);
|
|
foreach (Stream stream in m_streams)
|
|
{
|
|
stream.Position = 0;
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// Export del report come PDF file.
|
|
/// </summary>
|
|
/// <param name="report"></param>
|
|
private void ExportPDF(LocalReport report, string deviceInfo)
|
|
{
|
|
Warning[] warnings;
|
|
m_streams = new List<Stream>();
|
|
report.Render("PDF", deviceInfo, CreateStreamPdf, out warnings);
|
|
foreach (Stream stream in m_streams)
|
|
{
|
|
stream.Position = 0;
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// dispone l'applicazione e rilascia le risorse
|
|
/// </summary>
|
|
public void Dispose()
|
|
{
|
|
if (m_streams != null)
|
|
{
|
|
foreach (Stream stream in m_streams)
|
|
{
|
|
stream.Close();
|
|
}
|
|
|
|
m_streams = null;
|
|
}
|
|
}
|
|
|
|
|
|
#endregion
|
|
|
|
#region area codice da modificare
|
|
|
|
/// <summary>
|
|
/// carica i dati richiesti dal report dalla StoredProcedure (filtrando quindi...)
|
|
/// </summary>
|
|
/// <param name="tipoReport"></param>
|
|
/// <param name="keyParam">cod UDC</param>
|
|
/// <returns>tabella dati</returns>
|
|
private DataTable caricaDati(reportRichiesto tipoReport, string keyParam)
|
|
{
|
|
DataTable tab = new DataTable();
|
|
switch (tipoReport)
|
|
{
|
|
case reportRichiesto.CartellinoPedane:
|
|
tab = MagDataLayer.man.taCPed.GetData(keyParam);
|
|
break;
|
|
case reportRichiesto.CartellinoFinitiOdette:
|
|
tab = MagDataLayer.man.taCFOdette.GetData(keyParam);
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
return tab;
|
|
}
|
|
/// <summary>
|
|
/// Crea un report locale da file rdlc, carica i dati, esporta report come EMF file e quindi lo invia alla stampante
|
|
/// </summary>
|
|
/// <param name="tipoReport">report ammessi: ElencoMacchine / RichiestaIntervento</param>
|
|
/// <param name="printerName">nome completo stampante (rispetto al server)</param>
|
|
/// <param name="keyParam">cod UDC</param>
|
|
/// <param name="deviceInfoParam">parametri "device input"</param>
|
|
public void printReport(reportRichiesto tipoReport, string printerName, string keyParam, devInfoParam deviceInfoParam)
|
|
{
|
|
LocalReport report = new LocalReport();
|
|
report.EnableExternalImages = true;
|
|
string deviceInfo = "";
|
|
string repoBasePath = utils.getPath(memLayer.ML.cdv("ReportBasePath"));
|
|
repoBasePath = repoBasePath.Replace("\\site", "");
|
|
switch (tipoReport)
|
|
{
|
|
case reportRichiesto.CartellinoPedane:
|
|
report.ReportPath = string.Format(@"{0}\PartLabel.rdlc", repoBasePath);
|
|
report.DataSources.Add(new ReportDataSource(memLayer.ML.cdv("ReportDS_DocPart"), caricaDati(tipoReport, keyParam)));
|
|
break;
|
|
case reportRichiesto.CartellinoFinitiOdette:
|
|
report.ReportPath = string.Format(@"{0}\StackLabel.rdlc", repoBasePath);
|
|
report.DataSources.Add(new ReportDataSource(memLayer.ML.cdv("ReportDS_DocStack"), caricaDati(tipoReport, keyParam)));
|
|
break;
|
|
}
|
|
deviceInfo = deviceInfoParam.xmlParam;
|
|
doEmfPrint(printerName, report, deviceInfo);
|
|
// controllo se devo fare copia PDF... stampiamo ANCHE su pdf su una folder locale
|
|
if (doPdfCopy)
|
|
{
|
|
deviceInfoParam.OutputFormat = "PDF";
|
|
deviceInfo = deviceInfoParam.xmlParam;
|
|
doLocalPdfPrint(report, deviceInfo);
|
|
}
|
|
}
|
|
/// <summary>
|
|
/// esegue print vero e proprio
|
|
/// </summary>
|
|
/// <param name="printerName"></param>
|
|
/// <param name="report"></param>
|
|
/// <param name="deviceInfo"></param>
|
|
private void doEmfPrint(string printerName, LocalReport report, string deviceInfo)
|
|
{
|
|
// export in EMF
|
|
Export(report, deviceInfo);
|
|
m_currentPageIndex = 0;
|
|
// stampo
|
|
Print(printerName);
|
|
// do dispose?
|
|
Dispose();
|
|
}
|
|
/// <summary>
|
|
/// effettua stampa in PDF dei vari report in una cartella Anno/Mese/Giorno
|
|
/// </summary>
|
|
/// <param name="report"></param>
|
|
/// <param name="deviceInfo"></param>
|
|
private void doLocalPdfPrint(LocalReport report, string deviceInfo)
|
|
{
|
|
// export in PDF
|
|
ExportPDF(report, deviceInfo);
|
|
m_currentPageIndex = 0;
|
|
// do dispose?
|
|
Dispose();
|
|
}
|
|
/// <summary>
|
|
/// Effettua la stampa del documento indicato
|
|
/// </summary>
|
|
/// <param name="printerQueue">coda di stampa da utilizzare</param>
|
|
/// <param name="keyParam">Chiave del documento</param>
|
|
/// <returns></returns>
|
|
public bool stampaReport(string printerQueue, string keyParam)
|
|
{
|
|
bool answ = false;
|
|
MagDataLayer dtProx = new MagDataLayer();
|
|
// gestione coda stampa...
|
|
|
|
// incomincio con gestione della coda di stampa... inserisco in tab la richiesta di stampa...
|
|
if (memLayer.ML.CRB("disable_singleton"))
|
|
{
|
|
dtProx.taPJQ.insertQuery(keyParam, printerQueue);
|
|
}
|
|
else
|
|
{
|
|
MagDataLayer.man.taPJQ.insertQuery(keyParam, printerQueue);
|
|
}
|
|
#if false
|
|
// faccio un ciclo while... finchè non sono "in testa" alla coda delle esecuzioni aspetto...
|
|
string nextJob = "ND";
|
|
try
|
|
{
|
|
if (memLayer.ML.CRB("disable_singleton"))
|
|
{
|
|
nextJob = dtProx.taPJQ.getNext()[0].KeyParam;
|
|
}
|
|
else
|
|
{
|
|
nextJob = MagDataLayer.man.taPJQ.getNext()[0].KeyParam;
|
|
}
|
|
}
|
|
catch
|
|
{
|
|
nextJob = "ND";
|
|
}
|
|
// verifico eventuali processi zombie: quelli in stato 0 con LastTry superiore a data attuale meno zombieMsTime
|
|
if (memLayer.ML.CRB("disable_singleton"))
|
|
{
|
|
dtProx.taPJQ.chiudiZoombie(DateTime.Now.AddMilliseconds(-memLayer.ML.CRI("zombieMsTime")));
|
|
}
|
|
else
|
|
{
|
|
MagDataLayer.man.taPJQ.chiudiZoombie(DateTime.Now.AddMilliseconds(-memLayer.ML.CRI("zombieMsTime")));
|
|
}
|
|
// ora inizio a fare le mie stampe...
|
|
Random rand = new Random();
|
|
int msWait = 200;
|
|
while (nextJob != keyParam)
|
|
{
|
|
// indico che ho fatto un tentativo di stampa aggiornando dtLastTry
|
|
if (memLayer.ML.CRB("disable_singleton"))
|
|
{
|
|
dtProx.taPJQ.updateLastTry(keyParam);
|
|
}
|
|
else
|
|
{
|
|
MagDataLayer.man.taPJQ.updateLastTry(keyParam);
|
|
}
|
|
// aspetto...
|
|
msWait = rand.Next(memLayer.ML.confReadInt("minWait"), memLayer.ML.confReadInt("maxWait"));
|
|
System.Threading.Thread.Sleep(msWait);
|
|
// leggo prox record da coda
|
|
if (memLayer.ML.CRB("disable_singleton"))
|
|
{
|
|
nextJob = dtProx.taPJQ.getNext()[0].KeyParam;
|
|
}
|
|
else
|
|
{
|
|
nextJob = MagDataLayer.man.taPJQ.getNext()[0].KeyParam;
|
|
}
|
|
}
|
|
// salvo idx job...
|
|
try
|
|
{
|
|
if (memLayer.ML.CRB("disable_singleton"))
|
|
{
|
|
idxPrintJob = dtProx.taPJQ.getNext()[0].IdxPrintJob;
|
|
}
|
|
else
|
|
{
|
|
idxPrintJob = MagDataLayer.man.taPJQ.getNext()[0].IdxPrintJob;
|
|
}
|
|
}
|
|
catch (Exception exc)
|
|
{
|
|
logger.lg.scriviLog($"Errore in recupero IdxPrint Job:{exc}", tipoLog.EXCEPTION);
|
|
}
|
|
|
|
// dimensioni pagina
|
|
string outForm = "";
|
|
string pagWidth = "";
|
|
string pagHeigth = "";
|
|
string margin = "";
|
|
reportRichiesto report = reportRichiesto.cartOdette;
|
|
string tipo = "";
|
|
|
|
switch (documento)
|
|
{
|
|
case tipoDocumento.docBinPre:
|
|
tipo = "DocPaint";
|
|
report = reportRichiesto.paintLabelPre;
|
|
break;
|
|
case tipoDocumento.docBinPost:
|
|
tipo = "DocPaintPost";
|
|
report = reportRichiesto.paintLabelPost;
|
|
break;
|
|
case tipoDocumento.docCart:
|
|
tipo = "DocCart";
|
|
report = reportRichiesto.cartLabel;
|
|
break;
|
|
case tipoDocumento.docPart:
|
|
tipo = "DocPart";
|
|
report = reportRichiesto.cartPedane;
|
|
break;
|
|
case tipoDocumento.docStack:
|
|
tipo = "DocStack";
|
|
report = reportRichiesto.cartOdette;
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
// carico di dati con lettura da web.config parametrica
|
|
if (string.IsNullOrEmpty(printerQueue))
|
|
{
|
|
printerQueue = memLayer.ML.cdv(string.Format("printer{0}", tipo));
|
|
}
|
|
outForm = "EMF";
|
|
pagWidth = memLayer.ML.cdv(string.Format("PageWidth{0}", tipo));
|
|
pagHeigth = memLayer.ML.cdv(string.Format("PageHeight{0}", tipo));
|
|
margin = memLayer.ML.cdv(string.Format("Margin{0}", tipo));
|
|
// compongo parametri stampa
|
|
devInfoParam deviceInfo = new devInfoParam(outForm, pagHeigth, pagWidth, margin, margin, margin, margin);
|
|
answ = printAndLog(keyParam, printerQueue, answ, report, deviceInfo);
|
|
if (answ)
|
|
{
|
|
// registro stampato in tabella queue...
|
|
if (memLayer.ML.CRB("disable_singleton"))
|
|
{
|
|
dtProx.taPJQ.updateStato(idxPrintJob, 1);
|
|
}
|
|
else
|
|
{
|
|
MagDataLayer.man.taPJQ.updateStato(idxPrintJob, 1);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// registro annullato in tab queue...
|
|
if (memLayer.ML.CRB("disable_singleton"))
|
|
{
|
|
dtProx.taPJQ.updateStato(idxPrintJob, -1);
|
|
}
|
|
else
|
|
{
|
|
MagDataLayer.man.taPJQ.updateStato(idxPrintJob, -1);
|
|
}
|
|
|
|
}
|
|
#endif
|
|
return answ;
|
|
}
|
|
/// <summary>
|
|
/// effettua la vera e propria fase di stampa
|
|
/// </summary>
|
|
/// <param name="keyParam"></param>
|
|
/// <param name="printerName"></param>
|
|
/// <param name="answ"></param>
|
|
/// <param name="report"></param>
|
|
/// <param name="deviceInfo"></param>
|
|
/// <returns></returns>
|
|
private bool printAndLog(string keyParam, string printerName, bool answ, reportRichiesto report, devInfoParam deviceInfo)
|
|
{
|
|
try
|
|
{
|
|
if (logLevel > 5)
|
|
{
|
|
Logging.Instance.Info(String.Format("Sto per inviare un report alla stampante {0}", printerName));
|
|
}
|
|
|
|
reportPrinter.obj.printReport(report, printerName, keyParam, deviceInfo);
|
|
if (logLevel > 5)
|
|
{
|
|
Logging.Instance.Info(String.Format("inviato comando print alla stampante {0}", printerName));
|
|
}
|
|
|
|
answ = true;
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
Logging.Instance.Error(String.Format("Errore in fase di creazione e stampa report: stampante {0}, errore riscontrato {1}", printerName, e));
|
|
}
|
|
return answ;
|
|
}
|
|
/// <summary>
|
|
/// oggetto protected
|
|
/// </summary>
|
|
/// <param name="args"></param>
|
|
protected reportPrinter()
|
|
{
|
|
logLevel = memLayer.ML.CRI("_logLevel");
|
|
doPdfCopy = memLayer.ML.CRB("doPdfCopy");
|
|
}
|
|
/// <summary>
|
|
/// singleton pubblico
|
|
/// </summary>
|
|
public static reportPrinter obj = new reportPrinter();
|
|
/// <summary>
|
|
/// effettua pulizia della cartella temp x i files più vecchi di X ore (web.config)
|
|
/// </summary>
|
|
public void pulisciDir()
|
|
{
|
|
// num max ore di età x files "vecchi" da tenere in temp area...
|
|
int maxOre = memLayer.ML.CRI("maxAgeTempAreaHours");
|
|
int eliminati = 0;
|
|
// ottengo elenco files *.emf
|
|
fileMover.obj.setDirectory(@"~\temp\");
|
|
FileInfo[] _fis = fileMover.obj.elencoFiles_FI("*.emf");
|
|
bool fatto = false;
|
|
foreach (FileInfo _file in _fis)
|
|
{
|
|
if (_file.CreationTime < DateTime.Now.AddHours(-maxOre)) // elimino files vecchi...
|
|
{
|
|
fatto = fileMover.obj.eliminaFile(_file);
|
|
if (fatto)
|
|
{
|
|
Logging.Instance.Info(String.Format("Eliminato file {0}", _file.Name));
|
|
eliminati++;
|
|
}
|
|
}
|
|
}
|
|
// salvo il log degli update
|
|
if (eliminati > 0)
|
|
{
|
|
Logging.Instance.Info(String.Format("Eliminati {0} files temporanei da area temp", eliminati));
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
}
|
|
}
|