public Boolean Convert(String inputFileName, String outputFileName)
{
try
{
var text = File.ReadAllText(inputFileName);
// Create a MigraDoc document
Document document = new Document();
var section = document.AddSection();
var paragraph = section.AddParagraph();
paragraph.Format.Font.Size = 12;
paragraph.AddFormattedText(text);
PdfDocumentRenderer pdfRenderer = new PdfDocumentRenderer(unicode, embedding);
pdfRenderer.Document = document;
pdfRenderer.RenderDocument();
pdfRenderer.PdfDocument.Save(outputFileName);
return(true);
}
catch (Exception ex)
{
Logger.WarnFormat(ex, "Error converting file {0} to Pdf.", inputFileName);
return(false);
}
}
public void Verify_sanitize_of_single_mhtml_file()
{
var tempFile = Path.ChangeExtension(Path.GetTempFileName(), ".mht");
File.Copy(TestConfig.PathToMht, tempFile);
string mhtml = File.ReadAllText(tempFile);
MHTMLParser parser = new MHTMLParser(mhtml)
{
OutputDirectory = Path.GetDirectoryName(tempFile),
DecodeImageData = true
};
var outFile = Path.ChangeExtension(tempFile, ".html");
File.WriteAllText(outFile, parser.getHTMLText());
_sanitizer = new SafeHtmlConverter(outFile)
{
Logger = NullLogger.Instance
};
var result = _sanitizer.Run("jobtest");
Assert.That(File.Exists(result), "Output pdf file not created");
File.Delete(result);
}
internal Boolean DecryptFile(
string inputFile,
string outputFile,
IEnumerable <string> userPasswords)
{
foreach (var pwd in userPasswords)
{
try
{
using (var reader = new PdfReader(inputFile, new ASCIIEncoding().GetBytes(pwd)))
{
reader.GetType().Field("encrypted").SetValue(reader, false);
using (var outStream = File.OpenWrite(outputFile))
{
using (var stamper = new PdfStamper(reader, outStream))
{
stamper.Close();
}
}
}
return(true);
}
catch (Exception ex)
{
Logger.ErrorFormat(ex, "Error trying to decrypt file {0}: {1}", inputFile, ex.Message);
}
}
return(false);
}
private void TestWordFile(
List <PollerTestResult> retValue,
String fileName,
String type,
Byte[] fileContent)
{
try
{
OfficeUtils.KillOfficeProcess("WINWORD");
var tempFile = Path.Combine(Path.GetTempPath(), fileName);
if (File.Exists(tempFile))
{
File.Delete(tempFile);
}
File.WriteAllBytes(tempFile, fileContent);
var conversionError = WordConverter.ConvertToPdf(tempFile, tempFile + ".pdf");
if (!String.IsNullOrEmpty(conversionError))
{
retValue.Add(new PollerTestResult(false, type + "Conversion with word converter failed: " + conversionError));
}
else
{
retValue.Add(new PollerTestResult(true, type + "Conversion with word ok."));
}
}
catch (Exception ex)
{
retValue.Add(new PollerTestResult(false, type + "Conversion with word converter failed: " + ex.Message));
}
}
protected async override Task <ProcessResult> OnPolling(PollerJobParameters parameters, string workingFolder)
{
string pathToFile = await DownloadBlob(parameters.TenantId, parameters.JobId, parameters.FileName, workingFolder).ConfigureAwait(false);
String fileName = Path.Combine(Path.GetDirectoryName(pathToFile), parameters.All[JobKeys.FileName]);
Logger.DebugFormat("Move blob id {0} to real filename {1}", pathToFile, fileName);
if (File.Exists(fileName))
{
File.Delete(fileName);
}
File.Copy(pathToFile, fileName);
var converter = new HtmlToPdfConverterFromDiskFile(fileName, base.JobsHostConfiguration)
{
Logger = Logger
};
var pdfConvertedFileName = converter.Run(parameters.TenantId, parameters.JobId);
await AddFormatToDocumentFromFile(
parameters.TenantId,
parameters.JobId,
new DocumentFormat(DocumentFormats.Pdf),
pdfConvertedFileName,
new Dictionary <string, object>()).ConfigureAwait(false);
return(ProcessResult.Ok);
}
string DownloadLocalCopy(String tenantId, String jobId)
{
Logger.DebugFormat("Downloaded {0}", _inputFileName);
if (IsUnzippedHtmlFile())
{
return(_inputFileName);
}
var workingFolder = Path.GetDirectoryName(_inputFileName);
ZipFile.ExtractToDirectory(_inputFileName, workingFolder);
Logger.DebugFormat("Extracted zip to {0}", workingFolder);
var htmlFile = Path.ChangeExtension(_inputFileName, "html");
if (File.Exists(htmlFile))
{
Logger.DebugFormat("Html file is {0}", htmlFile);
return(htmlFile);
}
htmlFile = Path.ChangeExtension(_inputFileName, "htm");
if (File.Exists(htmlFile))
{
Logger.DebugFormat("Html file is {0}", htmlFile);
return(htmlFile);
}
var msg = string.Format("Html file not found for {0}!", jobId);
Logger.Error(msg);
throw new Exception(msg);
}
private void TestPowerPointFile(
List <PollerTestResult> retValue,
String fileName,
String type,
Byte[] fileContent)
{
try
{
var tempFile = Path.Combine(Path.GetTempPath(), fileName);
if (File.Exists(tempFile))
{
File.Delete(tempFile);
}
File.WriteAllBytes(tempFile, fileContent);
var conversionError = PowerPointConverter.ConvertToPdf(tempFile, tempFile + ".pdf");
if (!String.IsNullOrEmpty(conversionError))
{
retValue.Add(new PollerTestResult(false, type + "Conversion with powerpoint converter failed:" + conversionError));
}
else
{
retValue.Add(new PollerTestResult(true, type + "Conversion with powerpoint ok."));
}
}
catch (Exception ex)
{
retValue.Add(new PollerTestResult(false, type + "Conversion with powerpoint converter failed: " + ex.Message));
}
}
public BlobId Upload(DocumentFormat format, string pathToFile)
{
using (var inStream = File.OpenRead(pathToFile))
{
return(Upload(format, new FileNameWithExtension(Path.GetFileName(pathToFile)), inStream));
}
}
public async Task can_upload_document_with_name_greater_than_250_char()
{
var handle = DocumentHandle.FromString("Pdf_3");
String longFileName = Path.Combine(
Path.GetTempPath(),
"_lfn" + new string('X', 240) + ".pdf");
if (!File.Exists(longFileName))
{
File.Copy(TestConfig.PathToDocumentPdf, longFileName);
}
await _documentStoreClient.UploadAsync(longFileName, handle);
// wait background projection polling
await UpdateAndWaitAsync().ConfigureAwait(false);
// check readmodel
var tenantAccessor = ContainerAccessor.Instance.Resolve <ITenantAccessor>();
var tenant = tenantAccessor.GetTenant(new TenantId(TestConfig.Tenant));
var docReader = tenant.Container.Resolve <IMongoDbReader <DocumentDescriptorReadModel, DocumentDescriptorId> >();
var allDocuments = docReader.AllUnsorted.Count();
Assert.AreEqual(1, allDocuments);
}
private void TestFile(
List <PollerTestResult> retValue,
String fileName,
String type,
Byte[] fileContent)
{
String converter = Conversion.GetType().Name;
try
{
var tempFile = Path.Combine(Path.GetTempPath(), fileName);
if (File.Exists(tempFile))
{
File.Delete(tempFile);
}
File.WriteAllBytes(tempFile, fileContent);
string content = Conversion.Run(tempFile, "pdf");
if (!String.IsNullOrEmpty(content))
{
retValue.Add(new PollerTestResult(true, type + " conversion with converter: " + converter));
}
else
{
retValue.Add(new PollerTestResult(false, type + " conversion: wrong content with converter: " + converter));
}
}
catch (Exception ex)
{
retValue.Add(new PollerTestResult(false, type + " conversion with converter " + converter + ex.Message));
}
}
private static void TestFile(
List <PollerTestResult> retValue,
ITikaAnalyzer analyzer,
String fileName,
String type,
String expected,
Byte[] fileContent)
{
var tempFile = Path.Combine(Path.GetTempPath(), fileName);
if (File.Exists(tempFile))
{
File.Delete(tempFile);
}
File.WriteAllBytes(tempFile, fileContent);
try
{
string content = analyzer.GetHtmlContent(tempFile, "");
if (content.Contains(expected))
{
retValue.Add(new PollerTestResult(true, type + " conversion"));
}
else
{
retValue.Add(new PollerTestResult(false, type + " conversion: wrong content"));
}
}
catch (Exception ex)
{
retValue.Add(new PollerTestResult(false, type + " conversion: " + ex.Message));
}
}
public async Task Should_upload_and_download_original_format()
{
await _documentStoreClient.UploadAsync(
TestConfig.PathToDocumentPdf,
DocumentHandle.FromString("Pdf_2"),
new Dictionary <string, object> {
{ "callback", "http://localhost/demo" }
}
);
// waits for storage
await UpdateAndWaitAsync().ConfigureAwait(false);
var reader = _documentStoreClient.OpenRead(DocumentHandle.FromString("Pdf_2"));
using (var downloaded = new MemoryStream())
using (var uploaded = new MemoryStream())
{
using (var fileStream = File.OpenRead(TestConfig.PathToDocumentPdf))
{
await fileStream.CopyToAsync(uploaded).ConfigureAwait(false);
}
await(await reader.OpenStream()).CopyToAsync(downloaded);
Assert.IsTrue(CompareMemoryStreams(uploaded, downloaded));
}
}
/// <summary>
/// Elaborate
/// </summary>
/// <param name="tenantId"></param>
/// <param name="jobId"></param>
/// <returns></returns>
public String Run(String tenantId, String jobId)
{
Logger.DebugFormat("Converting {0} to pdf", jobId);
var localFileName = DownloadLocalCopy(tenantId, jobId);
var outputFileName = localFileName + ".pdf";
var uri = new Uri(localFileName);
var document = new HtmlToPdfDocument
{
GlobalSettings =
{
ProduceOutline = ProduceOutline,
PaperSize = PaperKind.A4, // Implicit conversion to PechkinPaperSize
Margins =
{
All = 1.375,
Unit = Unit.Centimeters
},
OutputFormat = GlobalSettings.DocumentOutputFormat.PDF
},
Objects =
{
new ObjectSettings
{
PageUrl = uri.AbsoluteUri,
WebSettings = new WebSettings()
{
EnableJavascript = false,
PrintMediaType = false
}
},
}
};
//This is the thread safe converter
//it seems sometimes to hang forever during tests.
//https://github.com/tuespetre/TuesPechkin
//IConverter converter =
// new ThreadSafeConverter(
// new PdfToolset(
// new Win32EmbeddedDeployment(
// new TempFolderDeployment())));
//Standard, non thread safe converter.
IConverter converter =
new StandardConverter(
new PdfToolset(
new Win32EmbeddedDeployment(
new TempFolderDeployment())));
var pdf = converter.Convert(document);
File.WriteAllBytes(outputFileName, pdf);
Logger.DebugFormat("Deleting {0}", localFileName);
File.Delete(localFileName);
Logger.DebugFormat("Conversion of {0} to pdf done!", jobId);
return(outputFileName);
}
public void correctly_delete_file_after_import()
{
_queue.DeleteTaskFileAfterImport = true;
var descriptor = _queue.LoadTask(_pathToTask);
_queue.UploadFile(_pathToTask, descriptor);
Assert.That(File.Exists(_pathToTask), Is.False);
}
public void Delete(BlobId blobId)
{
var fileName = _directoryManager.GetFileNameFromBlobId(blobId);
File.Delete(fileName);
_blobDescriptorCollection.RemoveById(blobId);
}
public void Delete(BlobId blobId)
{
var descriptorLocalFileName = _directoryManager.GetDescriptorFileNameFromBlobId(blobId);
if (File.Exists(descriptorLocalFileName))
{
File.Delete(descriptorLocalFileName);
}
}
public void Upload_list_files_in_temp()
{
var fileList = File.ReadAllText(@"c:\temp\filelist.txt");
foreach (var line in fileList.Split('\n'))
{
FileInfo finfo = new FileInfo(line);
_docs.UploadAsync(finfo.FullName, DocumentHandle.FromString(finfo.Name)).Wait();
}
}
private void ClearQueueTempFolder()
{
if (Directory.Exists(longFolderName))
{
foreach (var file in Directory.GetFiles(longFolderName))
{
File.SetAttributes(file, FileAttributes.Archive);
}
Directory.Delete(longFolderName, true);
}
}
private static void ClearQueueTempFolder()
{
if (Directory.Exists(TestConfig.QueueFolder))
{
foreach (var file in Directory.GetFiles(TestConfig.QueueFolder))
{
File.SetAttributes(file, FileAttributes.Archive);
}
Directory.Delete(TestConfig.QueueFolder, true);
}
}
public void processing_file_should_succeed(string blobId)
{
var s = new Stopwatch();
s.Start();
var fileName = _withLibreOfficeConversion.Run(_mapping[blobId], "pdf");
s.Stop();
File.Delete(fileName);
Debug.WriteLine("{0} conversion took {1} ms", blobId, s.ElapsedMilliseconds);
}
public void SaveDescriptor(FileSystemBlobDescriptor fileSystemBlobDescriptor)
{
if (fileSystemBlobDescriptor == null)
{
throw new ArgumentNullException(nameof(fileSystemBlobDescriptor));
}
var fileName = _directoryManager.GetDescriptorFileNameFromBlobId(fileSystemBlobDescriptor.BlobId);
File.WriteAllText(fileName, JsonConvert.SerializeObject(fileSystemBlobDescriptor));
}
public void Verify_preview_of_single_html_file()
{
var tempFile = Path.ChangeExtension(Path.GetTempFileName(), ".html");
File.Copy(TestConfig.PathToSimpleHtmlFile, tempFile);
_converter = new HtmlToPdfConverterFromDiskFileOld(tempFile, _config);
_converter.Logger = NullLogger.Instance;
var result = _converter.Run("jobtest");
Assert.That(File.Exists(result), "Output pdf file not created");
File.Delete(result);
}
private static string SanitizeFileName(string inputFile)
{
if (inputFile.Contains("%"))
{
//percentage sign create trouble
var sanitizeFileName = inputFile.Replace("%", "_");
File.Move(inputFile, sanitizeFileName);
inputFile = sanitizeFileName;
}
return(inputFile);
}
public void parallel_conversion_should_not_throw_exceptions()
{
Parallel.ForEach(
_mapping.Keys,
// new ParallelOptions() { MaxDegreeOfParallelism = 2 },
k =>
{
var fileName = _unoConversion.Run(_mapping[k], "pdf");
File.Delete(fileName);
}
);
}
/// <summary>
/// Elaborate
/// </summary>
/// <param name="tenantId"></param>
/// <param name="jobId"></param>
/// <returns></returns>
public String Run(String jobId)
{
Logger.DebugFormat("Converting {0} to pdf", jobId);
var localFileName = DownloadLocalCopy(jobId);
var sanitizer = new SafeHtmlConverter(localFileName)
{
Logger = Logger
};
localFileName = sanitizer.Run(jobId);
var outputFileName = localFileName + ".pdf";
var uri = new Uri(localFileName);
var document = new HtmlToPdfDocument
{
GlobalSettings =
{
ProduceOutline = ProduceOutline,
PaperSize = PaperKind.A4, // Implicit conversion to PechkinPaperSize
Margins =
{
All = 1.375,
Unit = Unit.Centimeters
},
OutputFormat = GlobalSettings.DocumentOutputFormat.PDF
},
Objects =
{
new ObjectSettings
{
PageUrl = uri.AbsoluteUri,
WebSettings = new WebSettings()
{
EnableJavascript = false,
PrintMediaType = false
}
},
}
};
var converter = Factory.Create();
var pdf = converter.Convert(document);
File.WriteAllBytes(outputFileName, pdf);
Logger.DebugFormat("Deleting {0}", localFileName);
File.Delete(localFileName);
Logger.DebugFormat("Conversion of {0} to pdf done!", jobId);
return(outputFileName);
}
protected async override Task <ProcessResult> OnPolling(PollerJobParameters parameters, string workingFolder)
{
string pathToFile = await DownloadBlob(parameters.TenantId, parameters.JobId, parameters.FileName, workingFolder).ConfigureAwait(false);
//String fileName = Path.Combine(Path.GetDirectoryName(pathToFile), parameters.All[JobKeys.FileName]);
//Logger.DebugFormat("Move blob id {0} to real filename {1}", pathToFile, fileName);
//if (File.Exists(fileName)) File.Delete(fileName);
//File.Copy(pathToFile, fileName);
if (Logger.IsDebugEnabled)
{
Logger.DebugFormat("Conversion of HtmlZip to PDF: file {0}", pathToFile);
}
var file = pathToFile;
if (pathToFile.EndsWith(".mht", StringComparison.OrdinalIgnoreCase) || pathToFile.EndsWith(".mhtml", StringComparison.OrdinalIgnoreCase))
{
string mhtml = File.ReadAllText(pathToFile);
MHTMLParser parser = new MHTMLParser(mhtml)
{
OutputDirectory = workingFolder,
DecodeImageData = true
};
var outFile = Path.ChangeExtension(pathToFile, ".html");
File.WriteAllText(outFile, parser.getHTMLText());
file = outFile;
}
var sanitizer = new SafeHtmlConverter(file)
{
Logger = Logger
};
file = sanitizer.Run(parameters.JobId);
var converter = new HtmlToPdfConverterFromDiskFile(file, base.JobsHostConfiguration)
{
Logger = Logger
};
var pdfConvertedFileName = converter.Run(parameters.TenantId, parameters.JobId);
await AddFormatToDocumentFromFile(
parameters.TenantId,
parameters.JobId,
new DocumentFormat(DocumentFormats.Pdf),
pdfConvertedFileName,
new Dictionary <string, object>()).ConfigureAwait(false);
return(ProcessResult.Ok);
}
public void what_happens_if_task_file_cannot_be_deleted()
{
_queue.DeleteTaskFileAfterImport = true;
var attribute = File.GetAttributes(_pathToTask);
File.SetAttributes(_pathToTask, attribute | FileAttributes.ReadOnly);
_queue.PollFileSystem();
Assert.That(File.Exists(_pathToTask), Is.True); //file cannot be deleted
_commandBus.Received(1).Send(Arg.Any <ICommand>(), "import-from-file");
_queue.PollFileSystem();
_commandBus.Received(1).Send(Arg.Any <ICommand>(), "import-from-file");
}
public void Verify_sanitize_of_single_html_file()
{
var tempFile = Path.ChangeExtension(Path.GetTempFileName(), ".html");
File.Copy(TestConfig.PathToSimpleHtmlFile, tempFile);
_sanitizer = new SafeHtmlConverter(tempFile)
{
Logger = NullLogger.Instance
};
var result = _sanitizer.Run("jobtest");
Assert.That(File.Exists(result), "HTML file sanitized");
File.Delete(result);
}
private string GetFileNameFromBlobIdAndRemoveDuplicates(BlobId blobId)
{
var fileName = _directoryManager.GetFileNameFromBlobId(blobId);
if (File.Exists(fileName))
{
//Anomaly, we are trying to overwrite the blob
Logger.Warn($"Destination file {blobId} already exists for id {blobId}");
//Todo move in another folder ... maybe a lost and found.
File.Move(fileName, fileName + "." + Guid.NewGuid().ToString());
}
return(fileName);
}
public void SetUp()
{
longFolderName = Path.Combine(Path.GetTempPath(), new String('a', 230));
_blobId = new BlobId(_originalFormat, 1);
_pathToTask = Path.Combine(longFolderName, "File_1.dsimport");
_fileToImport = Path.Combine(longFolderName, "A Word Document.docx");
_fileUri = new Uri(Path.Combine(longFolderName, "A word document.docx"));
ClearQueueTempFolder();
Directory.CreateDirectory(longFolderName);
File.Copy(Path.Combine(TestConfig.DocumentsFolder, "Queue\\File_1.dsimport"), _pathToTask);
File.Copy(TestConfig.PathToWordDocument, _fileToImport);
var accessor = Substitute.For <ITenantAccessor>();
var tenant = Substitute.For <ITenant>();
tenant.Id.Returns(new TenantId("tests"));
var container = Substitute.For <IWindsorContainer>();
_commandBus = Substitute.For <ICommandBus>();
var identityGenerator = Substitute.For <IIdentityGenerator>();
_blobstore = Substitute.For <IBlobStore>();
_blobstore.Upload(Arg.Is(_originalFormat), Arg.Any <string>()).Returns(_blobId);
_blobstore.Upload(Arg.Is(_originalFormat), Arg.Any <FileNameWithExtension>(), Arg.Any <Stream>()).Returns(_blobId);
accessor.GetTenant(_testTenant).Returns(tenant);
accessor.Current.Returns(tenant);
tenant.Container.Returns(container);
container.Resolve <IBlobStore>().Returns(_blobstore);
container.Resolve <IIdentityGenerator>().Returns(identityGenerator);
container.Resolve <IMongoDatabase>().Returns(MongoDbTestConnectionProvider.ReadModelDb);
var collection = MongoDbTestConnectionProvider.ReadModelDb.GetCollection <ImportFailure>("sys.importFailures");
collection.Drop();
DocumentStoreTestConfiguration config = new DocumentStoreTestConfiguration(tenantId: "tests");
config.SetFolderToMonitor(longFolderName);
var sysDb = config.TenantSettings.Single(t => t.TenantId == "tests").Get <IMongoDatabase>("system.db");
sysDb.Drop();
_queue = new ImportFormatFromFileQueue(config, accessor, _commandBus)
{
Logger = new ConsoleLogger()
};
_queue.DeleteTaskFileAfterImport = false;
}
