public void CopySignedDocuments()
{
string file = RESOURCES + "hello_signed1.pdf";
Directory.CreateDirectory("PdfCopyTest/");
Document pdfDocument = new Document();
PdfCopy copier = new PdfCopy(pdfDocument, new FileStream("PdfCopyTest/CopySignedDocuments.pdf", FileMode.Create));
pdfDocument.Open();
PdfReader reader1 = new PdfReader(file);
copier.AddPage(copier.GetImportedPage(reader1, 1));
copier.FreeReader(reader1);
reader1 = new PdfReader(file);
copier.AddPage(copier.GetImportedPage(reader1, 1));
copier.FreeReader(reader1);
pdfDocument.Close();
PdfReader reader = new PdfReader("PdfCopyTest/CopySignedDocuments.pdf");
PdfDictionary sig = (PdfDictionary)reader.GetPdfObject(9);
PdfDictionary sigRef = sig.GetAsArray(PdfName.REFERENCE).GetAsDict(0);
Assert.True(PdfName.SIGREF.Equals(sigRef.GetAsName(PdfName.TYPE)));
Assert.False(sigRef.Contains(PdfName.DATA));
sig = (PdfDictionary)reader.GetPdfObject(21);
sigRef = sig.GetAsArray(PdfName.REFERENCE).GetAsDict(0);
Assert.True(PdfName.SIGREF.Equals(sigRef.GetAsName(PdfName.TYPE)));
Assert.False(sigRef.Contains(PdfName.DATA));
}
private void Button11_Click(object sender, EventArgs e)
{
var document = new Document();
var ms = new MemoryStream();
string[] Lista = { "Guia_CV_2016.pdf", "Guia_CV_2016.pdf" };
var pdfCopy = new PdfCopy(document, ms);
document.Open();
foreach (var item in Lista)
{
var pdfReader = new PdfReader(item);
var n = pdfReader.NumberOfPages;
for (var page = 0; page < n;)
{
pdfCopy.AddPage(pdfCopy.GetImportedPage(pdfReader, ++page));
}
pdfCopy.FreeReader(pdfReader);
}
pdfCopy.Flush();
document.Close();
Document doc = new Document();
PdfWriter.GetInstance(doc, new FileStream("COMPLETO2.pdf", FileMode.Create));
//ms.WriteTo(new FileStream("documentoJutar.pdf", FileMode.OpenOrCreate));
ms.WriteTo(new FileStream("Prueba.pdf", FileMode.OpenOrCreate));
}
/// <summary>
/// Concatenates PDFs
/// </summary>
/// <param name="pdfByteContent">A list of byte arrays containing the PDFs</param>
/// <returns>A single byte array for one PDF</returns>
public static byte[] ConcatenatePDFs(IEnumerable <byte[]> pdfByteContent)
{
//Console.WriteLine("Concatenating PDFs...");
using var ms = new MemoryStream();
var doc = new Document();
var copy = new PdfCopy(doc, ms);
doc.Open();
//Loop through each byte array
foreach (var p in pdfByteContent)
{
//Create a PdfReader bound to that byte array
var reader = new PdfReader(p);
for (var i = 1; i <= reader.NumberOfPages; i++)
{
copy.AddPage(copy.GetImportedPage(reader, i));
}
copy.FreeReader(reader);
reader.Close();
}
copy.Close();
doc.Close();
var allPagesContent = ms.GetBuffer();
ms.Flush();
return(allPagesContent);
}
public static void Merge(List <string> fromFileNames, string toFileName)
{
using (var fs = new FileStream(toFileName, FileMode.Create))
{
var document = new Document();
var pdfCopy = new PdfCopy(document, fs);
document.Open();
PdfReader reader = null;
PdfImportedPage page = null;
fromFileNames.ForEach(fileName =>
{
reader = new PdfReader(fileName);
for (int i = 0; i < reader.NumberOfPages; i++)
{
page = pdfCopy.GetImportedPage(reader, i + 1);
pdfCopy.AddPage(page);
}
pdfCopy.FreeReader(reader);
reader.Close();
// File.Delete(fileName);
});
document.Close();
fs.Close();
}
}
public static void MergeFiles(List <string> sourceFiles, string rutaPdfJoin, bool addCopy)
{
Document document = new Document();
using (MemoryStream ms = new MemoryStream())
{
FileStream fl = new FileStream(rutaPdfJoin, FileMode.Create, FileAccess.Write, FileShare.None);
PdfCopy copy = new PdfCopy(document, fl);
document.Open();
// Iterar pdfs
for (int fileCounter = 0; fileCounter < sourceFiles.Count; fileCounter++)
{
PdfReader reader = new PdfReader(sourceFiles[fileCounter]);
int numberOfPages = reader.NumberOfPages;
// Iterar paginas
for (int currentPageIndex = 1; currentPageIndex <= numberOfPages; currentPageIndex++)
{
PdfImportedPage importedPage = copy.GetImportedPage(reader, currentPageIndex);
PdfCopy.PageStamp pageStamp = copy.CreatePageStamp(importedPage);
pageStamp.AlterContents();
copy.AddPage(importedPage);
if (addCopy)
{
copy.AddPage(importedPage);
}
}
copy.FreeReader(reader);
reader.Close();
}
document.Close();
}
}
/// <summary>
/// Une los manifiesto de una determinada
/// </summary>
/// <param name="c"></param>
public void UnirPDF(CargaSucursal c)
{
Document doc = new Document();
try
{
ManipulacionPDF m = new ManipulacionPDF();
string[] final = new string[c.Manifiesto.Count];
int i = 0;
foreach (ManifiestoSucursalCarga man in c.Manifiesto)
{
final[i] = @"\\10.120.131.100\Manifiestos\SUC-" + man.ID.ToString() + ".pdf";
i++;
}
//m.MergePdfFiles(final, @"\\10.120.131.100\ECARD\Final_Validacion\FINALSUCURSAL-" + c.ID + ".pdf");
string rutafinal = @"\\10.120.131.100\ECARD\Final_Validacion\FINALSUCURSAL-" + c.ID + ".pdf";
FileStream fs = new FileStream(rutafinal, FileMode.Create, FileAccess.Write, FileShare.None);
PdfCopy copy = new PdfCopy(doc, fs);
doc.Open();
iTextSharp.text.pdf.PdfReader reader = null;
iTextSharp.text.pdf.PdfReader.unethicalreading = true;
int n;
foreach (string file in final)
{
reader = new PdfReader(file);
iTextSharp.text.pdf.PdfReader.unethicalreading = true;
n = reader.NumberOfPages;
int page = 0;
while (page < n)
{
page++;
copy.AddPage(copy.GetImportedPage(reader, page));
}
copy.FreeReader(reader);
reader.Close();
}
}
catch (Excepcion ex)
{
doc.Close();
}
finally
{
doc.Close();
}
}
public static byte[] merge_files(List <FileInfo> docs)
{
Document document = new Document();
using (MemoryStream ms = new MemoryStream()) {
PdfCopy copy = new PdfCopy(document, ms);
document.Open();
int document_page_counter = 0;
foreach (FileInfo fi in docs)
{
PdfReader reader = new PdfReader(fi.FullName);
for (int i = 1; i <= reader.NumberOfPages; i++)
{
document_page_counter++;
PdfImportedPage ip = copy.GetImportedPage(reader, i);
#if PAGE_NUMBERS
PdfCopy.PageStamp ps = copy.CreatePageStamp(ip);
ColumnText.ShowTextAligned(ps.GetOverContent(), Element.ALIGN_CENTER,
new Phrase(string.Format("{0}", document_page_counter)), (ip.Width / 2), 5, ip.Width < ip.Height ? 0 : 1);
ps.AlterContents();
#endif
copy.AddPage(ip);
}
copy.FreeReader(reader);
reader.Close();
}
document.Close();
return(ms.GetBuffer());
}
}
public static void Merge(List <String> InFiles, String OutFile)
{
using (FileStream stream = new FileStream(OutFile, FileMode.Create))
using (Document doc = new Document())
using (PdfCopy pdf = new PdfCopy(doc, stream))
{
doc.Open();
PdfReader reader = null;
PdfImportedPage page = null;
//fixed typo
InFiles.ForEach(file =>
{
reader = new PdfReader(file);
for (int i = 0; i < reader.NumberOfPages; i++)
{
page = pdf.GetImportedPage(reader, i + 1);
pdf.AddPage(page);
}
pdf.FreeReader(reader);
reader.Close();
File.Delete(file);
});
}
}
/// <summary>
/// Takes an ordered list of files and merges them into one output file.
/// </summary>
/// <param name="mergeList">An ordered list of file paths.</param>
/// <returns>The path to merged file created in this method.</returns>
private static string MergeOrderedList(List <string> mergeList)
{
int counter = 0;
string filename = Guid.NewGuid() + ".pdf";
string outfileFullPath = Path.Combine(Constants.inputDirectory.FullName, filename);
using (var stream = new FileStream(outfileFullPath, FileMode.Create))
using (var doc = new Document())
using (var pdf = new PdfCopy(doc, stream))
{
PdfReader reader = null;
PdfImportedPage page = null;
doc.Open();
foreach (string file in mergeList)
{
reader = new PdfReader(file);
for (int i = 0; i < reader.NumberOfPages; i++)
{
page = pdf.GetImportedPage(reader, i + 1);
pdf.AddPage(page);
}
counter++;
}
pdf.FreeReader(reader);
reader.Close();
}
return(outfileFullPath);
}
public static void Merge(List <String> InFiles, String OutFile)
{
try
{
using (FileStream stream = new FileStream(OutFile, FileMode.Create))
using (Document doc = new Document())
using (PdfCopy pdf = new PdfCopy(doc, stream))
{
doc.Open();
PdfReader reader = null;
PdfImportedPage page = null;
InFiles.ForEach(file =>
{
reader = new PdfReader(file);
for (int i = 0; i < reader.NumberOfPages; i++)
{
page = pdf.GetImportedPage(reader, i + 1);
pdf.AddPage(page);
}
pdf.FreeReader(reader);
reader.Close();
});
}
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
}
public static MemoryStream MergePdfForms(List <byte[]> files)
{
if (files.Count > 1)
{
PdfReader pdfFile;
Document doc;
PdfWriter pCopy;
MemoryStream msOutput = new MemoryStream();
pdfFile = new PdfReader(files[0]);
doc = new Document();
pCopy = new PdfCopy(doc, msOutput);
doc.Open();
for (int k = 0; k < files.Count; k++)
{
pdfFile = new PdfReader(files[k]);
for (int i = 1; i < pdfFile.NumberOfPages + 1; i++)
{
((PdfCopy)pCopy).AddPage(pCopy.GetImportedPage(pdfFile, i));
}
pCopy.FreeReader(pdfFile);
}
pdfFile.Close();
pCopy.Close();
doc.Close();
return(msOutput);
}
else if (files.Count == 1)
{
return(new MemoryStream(files[0]));
}
return(null);
}
public static MemoryStream Merge(List <String> InFiles)
{
MemoryStream stream = new MemoryStream();
using (Document doc = new Document())
using (PdfCopy pdf = new PdfCopy(doc, stream))
{
doc.Open();
PdfReader reader = null;
PdfImportedPage page = null;
InFiles.ForEach(file =>
{
reader = new PdfReader(file);
for (int i = 0; i < reader.NumberOfPages; i++)
{
page = pdf.GetImportedPage(reader, i + 1);
pdf.AddPage(page);
}
pdf.FreeReader(reader);
reader.Close();
});
}
return(stream);
}
/* private void Button2_Click(object sender, EventArgs e)
* {
* if (/*digital.Rows.Count > 0)
* {
* int id = int.Parse(/**digital .Rows[*digital .currentRow.Index].Cell[0].Value.ToString());
* using (Model.datosUsuario db = new Model.datosUsuario())
* {
* var oDocument = db.documen.Find(id);
* string path = AppDomain.CurrentDomain.BaseDirectory;
* string folder = path + "/temp/";
* string fullFilePath = folder + oDocument.realName;
*
* if (!Directory.Exists(folder))
* Directory.CreateDirectory(folder);
*
* if (File.Exists(fullFilePath))
* Directory.Delete(fullFilePath);
*
* File.WriteAllBytes(fullFilePath, oDocument.doc);
*
* Process.Start(fullFilePath);
*
* }
*
* }
* }
*
* private void Button3_Click(object sender, EventArgs e)
* {
* try
* {
* conexion.Close();
* SqlDataAdapter adapter = new SqlDataAdapter("Select Archivo from Scanner where Nombre = '" + Nombre + "'", conexion);
* DataSet set = new DataSet();
* conecta();
* adapter.Fill(set, "Scanner");
* byte[] datos = new byte[0];
* DataRow row = set.Tables["Scanner"].Rows[0];
* datos = (byte[])row["Archivo"];
* datos = (byte[])row["Archivo"];
* datos = (byte[])row["Archivo"];
* datos = (byte[])row["Archivo"];
* System.IO.MemoryStream ms = new System.IO.MemoryStream(datos);
*
* PDF.src = openFileDialog.FileName;
*
* }
* catch (SqlException)
* {
* MessageBox.Show("Error Al Cargar La Imagen", "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
* }
*
* }
* public void verdocumentos(string Nombre, AxAcroPDF PDF, OpenFileDialog openFileDialog)
* {
* try
* {
* string query = "Select Archivo from Scanner where Nombre = @nombre";
* SqlCommand cmd = new SqlCommand(query, conexion)
*
* cmd.Parameters.AddWithValue("@nombre", Nombre);
*
* SqlDataAdapter da = new SqlDataAdapter(cmd);
* DataTable dt = new DataTable();
* adapter.Fill(dt);
*
* DataRow row = dt.Rows[0];
* byte[] datos = (byte[])row["Archivo"];
*
* File.WriteAllBytes("ruta", datos);
* File.WriteAllBytes(fileDialog.FileName, datos);
* PDF.src = "ruta";
*
*
* }
* catch (SqlException)
* {
* MessageBox.Show("Error Al Cargar La Imagen", "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
* }
* }*/
private void Button4_Click(object sender, EventArgs e)
{
var document = new Document();
var ms = new MemoryStream();
string[] Lista = { "PRUEBA5.pdf", "PRUEBA7.pdf" };
var pdfCopy = new PdfCopy(document, ms);
document.Open();
foreach (var item in Lista)
{
var pdfReader = new PdfReader(item);
var n = pdfReader.NumberOfPages;
for (var page = 0; page < n;)
{
pdfCopy.AddPage(pdfCopy.GetImportedPage(pdfReader, ++page));
}
pdfCopy.FreeReader(pdfReader);
}
pdfCopy.Flush();
document.Close();
ms.WriteTo(new FileStream("documentoJutar.pdf", FileMode.OpenOrCreate));
}
public static MemoryStream MergePdf(List <MemoryStream> inFiles)
{
var ms = new MemoryStream();
var doc = new Document();
var pdf = new PdfCopy(doc, ms);
doc.Open();
PdfReader reader;
PdfImportedPage page;
inFiles.ForEach(file =>
{
reader = new PdfReader(file);
for (var i = 0; i < reader.NumberOfPages; i++)
{
page = pdf.GetImportedPage(reader, i + 1);
pdf.AddPage(page);
}
pdf.FreeReader(reader);
});
pdf.CloseStream = false;
doc.Close();
ms.Position = 0;
return(ms);
}
public void CreateNewPdf(string path, string targetFile, List <int> Pages)
{
try
{
using (FileStream stream = new FileStream(targetFile, FileMode.Create))
using (Document doc = new Document())
using (PdfCopy pdf = new PdfCopy(doc, stream))
{
doc.Open();
PdfReader reader = new PdfReader(path);
PdfImportedPage page = null;
foreach (int pageNumber in Pages)
{
page = pdf.GetImportedPage(reader, pageNumber);
pdf.AddPage(page);
}
pdf.FreeReader(reader);
reader.Close();
}
}
catch (Exception ex)
{
HandleException(ex, false);
}
}
public static string Combine(string[] files, string pdfFileName)
{
if (!files.Any())
{
return("empty");
}
string outputPdfPath = Path.Combine(new DirectoryInfo(files[0]).Parent.Parent.FullName, pdfFileName + ".pdf");
try
{
using (FileStream stream = new FileStream(outputPdfPath, FileMode.Create))
using (Document doc = new Document())
using (PdfCopy pdf = new PdfCopy(doc, stream))
{
doc.Open();
doc.AddTitle(pdfFileName);
/*
* doc.NewPage();
* doc.Add(new Paragraph(pdfFileName));
* doc.Add(new Paragraph("power by "));
* Anchor anchor = new Anchor("html2pdf");
* anchor.Reference = "https://github.com/xiangwan/html2pdf";
* doc.Add(anchor);*/
var rootOutline = pdf.RootOutline;
PdfReader reader = null;
PdfImportedPage page = null;
PdfContentByte cb = pdf.DirectContent;
PdfWriter wrt = cb.PdfWriter;
var pageIndex = 1;
files.ToList().ForEach(file =>
{
reader = new PdfReader(file);
var n = reader.NumberOfPages;
for (int i = 0; i < n; i++)
{
page = pdf.GetImportedPage(reader, i + 1);
pdf.AddPage(page);
}
var title = new FileInfo(file).Name.Replace(".pdf", "");
var oline = new PdfOutline(rootOutline,
PdfAction.GotoLocalPage(pageIndex, new PdfDestination(pageIndex), wrt), title);
rootOutline.AddKid(oline);
pageIndex += n;
pdf.FreeReader(reader);
reader.Close();
});
}
}
catch (Exception ex)
{
logger.Error(ex);
return("error." + ex.Message);
}
return("ok");
}
public byte[] Generate(TakeDocModel.Version version, TakeDocModel.Entity entity)
{
byte[] data = this.GenerateStarterPdf(version, entity);
if (data == null)
{
return(null);
}
PdfReader entetePdf = new PdfReader(data);
PdfReader imagePdf = servImage.GetImagePdf(version);
its.Document document = new its.Document(iTextSharp.text.PageSize.A4, -70, -70, 0, 0);
MemoryStream streamOut = new MemoryStream();
using (PdfCopy copy = new PdfCopy(document, streamOut))
{
document.Open();
for (int p = 1; p <= entetePdf.NumberOfPages; p++)
{
PdfImportedPage page = copy.GetImportedPage(entetePdf, p);
copy.AddPage(page);
}
copy.FreeReader(entetePdf);
entetePdf.Close();
if (imagePdf != null)
{
// add page image to the pdf
for (int p = 1; p <= imagePdf.NumberOfPages; p++)
{
PdfImportedPage page = copy.GetImportedPage(imagePdf, p);
copy.AddPage(page);
}
copy.FreeReader(imagePdf);
imagePdf.Close();
}
}
System.IO.FileInfo file = this.GetGenerateFileInfo(entity.EntityReference, version.VersionReference, "pdf");
System.IO.File.WriteAllBytes(file.FullName, streamOut.ToArray());
version.VersionPath = file.FullName.Replace(TakeDocModel.Environnement.VersionStoreUNC, string.Empty);
servVersion.Update(version);
return(streamOut.ToArray());
}
public FileStreamResult PrintFormats(int idFormat, string RecordId)
{
if (!_tokenManager.GenerateToken())
{
return(null);
}
_IGeneratePDFApiConsumer.SetAuthHeader(_tokenManager.Token);
_ISpartan_FormatRelatedApiConsumer.SetAuthHeader(_tokenManager.Token);
MemoryStream ms = new MemoryStream();
//Buscar los Formatos Relacionados
var relacionados = _ISpartan_FormatRelatedApiConsumer.ListaSelAll(0, 5000, "Spartan_Format_Related.FormatId = " + idFormat, "").Resource.Spartan_Format_Relateds.OrderBy(r => r.Order).ToList();
if (relacionados.Count > 0)
{
var outputDocument = new iTextSharp.text.Document();
var writer = new PdfCopy(outputDocument, ms);
outputDocument.Open();
foreach (var spartan_Format_Related in relacionados)
{
var bytePdf = _IGeneratePDFApiConsumer.GeneratePDF(Convert.ToInt32(spartan_Format_Related.FormatId_Related), RecordId).Resource;
var reader = new PdfReader(bytePdf);
for (var j = 1; j <= reader.NumberOfPages; j++)
{
writer.AddPage(writer.GetImportedPage(reader, j));
}
writer.FreeReader(reader);
reader.Close();
}
writer.Close();
outputDocument.Close();
var allPagesContent = ms.GetBuffer();
ms.Flush();
}
else
{
var bytePdf = _IGeneratePDFApiConsumer.GeneratePDF(idFormat, RecordId);
ms.Write(bytePdf.Resource, 0, bytePdf.Resource.Length);
}
Response.ContentType = "application/pdf";
Response.AddHeader("content-disposition", "attachment;filename=Formatos.pdf");
Response.Buffer = true;
Response.Clear();
Response.OutputStream.Write(ms.GetBuffer(), 0, ms.GetBuffer().Length);
Response.OutputStream.Flush();
Response.End();
return(new FileStreamResult(Response.OutputStream, "application/pdf"));
}
public static byte[] MergeFiles(List <byte[]> sourceFiles)
{
Document document = new Document();
using (MemoryStream ms = new MemoryStream())
{
PdfCopy copy = new PdfCopy(document, ms);
document.Open();
int documentPageCounter = 0;
// Iterate through all pdf documents
for (int fileCounter = 0; fileCounter < sourceFiles.Count; fileCounter++)
{
// Create pdf reader
PdfReader reader = new PdfReader(sourceFiles[fileCounter]);
int numberOfPages = reader.NumberOfPages;
// Iterate through all pages
for (int currentPageIndex = 1; currentPageIndex <= numberOfPages; currentPageIndex++)
{
PdfImportedPage importedPage = copy.GetImportedPage(reader, currentPageIndex);
//***************************************
// Uncomment and alter for watermarking.
//***************************************
//
//documentPageCounter++;
//PdfCopy.PageStamp pageStamp = copy.CreatePageStamp(importedPage);
//
//// Write header
//ColumnText.ShowTextAligned(pageStamp.GetOverContent(), Element.ALIGN_CENTER,
// new Phrase("PDF Merged with me.AxeyWorks PDFMerge"), importedPage.Width / 2, importedPage.Height - 30,
// importedPage.Width < importedPage.Height ? 0 : 1);
//
//// Write footer
//ColumnText.ShowTextAligned(pageStamp.GetOverContent(), Element.ALIGN_CENTER,
// new Phrase($"Page {documentPageCounter}"), importedPage.Width / 2, 30,
// importedPage.Width < importedPage.Height ? 0 : 1);
//
//pageStamp.AlterContents();
copy.AddPage(importedPage);
}
copy.FreeReader(reader);
reader.Close();
}
document.Close();
return(ms.GetBuffer());
}
}
public string GenerarExpediente(List <string> rutaArchivo, int idPrecliente, string path)
{
rutaArchivo = ImagenToPDF(rutaArchivo, idPrecliente, path);
var carpeta = path;
var rutaExpediente = "\\Documentos\\" + idPrecliente.ToString() + "\\Expediente" + ObtenerGuiArchivo() + ".pdf";
if (!Directory.Exists(carpeta))
{
Directory.CreateDirectory(carpeta);
}
try
{
using (MemoryStream stream = new MemoryStream())
{
using (Document doc = new Document())
{
PdfCopy pdf = new PdfCopy(doc, stream);
pdf.CloseStream = false;
doc.Open();
PdfReader reader = null;
PdfImportedPage page = null;
foreach (var file in rutaArchivo)
{
reader = new PdfReader(path + file);
for (int i = 0; i < reader.NumberOfPages; i++)
{
page = pdf.GetImportedPage(reader, i + 1);
pdf.AddPage(page);
}
pdf.FreeReader(reader);
reader.Close();
}
}
using (FileStream streamX = new FileStream(carpeta + "" + rutaExpediente, FileMode.Create))
{
stream.WriteTo(streamX);
}
}
return(rutaExpediente);
}
catch (Exception ex)
{
throw new Exception(ex.Message + "\n" + ex.StackTrace);
}
}
public async Task <byte[]> MergeFiles(List <ClaimFilePage> ClaimFilePages)
{
Document document = new Document();
using (MemoryStream ms = new MemoryStream())
{
PdfCopy copy = new PdfCopy(document, ms);
document.Open();
int documentPageCounter = 0;
// Iterate through all pdf documents
foreach (var claimPage in ClaimFilePages)
{
// Create pdf reader
PdfReader reader = new PdfReader(claimPage.Page);
int numberOfPages = reader.NumberOfPages;
// Iterate through all pages
for (int currentPageIndex = 1; currentPageIndex <= numberOfPages; currentPageIndex++)
{
documentPageCounter++;
PdfImportedPage importedPage = copy.GetImportedPage(reader, currentPageIndex);
PdfCopy.PageStamp pageStamp = copy.CreatePageStamp(importedPage);
// Write header
ColumnText.ShowTextAligned(pageStamp.GetOverContent(), Element.ALIGN_CENTER,
new Phrase(string.Empty), importedPage.Width / 2, importedPage.Height - 30,
importedPage.Width < importedPage.Height ? 0 : 1);
// Write footer
if (claimPage.ClaimId > 0)
{
ColumnText.ShowTextAligned(pageStamp.GetOverContent(), Element.ALIGN_CENTER,
new Phrase(String.Format($"Reclamo {claimPage.ClaimId}")), importedPage.Width / 2, 15,
importedPage.Width < importedPage.Height ? 0 : 1);
}
pageStamp.AlterContents();
copy.AddPage(importedPage);
}
copy.FreeReader(reader);
reader.Close();
}
document.Close();
return(ms.GetBuffer());
}
}
//public void ConvertDocumentToPDF(byte[] bytes, string pathFileOut,string pathFileOutTemp,List<Archive> ImageRoutes)
//{
// try {
// var inputAsString = Convert.ToBase64String(bytes.ToArray(), 0, bytes.ToArray().Length);
// File.WriteAllBytes(pathFileOutTemp, Convert.FromBase64String(inputAsString));
// //Incrustando Imagenes
// IncrustingImage(pathFileOutTemp, ImageRoutes,pathFileOut);
// //if (ImageRoutes != null && ImageRoutes.Count > 0)
// string textDelete = "Unlicensed version. Please register @ templater.info";
// DocumentCore document = DocumentCore.Load(pathFileOutTemp, new DocxLoadOptions());
// int countDel = 0;
// foreach (ContentRange cr in document.Content.Find(textDelete).Reverse())
// {
// cr.Delete();
// countDel++;
// }
// if (File.Exists(pathFileOut)) File.Delete(pathFileOut);
// if (ImageRoutes.Where(x=>x.typeAdjunte == TypeAdjunte.pdf).Count() > 0)
// {
// List<byte[]> listByte = new List<byte[]>();
// using (MemoryStream PDFGenerate = new MemoryStream())
// {
// document.Save(PDFGenerate, SaveOptions.PdfDefault);
// listByte.Add(PDFGenerate.ToArray());
// }
// foreach (var file in ImageRoutes.Where(x => x.typeAdjunte == TypeAdjunte.pdf))
// {
// byte[] PdfBype = null;
// if (File.Exists(file.RutaArchivo))
// {
// PdfBype = System.IO.File.ReadAllBytes(file.RutaArchivo);
// if (PdfBype != null)
// {
// listByte.Add(PdfBype);
// }
// }
// }
// byte[] PdfFinale = MergeFiles(listByte);
// var inputFinale = Convert.ToBase64String(PdfFinale.ToArray(), 0, PdfFinale.ToArray().Length);
// File.WriteAllBytes(pathFileOut, Convert.FromBase64String(inputFinale));
// }
// else
// {
// document.Save(pathFileOut);
// }
// File.Delete(pathFileOutTemp);
// }
// catch(Exception ex)
// {
// throw ex;
// }
//}
public static byte[] MergeFiles(Dictionary <int, byte[]> sourceFiles)
{
iTextSharp.text.Document document = new iTextSharp.text.Document();
using (MemoryStream ms = new MemoryStream())
{
PdfCopy copy = new PdfCopy(document, ms);
document.Open();
int documentPageCounter = 0;
sourceFiles = sourceFiles.OrderBy(x => x.Key).ToDictionary(x => x.Key, x => x.Value);
// Iterate through all pdf documents
foreach (KeyValuePair <int, byte[]> pair in sourceFiles)
{
// Create pdf reader
PdfReader reader = new PdfReader(pair.Value);
int numberOfPages = reader.NumberOfPages;
// Iterate through all pages
for (int currentPageIndex = 1; currentPageIndex <= numberOfPages; currentPageIndex++)
{
documentPageCounter++;
PdfImportedPage importedPage = copy.GetImportedPage(reader, currentPageIndex);
PdfCopy.PageStamp pageStamp = copy.CreatePageStamp(importedPage);
// Write header
ColumnText.ShowTextAligned(pageStamp.GetOverContent(), iTextSharp.text.Element.ALIGN_CENTER,
new Phrase(""), importedPage.Width / 2, importedPage.Height - 30,
importedPage.Width < importedPage.Height ? 0 : 1);
// Write footer
ColumnText.ShowTextAligned(pageStamp.GetOverContent(), iTextSharp.text.Element.ALIGN_CENTER,
new Phrase(String.Format("", documentPageCounter)), importedPage.Width / 2, 30,
importedPage.Width < importedPage.Height ? 0 : 1);
pageStamp.AlterContents();
copy.AddPage(importedPage);
}
copy.FreeReader(reader);
reader.Close();
}
document.Close();
return(ms.GetBuffer());
}
}
/// <summary>
/// Merge pdf files.
/// </summary>
/// <param name="sourceFiles">PDF files being merged.</param>
/// <returns></returns>
public static byte[] MergeFiles(List <byte[]> sourceFiles)
{
Document document = new Document();
using (MemoryStream ms = new MemoryStream())
{
PdfCopy copy = new PdfCopy(document, ms);
document.Open();
int documentPageCounter = 0;
// Iterate through all pdf documents
for (int fileCounter = 0; fileCounter < sourceFiles.Count; fileCounter++)
{
// Create pdf reader
PdfReader reader = new PdfReader(sourceFiles[fileCounter]);
int numberOfPages = reader.NumberOfPages;
// Iterate through all pages
for (int currentPageIndex = 1; currentPageIndex <= numberOfPages; currentPageIndex++)
{
documentPageCounter++;
PdfImportedPage importedPage = copy.GetImportedPage(reader, currentPageIndex);
/*
* PdfCopy.PageStamp pageStamp = copy.CreatePageStamp(importedPage);
*
* // Write header
* ColumnText.ShowTextAligned(pageStamp.GetOverContent(), Element.ALIGN_CENTER,
* new Phrase("PDF Merger by Helvetic Solutions"), importedPage.Width / 2, importedPage.Height - 30,
* importedPage.Width < importedPage.Height ? 0 : 1);
*
* // Write footer
* ColumnText.ShowTextAligned(pageStamp.GetOverContent(), Element.ALIGN_CENTER,
* new Phrase(String.Format("Page {0}", documentPageCounter)), importedPage.Width / 2, 30,
* importedPage.Width < importedPage.Height ? 0 : 1);
*
* pageStamp.AlterContents();
*/
copy.AddPage(importedPage);
}
copy.FreeReader(reader);
reader.Close();
}
document.Close();
return(ms.GetBuffer());
}
}
/// <summary>
/// Merge pdf files.
/// </summary>
/// <param name="sourceFiles">PDF files being merged.</param>
/// <returns></returns>
public static byte[] MergeFiles(List <byte[]> sourceFiles) //utiliza la librería externa para unir el string de bytes y crear una solo arreglo de byte,para conformar el nuevo pdf
{
Document document = new Document();
using (MemoryStream ms = new MemoryStream())
{
PdfCopy copy = new PdfCopy(document, ms);
document.Open();
int documentPageCounter = 0;
// Iterate through all pdf documents
for (int fileCounter = 0; fileCounter < sourceFiles.Count; fileCounter++)
{
// Create pdf reader
PdfReader reader = new PdfReader(sourceFiles[fileCounter]);
int numberOfPages = reader.NumberOfPages;
// Iterate through all pages
for (int currentPageIndex = 1; currentPageIndex <= numberOfPages; currentPageIndex++)
{
documentPageCounter++;
PdfImportedPage importedPage = copy.GetImportedPage(reader, currentPageIndex);
PdfCopy.PageStamp pageStamp = copy.CreatePageStamp(importedPage);
// Write header
ColumnText.ShowTextAligned(pageStamp.GetOverContent(), Element.ALIGN_CENTER,
new Phrase(""), importedPage.Width / 2, importedPage.Height - 30,
importedPage.Width < importedPage.Height ? 0 : 1);
// Write footer
ColumnText.ShowTextAligned(pageStamp.GetOverContent(), Element.ALIGN_CENTER,
new Phrase(String.Format("", documentPageCounter)), importedPage.Width / 2, 30,
importedPage.Width < importedPage.Height ? 0 : 1);
pageStamp.AlterContents();
copy.AddPage(importedPage);
}
copy.FreeReader(reader);
reader.Close();
}
document.Close();
return(ms.GetBuffer());
}
}
protected override void Convert(ConversionOptions options)
{
if (m_sourceFiles != null)
{
if (m_sourceFiles.Count == 1 && !m_forceConversion)
{
this.OutputFile = m_sourceFiles[0];
}
else
{
try
{
using (MemoryStream ms = new MemoryStream())
{
using (Document doc = new Document(options.Orientation == PageOrientation.Portrait ? PageSize.LETTER : PageSize.LETTER_LANDSCAPE))
{
PdfCopy copy = new PdfCopy(doc, ms);
PdfReader reader;
doc.Open();
int n;
foreach (byte[] file in m_sourceFiles)
{
if (file != null)
{
reader = new PdfReader(file);
n = reader.NumberOfPages;
for (int page = 1; page <= n; page++)
{
copy.AddPage(copy.GetImportedPage(reader, page));
}
copy.FreeReader(reader);
}
}
}
this.OutputFile = ms.ToArray();
}
}
catch (Exception ex)
{
throw new ConversionEngineException("Error when merging Pdf files.", null, "pdf", this, ex);
}
}
}
}
public static void Merge(string file, string OutFile, ref SetupStationaryFields.addresscollection aic)
{
using (FileStream stream = new FileStream(OutFile, FileMode.Create))
{
using (Document doc = new Document())
{
using (PdfCopy pdf = new PdfCopy(doc, stream))
{
doc.Open();
PdfReader reader = null;
PdfImportedPage page = null;
//fixed typo
int ii = 0;
int count = 0;
foreach (SetupStationaryFields.addressitem ai in aic)
{
if ((!ai.ommitted))
{
reader = new PdfReader(file);
PdfReader.unethicalreading = true;
count = reader.NumberOfPages;
for (int i = 0; i <= reader.NumberOfPages - 1; i++)
{
page = pdf.GetImportedPage(reader, i + 1);
pdf.AddPage(page);
}
pdf.FreeReader(reader);
reader.Close();
ai.startpage = ((ii) * count) + 1;
ai.endpage = (ii * count) + count;
ii = ii + 1;
}
}
}
}
stream.Close();
}
}
// <summary>
// This method combines pdf forms with xml data
// </summary>
// <param name="m_FormName">pdf form file path</param>
// <param name="oData">xml dataset</param>
// <returns>memory stream containing the pdf data</returns>
private MemoryStream GeneratePDF(string m_FormName, XmlDocument oData)
{
PdfReader pdfTemplate;
PdfStamper stamper;
PdfReader tempPDF;
Document doc;
MemoryStream msTemp;
PdfWriter pCopy;
MemoryStream msOutput = new MemoryStream();
pdfTemplate = new PdfReader(m_FormName);
doc = new Document();
pCopy = new PdfCopy(doc, msOutput);
pCopy.AddViewerPreference(PdfName.PICKTRAYBYPDFSIZE, new PdfBoolean(true));
pCopy.AddViewerPreference(PdfName.PRINTSCALING, PdfName.NONE);
doc.Open();
for (int i = 1; i < pdfTemplate.NumberOfPages + 1; i++)
{
msTemp = new MemoryStream();
pdfTemplate = new PdfReader(m_FormName);
stamper = new PdfStamper(pdfTemplate, msTemp);
// map xml values to pdf form controls (element name = control name)
foreach (XmlElement oElem in oData.SelectNodes("/Users/User"))
{
stamper.AcroFields.SetField(oElem.Name, oElem.InnerText);
}
stamper.FormFlattening = true;
stamper.Close();
tempPDF = new PdfReader(msTemp.ToArray());
((PdfCopy)pCopy).AddPage(pCopy.GetImportedPage(tempPDF, i));
pCopy.FreeReader(tempPDF);
}
doc.Close();
return(msOutput);
}
public byte[] PDF_Merger(List <string> li, string PrintedName)
{
List <byte[]> sourceFiles = FileReadIn(li);
Document document = new Document();
using (MemoryStream ms = new MemoryStream())
{
PdfCopy copy = new PdfCopy(document, ms);
document.Open();
int documentPageCounter = 0;
// Iterate through all pdf documents
for (int fileCounter = 0; fileCounter < sourceFiles.Count; fileCounter++)
{
// Create pdf reader
PdfReader reader = new PdfReader(sourceFiles[fileCounter]);
int numberOfPages = reader.NumberOfPages;
// Iterate through all pages
for (int currentPageIndex = 1; currentPageIndex <= numberOfPages; currentPageIndex++)
{
documentPageCounter++;
PdfImportedPage importedPage = copy.GetImportedPage(reader, currentPageIndex);
PdfCopy.PageStamp pageStamp = copy.CreatePageStamp(importedPage);
pageStamp.AlterContents();
copy.AddPage(importedPage);
}
copy.FreeReader(reader);
reader.Close();
}
document.Close();
if (PrintedName == "")
{
PrintedName = "PM Merger Document ";
}
DateTime thisDay = DateTime.Today;
System.IO.Directory.CreateDirectory(FolderUrl + "\\Merged Documents");
System.IO.File.WriteAllBytes(FolderUrl + "\\Merged Documents\\" + PrintedName + " ( " + thisDay.ToString("yyyy. MM. dd.") + " ).pdf", ms.GetBuffer());
Process.Start(FolderUrl + "\\Merged Documents");
return(ms.GetBuffer());
}
}
public string ProductQuoteToSmallPdf(ProductQuote productQuote, string productQuoteSmallPdfTemplate)
{
string fileTemplate = Path.Combine(CommonHelper.MapPath("~/Documents/Templates"), productQuoteSmallPdfTemplate);
string fileNameExport = string.Format("{0}_{1}_{2}.pdf", productQuote.ProductQuoteCode, "Rev08", Guid.NewGuid().ToString().Substring(0, 8));
string fileExport = Path.Combine(CommonHelper.MapPath("~/Documents/Export"), fileNameExport);
PdfReader reader = new PdfReader(fileTemplate);
FileStream fs = new FileStream(fileExport, FileMode.Create, FileAccess.Write);
iTextSharp.text.Rectangle size = reader.GetPageSizeWithRotation(1);
Document document = new Document(size);
PdfCopy copy = new PdfCopy(document, fs);
document.Open();
PdfImportedPage page = null;
for (int i = 1; i <= reader.NumberOfPages; i++)
{
page = copy.GetImportedPage(reader, i);
//En la primer pagina ponemos los datos
if (i == 1)
{
PdfCopy.PageStamp pageStamp = copy.CreatePageStamp(page);
StampDataIntoSmallPdf(pageStamp, productQuote);
pageStamp.AlterContents();
}
PdfCopy.PageStamp pageStampFooter = copy.CreatePageStamp(page);
StampFooterDataIntoPdf(pageStampFooter, productQuote.ProductQuoteSmallPDFFooter);
pageStampFooter.AlterContents();
copy.AddPage(page);
}
copy.FreeReader(reader);
document.Close();
reader.Close();
return(fileNameExport);
}
// ---------------------------------------------------------------------------
public void Write(Stream stream)
{
MovieLinks1 ml = new MovieLinks1();
MovieHistory mh = new MovieHistory();
List <byte[]> pdf = new List <byte[]>()
{
Utility.PdfBytes(ml),
Utility.PdfBytes(mh)
};
string[] names = { ml.ToString(), mh.ToString() };
using (ZipFile zip = new ZipFile())
{
using (MemoryStream ms = new MemoryStream())
{
// step 1
using (Document document = new Document())
{
// step 2
using (PdfCopy copy = new PdfCopy(document, ms))
{
// step 3
document.Open();
// step 4
for (int i = 0; i < pdf.Count; ++i)
{
zip.AddEntry(Utility.ResultFileName(names[i] + ".pdf"), pdf[i]);
PdfReader reader = new PdfReader(pdf[i]);
// loop over the pages in that document
int n = reader.NumberOfPages;
for (int page = 0; page < n;)
{
copy.AddPage(copy.GetImportedPage(reader, ++page));
}
copy.FreeReader(reader);
reader.Close();
}
}
}
zip.AddEntry(RESULT, ms.ToArray());
}
zip.Save(stream);
}
}
