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 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));
}
}
private async Task CompareDownloadedStreamToFile(string pathToFileToCompare, DocumentFormatReader documentFormatReader)
{
using (var downloaded = new MemoryStream())
using (var uploaded = new MemoryStream())
{
using (var fileStream = File.OpenRead(pathToFileToCompare))
{
await fileStream.CopyToAsync(uploaded).ConfigureAwait(false);
}
await(await documentFormatReader.OpenStream()).CopyToAsync(downloaded);
Assert.IsTrue(CompareMemoryStreams(uploaded, downloaded),
"Downloaded format is not equal to last format uploaded");
}
}
public async Task Should_upload_with_a_stream()
{
var handle = DocumentHandle.FromString("Pdf_4");
using (var stream = File.OpenRead(TestConfig.PathToDocumentPdf))
{
var response = await _documentStoreClient.UploadAsync(
"demo.pdf",
handle,
stream
);
Assert.AreEqual("8fe8386418f85ef4ee8ef1f3f1117928", response.Hash);
Assert.AreEqual("md5", response.HashType);
Assert.AreEqual("http://localhost:5123/tests/documents/pdf_4", response.Uri);
}
}
protected async override Task <ProcessResult> OnPolling(PollerJobParameters parameters, string workingFolder)
{
var fileExtension = parameters.All[JobKeys.ThumbnailFormat];
ImageFormat format = GetFormatFromExtension(fileExtension);
var sizesAsString = parameters.All[JobKeys.Sizes];
var imageSizes = SizeInfoHelper.Deserialize(sizesAsString);
Logger.DebugFormat("Starting resize job for {0} - {1}", parameters.JobId, sizesAsString);
string pathToFile = await DownloadBlob(parameters.TenantId, parameters.JobId, parameters.FileName, workingFolder);
using (var sourceStream = File.OpenRead(pathToFile))
{
using (var pageStream = new MemoryStream())
{
sourceStream.CopyTo(pageStream);
foreach (var size in imageSizes)
{
Logger.DebugFormat("Resize job for {0} - {1}", parameters.JobId, size.Name);
pageStream.Seek(0, SeekOrigin.Begin);
var fileFormat = new Client.Model.DocumentFormat("thumb." + size.Name);
string resizeImagePath = Path.Combine(
workingFolder,
String.Format("{0}.{1}.{2}", Path.GetFileNameWithoutExtension(parameters.FileName), size.Name, fileExtension));
resizeImagePath = SanitizeFileNameForLength(resizeImagePath);
using (var outStream = File.OpenWrite(resizeImagePath))
{
Logger.DebugFormat("Resizing {0}", parameters.JobId);
ImageResizer.Shrink(pageStream, outStream, size.Width, size.Height, format);
}
await AddFormatToDocumentFromFile(
parameters.TenantId,
parameters.JobId,
fileFormat,
resizeImagePath, new Dictionary <string, object>());
}
}
}
Logger.DebugFormat("Ended resize job for {0} - {1}", parameters.JobId, sizesAsString);
return(ProcessResult.Ok);
}
public async Task <Boolean> Run(
String pathToFile,
CreatePdfImageTaskParams createPdfImageTaskParams,
Func <int, Stream, Task <Boolean> > pageWriter)
{
String tempFileName = null;
if (Passwords.Count > 0)
{
tempFileName =
Path.Combine(Path.GetDirectoryName(pathToFile),
Path.GetFileNameWithoutExtension(pathToFile) + "_decrypted.pdf");
if (Decryptor.DecryptFile(pathToFile, tempFileName, Passwords))
{
pathToFile = tempFileName;
}
}
using (var sourceStream = File.OpenRead(pathToFile))
{
var settings = new MagickReadSettings
{
Density = new PointD(createPdfImageTaskParams.Dpi, createPdfImageTaskParams.Dpi)
};
settings.FrameIndex = 0; // First page
settings.FrameCount = 1; // Number of pages
MagickFormat imageFormat = TranslateFormat(createPdfImageTaskParams.Format);
Logger.DebugFormat("Image format is {0}", imageFormat.ToString());
using (var images = new MagickImageCollection())
{
bool done = false;
if (!_firstDone)
{
lock (LockForInitializationIssue)
{
if (!_firstDone)
{
images.Read(sourceStream, settings);
done = true;
}
}
}
if (!done)
{
images.Read(sourceStream, settings);
}
var lastImage =
Math.Min(createPdfImageTaskParams.FromPage - 1 + createPdfImageTaskParams.Pages, images.Count) -
1;
for (int page = createPdfImageTaskParams.FromPage - 1; page <= lastImage; page++)
{
var image = images[page];
image.Format = imageFormat;
using (var ms = new MemoryStream())
{
image.Write(ms);
ms.Seek(0L, SeekOrigin.Begin);
await pageWriter(page + 1, ms).ConfigureAwait(false);
}
}
}
}
if (!String.IsNullOrEmpty(tempFileName) && File.Exists(tempFileName))
{
File.Delete(tempFileName);
}
return(true);
}
