/// <summary>
/// Merges a row tree with a PDF document containing form fields.
/// </summary>
public static void CreatePdf(
MergeRowTree rowTree, bool ensureAllFieldsHaveValues, MemoryStream sourcePdfStream, Stream destinationStream,
bool useLegacyBehaviorOfIgnoringInvalidFields = false)
{
var streams = new List <Stream>();
try {
foreach (var row in rowTree.Rows)
{
var stream = new MemoryStream();
streams.Add(stream);
using (var sourcePdfMemoryStreamCopy = new MemoryStream()) {
// Aspose has decided that in the new Facades PDF library, they will close your source stream for you when you call doc.Save.
sourcePdfStream.Reset();
IoMethods.CopyStream(sourcePdfStream, sourcePdfMemoryStreamCopy);
var doc = new Aspose.Pdf.Facades.Form(sourcePdfMemoryStreamCopy);
foreach (var mergeField in doc.FieldNames.Where(mergeField => !mergeField.StartsWith("noMerge")))
{
var mergeValue = row.Values.SingleOrDefault(v => v.Name == mergeField);
if (mergeValue == null)
{
if (useLegacyBehaviorOfIgnoringInvalidFields)
{
continue;
}
throw new MailMergingException(string.Format("PDF document contains a merge field ({0}) that does not exist.", mergeField));
}
var mergeValueAsString = mergeValue as MergeValue <string>;
string value = null;
if (mergeValueAsString != null)
{
value = mergeValueAsString.Evaluate(ensureAllFieldsHaveValues);
}
if (value == null)
{
throw new MailMergingException("Merge field " + mergeValue.Name + " evaluates to an unsupported type.");
}
doc.FillField(mergeValue.Name, value);
}
doc.Save(stream);
}
}
if (streams.Any())
{
PdfOps.ConcatPdfs(streams, destinationStream);
}
}
finally {
foreach (var i in streams)
{
i.Dispose();
}
}
}
/// <summary>
/// Gets the post back value.
/// </summary>
public RsFile GetPostBackValue(PostBackValueDictionary postBackValues)
{
if (postBackValue == null)
{
var value = formValue.GetValue(postBackValues);
if (value == null)
{
return(null);
}
using (var ms = new MemoryStream()) {
IoMethods.CopyStream(value.InputStream, ms);
postBackValue = new RsFile(ms.ToArray(), Path.GetFileName(value.FileName), contentType: value.ContentType);
}
}
return(postBackValue);
}
void IHttpHandler.ProcessRequest(HttpContext context)
{
var url = EwfApp.GetRequestAppRelativeUrl(context.Request);
var queryIndex = url.IndexOf("?", StringComparison.Ordinal);
if (queryIndex >= 0)
{
url = url.Remove(queryIndex);
}
var extensionIndex = url.LastIndexOf(".", StringComparison.Ordinal);
var versionStringOrFileExtensionIndex = extensionIndex;
var urlVersionString = "";
if (url.StartsWith(VersionedFilesFolderName + "/") || url.StartsWith(EwfFolderName + "/" + VersionedFilesFolderName + "/"))
{
urlVersionString = "invariant";
}
else
{
// We assume that all URL version strings will have the same length as the format string.
var prefixedVersionStringIndex = extensionIndex - (urlVersionStringPrefix.Length + EwfSafeResponseWriter.UrlVersionStringFormat.Length);
if (prefixedVersionStringIndex >= 0)
{
DateTimeOffset dateAndTime;
var versionString = url.Substring(prefixedVersionStringIndex + urlVersionStringPrefix.Length, EwfSafeResponseWriter.UrlVersionStringFormat.Length);
if (DateTimeOffset.TryParseExact(
versionString,
EwfSafeResponseWriter.UrlVersionStringFormat,
DateTimeFormatInfo.InvariantInfo,
DateTimeStyles.None,
out dateAndTime))
{
versionStringOrFileExtensionIndex = prefixedVersionStringIndex;
urlVersionString = versionString;
}
}
}
if (versionStringOrFileExtensionIndex < 0)
{
throw new ResourceNotAvailableException("Failed to find the extension in the URL.", null);
}
var extension = url.Substring(extensionIndex);
var staticFileInfo =
EwfApp.GlobalType.Assembly.CreateInstance(
CombineNamespacesAndProcessEwfIfNecessary(
EwfApp.GlobalType.Namespace,
(url.Remove(versionStringOrFileExtensionIndex) + extension.CapitalizeString()).Separate("/", false)
.Select(StandardLibraryMethods.GetCSharpIdentifier)
.Aggregate((a, b) => a + "." + b) + "+Info")) as StaticFileInfo;
if (staticFileInfo == null)
{
throw new ResourceNotAvailableException("Failed to create an Info object for the request.", null);
}
var mediaTypeOverride = EwfApp.Instance.GetMediaTypeOverrides().SingleOrDefault(i => i.FileExtension == extension);
var contentType = mediaTypeOverride != null ? mediaTypeOverride.MediaType : MimeTypeMap.MimeTypeMap.GetMimeType(extension);
Func <string> cacheKeyGetter = () => staticFileInfo.GetUrl(false, false, false);
EwfSafeResponseWriter responseWriter;
if (contentType == ContentTypes.Css)
{
Func <string> cssGetter = () => File.ReadAllText(staticFileInfo.FilePath);
responseWriter = urlVersionString.Any()
? new EwfSafeResponseWriter(
cssGetter,
urlVersionString,
() => new ResponseMemoryCachingSetup(cacheKeyGetter(), staticFileInfo.GetResourceLastModificationDateAndTime()))
: new EwfSafeResponseWriter(
() => new EwfResponse(ContentTypes.Css, new EwfResponseBodyCreator(() => CssPreprocessor.TransformCssFile(cssGetter()))),
staticFileInfo.GetResourceLastModificationDateAndTime(),
memoryCacheKeyGetter: cacheKeyGetter);
}
else
{
Func <EwfResponse> responseCreator = () => new EwfResponse(
contentType,
new EwfResponseBodyCreator(
responseStream => {
using (var fileStream = File.OpenRead(staticFileInfo.FilePath))
IoMethods.CopyStream(fileStream, responseStream);
}));
responseWriter = urlVersionString.Any()
? new EwfSafeResponseWriter(
responseCreator,
urlVersionString,
memoryCachingSetupGetter:
() => new ResponseMemoryCachingSetup(cacheKeyGetter(), staticFileInfo.GetResourceLastModificationDateAndTime()))
: new EwfSafeResponseWriter(
responseCreator,
staticFileInfo.GetResourceLastModificationDateAndTime(),
memoryCacheKeyGetter: cacheKeyGetter);
}
responseWriter.WriteResponse();
}
