public void DownloadDocument(DocumentInfo document, string path)
{
var request = new DownloadDocumentRequest
{
OidDocument = document.OidDocument,
Version = document.Version,
ChunkNumber = 0,
ChunkSize = GetChunkSize()
};
DownloadDocumentResponse response = _flowDocsService.DownloadDocument(request);
var filePath = Path.Combine(path, response.DocumentName);
document.DocumentName = filePath;
document.Description = response.Description;
document.Owner = response.Owner;
document.Path = response.Path;
document.MimeType = response.MimeType;
document.FileHash = response.FileHash;
using (var writer = new FileStream(filePath, FileMode.Create))
{
int chunks = 0;
writer.Write(response.DataField, 0, response.ChunkSize);
request.ChunkNumber = ++chunks;
while (chunks < response.ChunkTotal)
{
response = _flowDocsService.DownloadDocument(request);
writer.Write(response.DataField, 0, response.ChunkSize);
request.ChunkNumber = ++chunks;
}
}
}
public DownloadDocumentResponse DownloadDocument(DownloadDocumentRequest request)
{
if (request == null)
{
throw new ArgumentNullException("request");
}
DownloadDocumentResponse response = null;
var httpResponse = SendGetRequest(request, "DownloadDocument");
//The DownloadDocument endpoint will return either the file as an attachment, or a JSON object if there was an error.
//DispositionType will be attachment if file was successfully returned.
if (httpResponse.Content.Headers.ContentDisposition != null && httpResponse.Content.Headers.ContentDisposition.DispositionType == "attachment")
{
response = new DownloadDocumentResponse
{
FileStream = httpResponse.Content.ReadAsStreamAsync().Result,
FileName = httpResponse.Content.Headers.ContentDisposition.FileName
};
}
else
{
//File was not successfully returned, check for JSON response instead
response = LoadResponse <DownloadDocumentResponse>(httpResponse);
}
response.DocumentID = request.DocumentID;
return(response);
}
/// <summary>
/// Get Document
/// </summary>
/// <param name="uow">Uow</param>
/// <param name="request">Request</param>
/// <param name="document">Document</param>
/// <returns>Document Id</returns>
private int GetDocument(IFlowDocsUnitOfWork uow, DownloadDocumentRequest request, ref Document document)
{
var docs = from d in uow.Documents.AsQueryable()
where d.OidDocument == request.OidDocument
orderby d.Version descending
select d;
Document doc = docs.FirstOrDefault();
List <Document> listOfDocs = new List <Document>();
while (doc != null)
{
listOfDocs.Add(doc);
doc = doc.DocumentPrevious;
}
if (request.Mode == DocumentDownloadMode.SpecifiedVersion)
{
doc = listOfDocs.Where(d => d.Version == request.Version).FirstOrDefault();
}
if (doc == null || request.Mode == DocumentDownloadMode.LastVersion)
{
doc = docs.First();
}
var dbId = uow.Attachments.First(a => a.DocumentId == doc.DocumentId);
document = doc;
return(dbId.AttachmentId);
}
/// <summary>
/// Download Document. It calls the abstract method to perform the operation
/// </summary>
/// <param name="request">Request</param>
/// <returns>Response</returns>
public DownloadDocumentResponse DownloadDocument(DownloadDocumentRequest request)
{
if (request.OidDocument == Guid.Empty)
{
throw new ArgumentException("OidDocument should not be empty");
}
DownloadDocumentResponse response = null;
DownloadChunk(request, ref response);
return(response);
}
/// <summary>
/// Download Chunk
/// </summary>
/// <param name="request">Request</param>
/// <param name="response">Response</param>
override protected void DownloadChunk(DownloadDocumentRequest request, ref DownloadDocumentResponse response)
{
if (FlowDocsUnitOfWork != null)
{
DownloadChunk(FlowDocsUnitOfWork, request, ref response);
}
else
{
using (var uow = new FlowDocsUnitOfWork())
{
DownloadChunk(uow, request, ref response);
}
}
}
public DownloadDocumentResponse DownloadDocument(string documentID, string merchantSessionID)
{
if (documentID == null)
{
throw new ArgumentNullException("documentID");
}
var request = new DownloadDocumentRequest
{
DocumentID = documentID,
MerchantSessionID = merchantSessionID
};
return(DownloadDocument(request));
}
/// <summary>
/// Download Chunk
/// </summary>
/// <param name="uow">Uow</param>
/// <param name="request">Request</param>
/// <param name="response">Response</param>
private void DownloadChunk(IFlowDocsUnitOfWork uow, DownloadDocumentRequest request, ref DownloadDocumentResponse response)
{
Document doc = null;
int identity = 0;
identity = GetDocument(uow, request, ref doc);
response = new DownloadDocumentResponse();
response.DocumentName = doc.DocumentName;
response.Version = doc.Version;
response.Description = doc.Description;
response.Owner = doc.Owner;
response.Path = doc.Path;
response.MimeType = doc.MimeType;
response.FileSize = doc.FileSize;
SqlServerBlobStream blob = null;
try
{
if (_provider.OpenProcedure != null && _provider.ReadProcedure != null)
{
blob = new SqlServerBlobStream(
_provider.ConnectionString, identity, _provider.OpenProcedure, _provider.ReadProcedure, FileAccess.Read);
}
else
{
blob = new SqlServerBlobStream(
_provider.ConnectionString, _provider.TableName, _provider.DataColumnName, identity,
_provider.FileNameColumnName, _provider.MIMETypeColumnName, FileAccess.Read);
}
blob.Seek(request.ChunkNumber * request.ChunkSize, SeekOrigin.Begin);
response.DataField = new byte[request.ChunkSize];
response.ChunkSize = blob.Read(response.DataField, 0, request.ChunkSize);
response.ChunkNumber = request.ChunkNumber;
response.ChunkTotal = (int)Math.Ceiling((decimal)blob.Length / request.ChunkSize);
response.FileHash = Md5Hash.CreateMd5Hash(response.DataField);
}
finally
{
if (blob != null)
{
blob.Close();
//blob.Dispose();
}
}
}
public async Task <Result <HttpResponseMessage> > DownloadDocument(DownloadDocumentRequest request)
{
const string api = "api/Factory/DownloadDocument";
NameValueCollection query = HttpUtility.ParseQueryString(string.Empty);
if (request.DocumentId != null)
{
query["documentId"] = request.DocumentId;
}
if (request.Uri != null)
{
query["uri"] = request.Uri.ToString();
}
query["includeAnnotations"] = request.IncludeAnnotations.ToString();
if (!string.IsNullOrEmpty(request.ContentDisposition))
{
query["contentDisposition"] = request.ContentDisposition;
}
Result <HttpResponseMessage> result = await _owner.GetAsyncMessage(api, query);
return(result);
}
/// <summary> /// Download Chunk /// </summary> /// <remarks> /// Abstract factory method. /// </remarks> /// <param name="request">Request</param> /// <param name="response">Response</param> abstract protected void DownloadChunk(DownloadDocumentRequest request, ref DownloadDocumentResponse response);
public HttpResponseMessage DownloadDocument([FromUri] DownloadDocumentRequest request)
{
if (request == null)
{
throw new ArgumentNullException("request");
}
if ((request.DocumentId == null && request.Uri == null) || (request.DocumentId != null && request.Uri != null))
{
throw new InvalidOperationException("DocumentId or Uri must not be null, but not both");
}
var cache = ServiceHelper.Cache;
DocumentCacheInfo cacheInfo;
if (request.Uri != null)
{
cacheInfo = DocumentFactory.GetDocumentCacheInfo(cache, request.Uri);
}
else
{
cacheInfo = DocumentFactory.GetDocumentCacheInfo(cache, request.DocumentId);
}
DocumentHelper.CheckCacheInfo(cacheInfo);
var documentMimeType = cacheInfo.MimeType;
var documentExtension = RasterCodecs.GetMimeTypeExtension(documentMimeType);
if (string.IsNullOrEmpty(documentExtension))
{
documentExtension = "data";
}
var name = "download";
if (!string.IsNullOrEmpty(cacheInfo.Name))
{
name = ServiceHelper.RemoveExtension(cacheInfo.Name, documentExtension);
}
var documentName = string.Format("{0}.{1}", name, documentExtension);
var annotationsName = string.Format("{0}_ann.xml", name);
var responseFileName = documentName;
var responseContentType = documentMimeType;
bool zipAnnotations = request.IncludeAnnotations && cacheInfo.HasAnnotations;
if (zipAnnotations)
{
// We will create a ZIP file
responseFileName = string.Format("{0}.zip", name);
responseContentType = MediaTypeNames.Application.Zip;
}
var documentId = cacheInfo.DocumentId;
Action <Stream, HttpContent, TransportContext> write = (outputStream, content, context) =>
{
if (zipAnnotations)
{
// We must create a new memory stream because Package.Open tries to request position
using (var zipStream = new MemoryStream())
{
using (var package = Package.Open(zipStream, FileMode.CreateNew))
{
var documentPart = package.CreatePart(new Uri(string.Format("/{0}", documentName), UriKind.Relative), documentMimeType);
Stream documentStream = documentPart.GetStream();
DocumentFactory.DownloadDocument(cache, documentId, 0, -1, documentStream);
documentStream.Close();
var annotationsPart = package.CreatePart(new Uri(string.Format("/{0}", annotationsName), UriKind.Relative), "text/xml");
Stream annotationsStream = annotationsPart.GetStream();
DocumentFactory.DownloadAnnotations(cache, documentId, 0, -1, annotationsStream);
annotationsStream.Close();
}
zipStream.Position = 0;
ServiceHelper.CopyStream(zipStream, outputStream);
}
}
else
{
// Just the document
DocumentFactory.DownloadDocument(cache, documentId, 0, -1, outputStream);
}
outputStream.Close();
};
var response = new HttpResponseMessage(HttpStatusCode.OK);
// For "Save to Google Drive" access, we must have the appropriate CORS headers.
// See https://developers.google.com/drive/v3/web/savetodrive
response.Headers.Remove("Access-Control-Allow-Headers");
response.Headers.Add("Access-Control-Allow-Headers", "Range");
response.Headers.Remove("Access-Control-Expose-Headers");
response.Headers.Add("Access-Control-Expose-Headers", "Cache-Control, Content-Encoding, Content-Range");
response.Content = new PushStreamContent(write, new MediaTypeHeaderValue(responseContentType));
ServiceHelper.SetResponseViewFileName(response, responseFileName, responseContentType);
return(response);
}
/// <summary>
/// Download Document
/// </summary>
/// <param name="request">Request</param>
/// <returns>DownloadDocumentResponse</returns>
public DownloadDocumentResponse DownloadDocument(DownloadDocumentRequest request)
{
return(BaseOperations.DownloadDocument(request));
}
/// <summary>
/// Download Document
/// </summary>
/// <param name="document">Document</param>
/// <param name="path">Path</param>
/// <param name="mode">Mode</param>
public void DownloadDocument(DocumentInfo document, string path, DocumentDownloadMode mode)
{
var request = new DownloadDocumentRequest
{
OidDocument = document.OidDocument,
Version = document.Version,
ChunkNumber = 0,
ChunkSize = GetChunkSize(),
Mode = mode
};
// Get the first chunk of data
DownloadDocumentResponse response = null;
if (_flowDocsService == null)
{
using (var docsProxy = new FlowDocsOperations())
{
response = docsProxy.DownloadDocument(request);
}
}
else
{
response = _flowDocsService.DownloadDocument(request);
}
var filePath = Path.Combine(path, response.DocumentName);
document.DocumentName = filePath;
document.Description = response.Description;
document.Owner = response.Owner;
document.Path = response.Path;
document.MimeType = response.MimeType;
document.FileHash = response.FileHash;
using (var writer = new FileStream(filePath, FileMode.Create))
{
int chunks = 0;
long curSize = response.ChunkSize;
writer.Write(response.DataField, 0, (int)Math.Min(response.ChunkSize, response.FileSize));
request.ChunkNumber = ++chunks;
// Get all the chunks of the document
while (chunks < response.ChunkTotal)
{
if (_flowDocsService == null)
{
using (var docsProxy = new FlowDocsOperations())
{
response = docsProxy.DownloadDocument(request);
}
}
else
{
response = _flowDocsService.DownloadDocument(request);
}
int size = response.ChunkSize;
if (response.FileSize > 0)
{
long bytesLeft = response.FileSize - curSize;
size = bytesLeft < response.ChunkSize ? (int)bytesLeft : response.ChunkSize;
}
writer.Write(response.DataField, 0, size);
var hash = Md5Hash.CreateMd5Hash(response.DataField);
if (hash != response.FileHash)
{
throw new Exception(Flow.Library.Properties.Resources.ER_HASH);
}
curSize += size;
request.ChunkNumber = ++chunks;
}
}
}
/// <summary>
/// Download Document
/// </summary>
/// <param name="request">Request</param>
/// <returns>DownloadDocumentResponse</returns>
public DownloadDocumentResponse DownloadDocument(DownloadDocumentRequest request)
{
return(Channel.DownloadDocument(request));
}
