/* (non-Javadoc)
* @see com.itextpdf.pdfa.checker.PdfA1Checker#checkMetaData(com.itextpdf.kernel.pdf.PdfDictionary)
*/
protected override void CheckMetaData(PdfDictionary catalog)
{
base.CheckMetaData(catalog);
XMPMeta xmpMeta;
try {
xmpMeta = XMPMetaFactory.ParseFromBuffer(catalog.GetAsStream(PdfName.Metadata).GetBytes());
String docFileName = xmpMeta.GetPropertyString(ZugferdXMPUtil.ZUGFERD_SCHEMA_NS, ZugferdXMPUtil.ZUGFERD_DOCUMENT_FILE_NAME
);
foreach (PdfDictionary attachment in attachments)
{
if ((attachment.GetAsString(PdfName.UF) != null && docFileName.Equals(attachment.GetAsString(PdfName.UF).ToString
())) || (attachment.GetAsString(PdfName.F) != null && docFileName.Equals(attachment.GetAsString(PdfName
.F).ToString())))
{
PdfName relationship = attachment.GetAsName(PdfName.AFRelationship);
if (!PdfName.Alternative.Equals(relationship))
{
throw new ZugferdConformanceException(ZugferdConformanceException.AFRelationshipValueShallbeAlternative);
}
break;
}
}
}
catch (XMPException e) {
throw new PdfException(e);
}
}
public virtual void XxeTestFromString()
{
String metadataToParse = MessageFormatUtil.Format(XMP_WITH_XXE, XXE_FILE_PATH);
XMPMeta xmpMeta = XMPMetaParser.Parse(metadataToParse, null);
NUnit.Framework.Assert.AreEqual(EXPECTED_SERIALIZED_XMP, XMPMetaFactory.SerializeToString(xmpMeta, null));
}
public virtual void XxeTestFromByteBuffer()
{
String metadataToParse = MessageFormatUtil.Format(XMP_WITH_XXE, XXE_FILE_PATH);
XMPMeta xmpMeta = XMPMetaParser.Parse(metadataToParse.GetBytes(System.Text.Encoding.UTF8), null);
NUnit.Framework.Assert.AreEqual(EXPECTED_SERIALIZED_XMP, XMPMetaFactory.SerializeToString(xmpMeta, null));
}
public PdfADocument(PdfReader reader, PdfWriter writer, StampingProperties properties)
: base(reader, writer, properties)
{
byte[] existingXmpMetadata = GetXmpMetadata();
if (existingXmpMetadata == null)
{
throw new PdfAConformanceException(PdfAConformanceException.DocumentToReadFromShallBeAPdfAConformantFileWithValidXmpMetadata
);
}
XMPMeta meta;
try {
meta = XMPMetaFactory.ParseFromBuffer(existingXmpMetadata);
}
catch (XMPException) {
throw new PdfAConformanceException(PdfAConformanceException.DocumentToReadFromShallBeAPdfAConformantFileWithValidXmpMetadata
);
}
PdfAConformanceLevel conformanceLevel = PdfAConformanceLevel.GetConformanceLevel(meta);
if (conformanceLevel == null)
{
throw new PdfAConformanceException(PdfAConformanceException.DocumentToReadFromShallBeAPdfAConformantFileWithValidXmpMetadata
);
}
SetChecker(conformanceLevel);
}
/// <summary>Find or create a schema node if <code>createNodes</code> is true.</summary>
/// <param name="tree">the root of the xmp tree.</param>
/// <param name="namespaceURI">a namespace</param>
/// <param name="suggestedPrefix">If a prefix is suggested, the namespace is allowed to be registered.</param>
/// <param name="createNodes">
/// a flag indicating if the node shall be created if not found.
/// <em>Note:</em> The namespace must be registered prior to this call.
/// </param>
/// <returns>
/// Returns the schema node if found, <code>null</code> otherwise.
/// Note: If <code>createNodes</code> is <code>true</code>, it is <b>always</b>
/// returned a valid node.
/// </returns>
/// <exception cref="Com.Adobe.Xmp.XMPException">
/// An exception is only thrown if an error occurred, not if a
/// node was not found.
/// </exception>
internal static XMPNode FindSchemaNode(XMPNode tree, string namespaceURI, string suggestedPrefix, bool createNodes)
{
System.Diagnostics.Debug.Assert(tree.GetParent() == null);
// make sure that its the root
XMPNode schemaNode = tree.FindChildByName(namespaceURI);
if (schemaNode == null && createNodes)
{
schemaNode = new XMPNode(namespaceURI, new PropertyOptions().SetSchemaNode(true));
schemaNode.SetImplicit(true);
// only previously registered schema namespaces are allowed in the XMP tree.
string prefix = XMPMetaFactory.GetSchemaRegistry().GetNamespacePrefix(namespaceURI);
if (prefix == null)
{
if (suggestedPrefix != null && suggestedPrefix.Length != 0)
{
prefix = XMPMetaFactory.GetSchemaRegistry().RegisterNamespace(namespaceURI, suggestedPrefix);
}
else
{
throw new XMPException("Unregistered schema namespace URI", XMPErrorConstants.Badschema);
}
}
schemaNode.SetValue(prefix);
tree.AddChild(schemaNode);
}
return(schemaNode);
}
/// <summary>Open a PDF/A document in stamping mode.</summary>
/// <param name="reader">PDF reader.</param>
/// <param name="writer">PDF writer.</param>
/// <param name="properties">properties of the stamping process</param>
public PdfADocument(PdfReader reader, PdfWriter writer, StampingProperties properties)
: base(reader, writer, properties)
{
byte[] existingXmpMetadata = GetXmpMetadata();
if (existingXmpMetadata == null)
{
throw new PdfAConformanceException(PdfAConformanceException.DOCUMENT_TO_READ_FROM_SHALL_BE_A_PDFA_CONFORMANT_FILE_WITH_VALID_XMP_METADATA
);
}
XMPMeta meta;
try {
meta = XMPMetaFactory.ParseFromBuffer(existingXmpMetadata);
}
catch (XMPException) {
throw new PdfAConformanceException(PdfAConformanceException.DOCUMENT_TO_READ_FROM_SHALL_BE_A_PDFA_CONFORMANT_FILE_WITH_VALID_XMP_METADATA
);
}
PdfAConformanceLevel conformanceLevel = PdfAConformanceLevel.GetConformanceLevel(meta);
if (conformanceLevel == null)
{
throw new PdfAConformanceException(PdfAConformanceException.DOCUMENT_TO_READ_FROM_SHALL_BE_A_PDFA_CONFORMANT_FILE_WITH_VALID_XMP_METADATA
);
}
SetChecker(conformanceLevel);
}
public virtual void CreatePdfTest()
{
String fileName = "xmp_metadata.pdf";
// step 1
PdfDocument pdfDocument = new PdfDocument(new PdfWriter(destinationFolder + "xmp_metadata.pdf"));
Document document = new Document(pdfDocument);
// step 2
ByteArrayOutputStream os = new ByteArrayOutputStream();
XMPMeta xmp = XMPMetaFactory.Create();
xmp.AppendArrayItem(XMPConst.NS_DC, "subject", new PropertyOptions(PropertyOptions.ARRAY), "Hello World",
null);
xmp.AppendArrayItem(XMPConst.NS_DC, "subject", new PropertyOptions(PropertyOptions.ARRAY), "XMP & Metadata"
, null);
xmp.AppendArrayItem(XMPConst.NS_DC, "subject", new PropertyOptions(PropertyOptions.ARRAY), "Metadata", null
);
pdfDocument.SetXmpMetadata(xmp);
// step 4
document.Add(new Paragraph("Hello World"));
// step 5
document.Close();
CompareTool ct = new CompareTool();
NUnit.Framework.Assert.IsNull(ct.CompareXmp(destinationFolder + fileName, sourceFolder + "cmp_" + fileName
, true));
}
private void ConvertToPdfa(Job job)
{
if (job.Profile.OutputFormat.IsPdfA())
{
var sourcePdf = job.IntermediatePdfFile;
if (string.IsNullOrEmpty(sourcePdf))
{
return;
}
var targetPdf = AddTailToFile(sourcePdf, "_pdfa");
var version = DeterminePdfVersionAsEnum(job.Profile);
var writerProperties = new WriterProperties();
writerProperties.SetPdfVersion(version);
byte[] resource;
//Set ICC Profile according to the color model
switch (job.Profile.PdfSettings.ColorModel)
{
case ColorModel.Cmyk:
resource = GhostscriptResources.WebCoatedFOGRA28;
break;
case ColorModel.Gray:
resource = GhostscriptResources.ISOcoated_v2_grey1c_bas;
break;
default:
resource = GhostscriptResources.eciRGB_v2;
break;
}
try
{
using (var icc = new MemoryStream(resource))
{
var document = new PdfADocument(new PdfWriter(targetPdf, writerProperties), GetConformLevel(job.Profile.OutputFormat), new PdfOutputIntent("Custom", "", "http://www.color.org", "sRGB IEC61966-2.1", icc));
document.SetTagged();
var toCopyDoc = new PdfDocument(new PdfReader(sourcePdf));
toCopyDoc.CopyPagesTo(1, toCopyDoc.GetNumberOfPages(), document);
var metaData = XMPMetaFactory.ParseFromBuffer(toCopyDoc.GetXmpMetadata());
document.SetXmpMetadata(metaData);
toCopyDoc.Close();
document.Close();
File.Delete(sourcePdf);
job.IntermediatePdfFile = targetPdf;
}
}
catch (PdfAConformanceException ex)
{
throw new ProcessingException("One of the used pdfs does not conform to the PDF-A specification", ErrorCode.Processing_ConformanceMismatch, ex);
}
}
}
internal static void AppendMetadataToInfo(byte[] xmpMetadata, PdfDocumentInfo info)
{
if (xmpMetadata != null)
{
try {
XMPMeta meta = XMPMetaFactory.ParseFromBuffer(xmpMetadata);
XMPProperty title = meta.GetLocalizedText(XMPConst.NS_DC, PdfConst.Title, XMPConst.X_DEFAULT, XMPConst.X_DEFAULT
);
if (title != null)
{
info.SetTitle(title.GetValue());
}
String author = FetchArrayIntoString(meta, XMPConst.NS_DC, PdfConst.Creator);
if (author != null)
{
info.SetAuthor(author);
}
// We assume that pdf:keywords has precedence over dc:subject
XMPProperty keywords = meta.GetProperty(XMPConst.NS_PDF, PdfConst.Keywords);
if (keywords != null)
{
info.SetKeywords(keywords.GetValue());
}
else
{
String keywordsStr = FetchArrayIntoString(meta, XMPConst.NS_DC, PdfConst.Subject);
if (keywordsStr != null)
{
info.SetKeywords(keywordsStr);
}
}
XMPProperty subject = meta.GetLocalizedText(XMPConst.NS_DC, PdfConst.Description, XMPConst.X_DEFAULT, XMPConst
.X_DEFAULT);
if (subject != null)
{
info.SetSubject(subject.GetValue());
}
XMPProperty creator = meta.GetProperty(XMPConst.NS_XMP, PdfConst.CreatorTool);
if (creator != null)
{
info.SetCreator(creator.GetValue());
}
XMPProperty producer = meta.GetProperty(XMPConst.NS_PDF, PdfConst.Producer);
if (producer != null)
{
info.Put(PdfName.Producer, new PdfString(producer.GetValue(), PdfEncodings.UNICODE_BIG));
}
XMPProperty trapped = meta.GetProperty(XMPConst.NS_PDF, PdfConst.Trapped);
if (trapped != null)
{
info.SetTrapped(new PdfName(trapped.GetValue()));
}
}
catch (XMPException) {
}
}
}
protected void ManipulatePdf(String dest)
{
PdfDocument pdfDoc = new PdfDocument(new PdfReader(SRC), new PdfWriter(dest));
PdfPage page = pdfDoc.GetFirstPage();
page.SetXmpMetadata(XMPMetaFactory.Create());
pdfDoc.Close();
}
public virtual string GetNamespace()
{
if (!node.GetOptions().IsSchemaNode())
{
// determine namespace of leaf node
QName qname = new QName(node.GetName());
return(XMPMetaFactory.GetSchemaRegistry().GetNamespaceURI(qname.GetPrefix()));
}
return(baseNs);
}
/// <summary>Set up the first 2 components of the expanded XMPPath.</summary>
/// <remarks>
/// Set up the first 2 components of the expanded XMPPath. Normalizes the various cases of using
/// the full schema URI and/or a qualified root property name. Returns true for normal
/// processing. If allowUnknownSchemaNS is true and the schema namespace is not registered, false
/// is returned. If allowUnknownSchemaNS is false and the schema namespace is not registered, an
/// exception is thrown
/// <P>
/// (Should someday check the full syntax:)
/// </remarks>
/// <param name="schemaNS">schema namespace</param>
/// <param name="rootProp">the root xpath segment</param>
/// <returns>Returns root QName.</returns>
/// <exception cref="Com.Adobe.Xmp.XMPException">Thrown if the format is not correct somehow.</exception>
private static string VerifyXPathRoot(string schemaNS, string rootProp)
{
// Do some basic checks on the URI and name. Try to lookup the URI. See if the name is
// qualified.
if (schemaNS == null || schemaNS.Length == 0)
{
throw new XMPException("Schema namespace URI is required", XMPErrorConstants.Badschema);
}
if ((rootProp[0] == '?') || (rootProp[0] == '@'))
{
throw new XMPException("Top level name must not be a qualifier", XMPErrorConstants.Badxpath);
}
if (rootProp.IndexOf('/') >= 0 || rootProp.IndexOf('[') >= 0)
{
throw new XMPException("Top level name must be simple", XMPErrorConstants.Badxpath);
}
string prefix = XMPMetaFactory.GetSchemaRegistry().GetNamespacePrefix(schemaNS);
if (prefix == null)
{
throw new XMPException("Unregistered schema namespace URI", XMPErrorConstants.Badschema);
}
// Verify the various URI and prefix combinations. Initialize the
// expanded XMPPath.
int colonPos = rootProp.IndexOf(':');
if (colonPos < 0)
{
// The propName is unqualified, use the schemaURI and associated
// prefix.
VerifySimpleXMLName(rootProp);
// Verify the part before any colon
return(prefix + rootProp);
}
else
{
// The propName is qualified. Make sure the prefix is legit. Use the associated URI and
// qualified name.
// Verify the part before any colon
VerifySimpleXMLName(Sharpen.Runtime.Substring(rootProp, 0, colonPos));
VerifySimpleXMLName(Sharpen.Runtime.Substring(rootProp, colonPos));
prefix = Sharpen.Runtime.Substring(rootProp, 0, colonPos + 1);
string regPrefix = XMPMetaFactory.GetSchemaRegistry().GetNamespacePrefix(schemaNS);
if (regPrefix == null)
{
throw new XMPException("Unknown schema namespace prefix", XMPErrorConstants.Badschema);
}
if (!prefix.Equals(regPrefix))
{
throw new XMPException("Schema namespace URI and prefix mismatch", XMPErrorConstants.Badschema);
}
return(rootProp);
}
}
private byte[] RemoveAlwaysDifferentEntries(byte[] cmpBytes)
{
XMPMeta xmpMeta = XMPMetaFactory.ParseFromBuffer(cmpBytes);
XMPUtils.RemoveProperties(xmpMeta, XMPConst.NS_XMP, PdfConst.CreateDate, true, true);
XMPUtils.RemoveProperties(xmpMeta, XMPConst.NS_XMP, PdfConst.ModifyDate, true, true);
XMPUtils.RemoveProperties(xmpMeta, XMPConst.NS_XMP, PdfConst.MetadataDate, true, true);
XMPUtils.RemoveProperties(xmpMeta, XMPConst.NS_PDF, PdfConst.Producer, true, true);
cmpBytes = XMPMetaFactory.SerializeToBuffer(xmpMeta, new SerializeOptions(SerializeOptions.SORT));
return(cmpBytes);
}
public virtual void MetadataReadingInEncryptedDoc()
{
PdfReader reader = new PdfReader(sourceFolder + "encryptedWithPlainMetadata.pdf", new ReaderProperties().SetPassword
(OWNER));
PdfDocument doc = new PdfDocument(reader);
XMPMeta xmpMeta = XMPMetaFactory.ParseFromBuffer(doc.GetXmpMetadata());
XMPProperty creatorToolXmp = xmpMeta.GetProperty(XMPConst.NS_XMP, "CreatorTool");
doc.Close();
NUnit.Framework.Assert.IsNotNull(creatorToolXmp);
NUnit.Framework.Assert.AreEqual("iText 7", creatorToolXmp.GetValue());
}
protected override void AddCustomMetadataExtensions(XMPMeta xmpMeta)
{
if (this.IsTagged())
{
try {
XMPMeta taggedExtensionMeta = XMPMetaFactory.ParseFromString(PdfAXMPUtil.PDF_UA_EXTENSION);
XMPUtils.AppendProperties(taggedExtensionMeta, xmpMeta, true, false);
}
catch (XMPException exc) {
ILogger logger = LoggerFactory.GetLogger(typeof(iText.Pdfa.PdfADocument));
logger.Error(LogMessageConstant.EXCEPTION_WHILE_UPDATING_XMPMETADATA, exc);
}
}
}
/// <summary>
/// Performs the XMP data extraction, adding found values to the specified instance of
/// <see cref="Com.Drew.Metadata.Metadata"/>
/// .
/// <p/>
/// The extraction is done with Adobe's XMPCore library.
/// </summary>
public virtual void Extract(string xmpString, Com.Drew.Metadata.Metadata metadata)
{
XmpDirectory directory = metadata.GetOrCreateDirectory <XmpDirectory>();
try
{
XMPMeta xmpMeta = XMPMetaFactory.ParseFromString(xmpString);
ProcessXmpTags(directory, xmpMeta);
}
catch (XMPException e)
{
directory.AddError("Error processing XMP data: " + e.Message);
}
}
/// <summary>
/// Parses the root node of an XMP Path, checks if namespace and prefix fit together
/// and resolve the property to the base property if it is an alias.
/// </summary>
/// <param name="schemaNS">the root namespace</param>
/// <param name="pos">the parsing position helper</param>
/// <param name="expandedXPath">the path to contribute to</param>
/// <exception cref="iText.Kernel.XMP.XMPException">If the path is not valid.</exception>
private static void ParseRootNode(String schemaNS, PathPosition pos, XMPPath expandedXPath)
{
while (pos.stepEnd < pos.path.Length && "/[*".IndexOf(pos.path[pos.stepEnd]) < 0)
{
pos.stepEnd++;
}
if (pos.stepEnd == pos.stepBegin)
{
throw new XMPException("Empty initial XMPPath step", XMPError.BADXPATH);
}
String rootProp = VerifyXPathRoot(schemaNS, pos.path.JSubstring(pos.stepBegin, pos.stepEnd));
XMPAliasInfo aliasInfo = XMPMetaFactory.GetSchemaRegistry().FindAlias(rootProp);
if (aliasInfo == null)
{
// add schema xpath step
expandedXPath.Add(new XMPPathSegment(schemaNS, XMPPath.SCHEMA_NODE));
XMPPathSegment rootStep = new XMPPathSegment(rootProp, XMPPath.STRUCT_FIELD_STEP);
expandedXPath.Add(rootStep);
}
else
{
// add schema xpath step and base step of alias
expandedXPath.Add(new XMPPathSegment(aliasInfo.GetNamespace(), XMPPath.SCHEMA_NODE));
XMPPathSegment rootStep = new XMPPathSegment(VerifyXPathRoot(aliasInfo.GetNamespace(), aliasInfo.GetPropName
()), XMPPath.STRUCT_FIELD_STEP);
rootStep.SetAlias(true);
rootStep.SetAliasForm(aliasInfo.GetAliasForm().GetOptions());
expandedXPath.Add(rootStep);
if (aliasInfo.GetAliasForm().IsArrayAltText())
{
XMPPathSegment qualSelectorStep = new XMPPathSegment("[?xml:lang='x-default']", XMPPath.QUAL_SELECTOR_STEP
);
qualSelectorStep.SetAlias(true);
qualSelectorStep.SetAliasForm(aliasInfo.GetAliasForm().GetOptions());
expandedXPath.Add(qualSelectorStep);
}
else
{
if (aliasInfo.GetAliasForm().IsArray())
{
XMPPathSegment indexStep = new XMPPathSegment("[1]", XMPPath.ARRAY_INDEX_STEP);
indexStep.SetAlias(true);
indexStep.SetAliasForm(aliasInfo.GetAliasForm().GetOptions());
expandedXPath.Add(indexStep);
}
}
}
}
/// <summary>
/// Parses the root node of an XMP Path, checks if namespace and prefix fit together
/// and resolve the property to the base property if it is an alias.
/// </summary>
/// <param name="schemaNS">the root namespace</param>
/// <param name="pos">the parsing position helper</param>
/// <param name="expandedXPath">the path to contribute to</param>
/// <exception cref="Com.Adobe.Xmp.XMPException">If the path is not valid.</exception>
private static void ParseRootNode(string schemaNS, PathPosition pos, XMPPath expandedXPath)
{
while (pos.stepEnd < pos.path.Length && "/[*".IndexOf(pos.path[pos.stepEnd]) < 0)
{
pos.stepEnd++;
}
if (pos.stepEnd == pos.stepBegin)
{
throw new XMPException("Empty initial XMPPath step", XMPErrorConstants.Badxpath);
}
string rootProp = VerifyXPathRoot(schemaNS, Sharpen.Runtime.Substring(pos.path, pos.stepBegin, pos.stepEnd));
XMPAliasInfo aliasInfo = XMPMetaFactory.GetSchemaRegistry().FindAlias(rootProp);
if (aliasInfo == null)
{
// add schema xpath step
expandedXPath.Add(new XMPPathSegment(schemaNS, XMPPath.SchemaNode));
XMPPathSegment rootStep = new XMPPathSegment(rootProp, XMPPath.StructFieldStep);
expandedXPath.Add(rootStep);
}
else
{
// add schema xpath step and base step of alias
expandedXPath.Add(new XMPPathSegment(aliasInfo.GetNamespace(), XMPPath.SchemaNode));
XMPPathSegment rootStep = new XMPPathSegment(VerifyXPathRoot(aliasInfo.GetNamespace(), aliasInfo.GetPropName()), XMPPath.StructFieldStep);
rootStep.SetAlias(true);
rootStep.SetAliasForm(aliasInfo.GetAliasForm().GetOptions());
expandedXPath.Add(rootStep);
if (aliasInfo.GetAliasForm().IsArrayAltText())
{
XMPPathSegment qualSelectorStep = new XMPPathSegment("[?xml:lang='x-default']", XMPPath.QualSelectorStep);
qualSelectorStep.SetAlias(true);
qualSelectorStep.SetAliasForm(aliasInfo.GetAliasForm().GetOptions());
expandedXPath.Add(qualSelectorStep);
}
else
{
if (aliasInfo.GetAliasForm().IsArray())
{
XMPPathSegment indexStep = new XMPPathSegment("[1]", XMPPath.ArrayIndexStep);
indexStep.SetAlias(true);
indexStep.SetAliasForm(aliasInfo.GetAliasForm().GetOptions());
expandedXPath.Add(indexStep);
}
}
}
}
/// <summary>
/// Performs the XMP data extraction, adding found values to the specified instance of
/// <see cref="Com.Drew.Metadata.Metadata"/>
/// .
/// <p>
/// The extraction is done with Adobe's XMPCore library.
/// </summary>
public virtual void Extract([NotNull] string xmpString, [NotNull] Com.Drew.Metadata.Metadata metadata)
{
XmpDirectory directory = new XmpDirectory();
try
{
XMPMeta xmpMeta = XMPMetaFactory.ParseFromString(xmpString);
ProcessXmpTags(directory, xmpMeta);
}
catch (XMPException e)
{
directory.AddError("Error processing XMP data: " + e.Message);
}
if (!directory.IsEmpty())
{
metadata.AddDirectory(directory);
}
}
/// <summary>
/// Verifies whether the qualifier name is not XML conformant or the
/// namespace prefix has not been registered.
/// </summary>
/// <param name="qualName">a qualifier name</param>
/// <exception cref="iText.Kernel.XMP.XMPException">If the name is not conformant</exception>
private static void VerifyQualName(String qualName)
{
int colonPos = qualName.IndexOf(':');
if (colonPos > 0)
{
String prefix = qualName.JSubstring(0, colonPos);
if (Utils.IsXMLNameNS(prefix))
{
String regURI = XMPMetaFactory.GetSchemaRegistry().GetNamespaceURI(prefix);
if (regURI != null)
{
return;
}
throw new XMPException("Unknown namespace prefix for qualified name", XMPError.BADXPATH);
}
}
throw new XMPException("Ill-formed qualified name", XMPError.BADXPATH);
}
protected override void UpdateXmpMetadata()
{
try {
XMPMeta xmpMeta = UpdateDefaultXmpMetadata();
xmpMeta.SetProperty(XMPConst.NS_PDFA_ID, XMPConst.PART, checker.GetConformanceLevel().GetPart());
xmpMeta.SetProperty(XMPConst.NS_PDFA_ID, XMPConst.CONFORMANCE, checker.GetConformanceLevel().GetConformance
());
if (this.IsTagged())
{
XMPMeta taggedExtensionMeta = XMPMetaFactory.ParseFromString(PdfAXMPUtil.PDF_UA_EXTENSION);
XMPUtils.AppendProperties(taggedExtensionMeta, xmpMeta, true, false);
}
SetXmpMetadata(xmpMeta);
}
catch (XMPException e) {
ILogger logger = LoggerFactory.GetLogger(typeof(iText.Pdfa.PdfADocument));
logger.Error(LogMessageConstant.EXCEPTION_WHILE_UPDATING_XMPMETADATA, e);
}
}
/// <summary>
/// Verifies whether the qualifier name is not XML conformant or the
/// namespace prefix has not been registered.
/// </summary>
/// <param name="qualName">a qualifier name</param>
/// <exception cref="Com.Adobe.Xmp.XMPException">If the name is not conformant</exception>
private static void VerifyQualName(string qualName)
{
int colonPos = qualName.IndexOf(':');
if (colonPos > 0)
{
string prefix = Sharpen.Runtime.Substring(qualName, 0, colonPos);
if (Utils.IsXMLNameNS(prefix))
{
string regURI = XMPMetaFactory.GetSchemaRegistry().GetNamespaceURI(prefix);
if (regURI != null)
{
return;
}
throw new XMPException("Unknown namespace prefix for qualified name", XMPErrorConstants.Badxpath);
}
}
throw new XMPException("Ill-formed qualified name", XMPErrorConstants.Badxpath);
}
/// <summary>Adds the ZUGFeRD RDF description.</summary>
/// <param name="xmpMeta">the xmp meta</param>
/// <param name="zugferdConformanceLevel">the zugferd conformance level</param>
/// <exception cref="iText.Kernel.XMP.XMPException">the XMP exception</exception>
private void AddZugferdRdfDescription(XMPMeta xmpMeta, ZugferdConformanceLevel zugferdConformanceLevel)
{
switch (zugferdConformanceLevel)
{
case ZugferdConformanceLevel.ZUGFeRDBasic:
case ZugferdConformanceLevel.ZUGFeRDComfort:
case ZugferdConformanceLevel.ZUGFeRDExtended: {
// fallthrough
// fallthrough
XMPMeta taggedExtensionMetaComfort = XMPMetaFactory.ParseFromString(GetZugferdExtension(zugferdConformanceLevel
));
XMPUtils.AppendProperties(taggedExtensionMetaComfort, xmpMeta, true, false);
break;
}
default: {
break;
}
}
}
public async Task ShouldConvertToPdfA2B(string level, string part, string conformance)
{
var path = $"/pdfa";
var fixture = $"{Program.TestProjectPath}/Fixtures/dummy.pdf";
var pdfFile = await File.ReadAllBytesAsync(fixture);
var formData = new PdfFormData().WithConformanceLevel(level).Upload(pdfFile);
var response = await _client.PostAsync(path, formData);
var stream = await response.Content.ReadAsStreamAsync();
var pdfa = new PdfADocument(new PdfReader(stream), new PdfWriter(new MemoryStream()));
var xmpMetadataBytes = pdfa.GetXmpMetadata();
var xmpMetadata = XMPMetaFactory.ParseFromBuffer(xmpMetadataBytes);
var conformanceLevel = PdfAConformanceLevel.GetConformanceLevel(xmpMetadata);
Assert.Equal(HttpStatusCode.OK, response.StatusCode);
Assert.Equal(part, conformanceLevel.GetPart());
Assert.Equal(conformance, conformanceLevel.GetConformance());
}
/// <summary>Serializes the XmpDirectory component of <code>Metadata</code> into an <code>OutputStream</code></summary>
/// <param name="os">Destination for the xmp data</param>
/// <param name="data">populated metadata</param>
/// <returns>serialize success</returns>
public static bool Write(OutputStream os, Com.Drew.Metadata.Metadata data)
{
XmpDirectory dir = data.GetFirstDirectoryOfType <XmpDirectory>();
if (dir == null)
{
return(false);
}
XMPMeta meta = dir.GetXMPMeta();
try
{
SerializeOptions so = new SerializeOptions().SetOmitPacketWrapper(true);
XMPMetaFactory.Serialize(meta, os, so);
}
catch (XMPException e)
{
Sharpen.Runtime.PrintStackTrace(e);
return(false);
}
return(true);
}
/// <exception cref="iText.Kernel.XMP.XMPException"/>
/// <exception cref="System.IO.IOException"/>
public virtual void SetXmpMetadata(XMPMeta xmpMeta, SerializeOptions serializeOptions)
{
SetXmpMetadata(XMPMetaFactory.SerializeToBuffer(xmpMeta, serializeOptions));
}
/// <summary>Visit all of the top level nodes looking for aliases.</summary>
/// <remarks>
/// Visit all of the top level nodes looking for aliases. If there is
/// no base, transplant the alias subtree. If there is a base and strict
/// aliasing is on, make sure the alias and base subtrees match.
/// </remarks>
/// <param name="tree">the root of the metadata tree</param>
/// <param name="options">th parsing options</param>
/// <exception cref="Com.Adobe.Xmp.XMPException">Forwards XMP errors</exception>
private static void MoveExplicitAliases(XMPNode tree, ParseOptions options)
{
if (!tree.GetHasAliases())
{
return;
}
tree.SetHasAliases(false);
bool strictAliasing = options.GetStrictAliasing();
for (Iterator schemaIt = tree.GetUnmodifiableChildren().Iterator(); schemaIt.HasNext();)
{
XMPNode currSchema = (XMPNode)schemaIt.Next();
if (!currSchema.GetHasAliases())
{
continue;
}
for (Iterator propertyIt = currSchema.IterateChildren(); propertyIt.HasNext();)
{
XMPNode currProp = (XMPNode)propertyIt.Next();
if (!currProp.IsAlias())
{
continue;
}
currProp.SetAlias(false);
// Find the base path, look for the base schema and root node.
XMPAliasInfo info = XMPMetaFactory.GetSchemaRegistry().FindAlias(currProp.GetName());
if (info != null)
{
// find or create schema
XMPNode baseSchema = XMPNodeUtils.FindSchemaNode(tree, info.GetNamespace(), null, true);
baseSchema.SetImplicit(false);
XMPNode baseNode = XMPNodeUtils.FindChildNode(baseSchema, info.GetPrefix() + info.GetPropName(), false);
if (baseNode == null)
{
if (info.GetAliasForm().IsSimple())
{
// A top-to-top alias, transplant the property.
// change the alias property name to the base name
string qname = info.GetPrefix() + info.GetPropName();
currProp.SetName(qname);
baseSchema.AddChild(currProp);
// remove the alias property
propertyIt.Remove();
}
else
{
// An alias to an array item,
// create the array and transplant the property.
baseNode = new XMPNode(info.GetPrefix() + info.GetPropName(), info.GetAliasForm().ToPropertyOptions());
baseSchema.AddChild(baseNode);
TransplantArrayItemAlias(propertyIt, currProp, baseNode);
}
}
else
{
if (info.GetAliasForm().IsSimple())
{
// The base node does exist and this is a top-to-top alias.
// Check for conflicts if strict aliasing is on.
// Remove and delete the alias subtree.
if (strictAliasing)
{
CompareAliasedSubtrees(currProp, baseNode, true);
}
propertyIt.Remove();
}
else
{
// This is an alias to an array item and the array exists.
// Look for the aliased item.
// Then transplant or check & delete as appropriate.
XMPNode itemNode = null;
if (info.GetAliasForm().IsArrayAltText())
{
int xdIndex = XMPNodeUtils.LookupLanguageItem(baseNode, XMPConstConstants.XDefault);
if (xdIndex != -1)
{
itemNode = baseNode.GetChild(xdIndex);
}
}
else
{
if (baseNode.HasChildren())
{
itemNode = baseNode.GetChild(1);
}
}
if (itemNode == null)
{
TransplantArrayItemAlias(propertyIt, currProp, baseNode);
}
else
{
if (strictAliasing)
{
CompareAliasedSubtrees(currProp, itemNode, true);
}
propertyIt.Remove();
}
}
}
}
}
currSchema.SetHasAliases(false);
}
}
/// <seealso cref="Com.Adobe.Xmp.XMPUtils.RemoveProperties(Com.Adobe.Xmp.XMPMeta, string, string, bool, bool)"/>
/// <param name="xmp">The XMP object containing the properties to be removed.</param>
/// <param name="schemaNS">
/// Optional schema namespace URI for the properties to be
/// removed.
/// </param>
/// <param name="propName">Optional path expression for the property to be removed.</param>
/// <param name="doAllProperties">
/// Option flag to control the deletion: do internal properties in
/// addition to external properties.
/// </param>
/// <param name="includeAliases">
/// Option flag to control the deletion: Include aliases in the
/// "named schema" case above.
/// </param>
/// <exception cref="Com.Adobe.Xmp.XMPException">If metadata processing fails</exception>
public static void RemoveProperties(XMPMeta xmp, string schemaNS, string propName, bool doAllProperties, bool includeAliases)
{
ParameterAsserts.AssertImplementation(xmp);
XMPMetaImpl xmpImpl = (XMPMetaImpl)xmp;
if (propName != null && propName.Length > 0)
{
// Remove just the one indicated property. This might be an alias,
// the named schema might not actually exist. So don't lookup the
// schema node.
if (schemaNS == null || schemaNS.Length == 0)
{
throw new XMPException("Property name requires schema namespace", XMPErrorConstants.Badparam);
}
XMPPath expPath = XMPPathParser.ExpandXPath(schemaNS, propName);
XMPNode propNode = XMPNodeUtils.FindNode(xmpImpl.GetRoot(), expPath, false, null);
if (propNode != null)
{
if (doAllProperties || !Utils.IsInternalProperty(expPath.GetSegment(XMPPath.StepSchema).GetName(), expPath.GetSegment(XMPPath.StepRootProp).GetName()))
{
XMPNode parent = propNode.GetParent();
parent.RemoveChild(propNode);
if (parent.GetOptions().IsSchemaNode() && !parent.HasChildren())
{
// remove empty schema node
parent.GetParent().RemoveChild(parent);
}
}
}
}
else
{
if (schemaNS != null && schemaNS.Length > 0)
{
// Remove all properties from the named schema. Optionally include
// aliases, in which case
// there might not be an actual schema node.
// XMP_NodePtrPos schemaPos;
XMPNode schemaNode = XMPNodeUtils.FindSchemaNode(xmpImpl.GetRoot(), schemaNS, false);
if (schemaNode != null)
{
if (RemoveSchemaChildren(schemaNode, doAllProperties))
{
xmpImpl.GetRoot().RemoveChild(schemaNode);
}
}
if (includeAliases)
{
// We're removing the aliases also. Look them up by their
// namespace prefix.
// But that takes more code and the extra speed isn't worth it.
// Lookup the XMP node
// from the alias, to make sure the actual exists.
XMPAliasInfo[] aliases = XMPMetaFactory.GetSchemaRegistry().FindAliases(schemaNS);
for (int i = 0; i < aliases.Length; i++)
{
XMPAliasInfo info = aliases[i];
XMPPath path = XMPPathParser.ExpandXPath(info.GetNamespace(), info.GetPropName());
XMPNode actualProp = XMPNodeUtils.FindNode(xmpImpl.GetRoot(), path, false, null);
if (actualProp != null)
{
XMPNode parent = actualProp.GetParent();
parent.RemoveChild(actualProp);
}
}
}
}
else
{
// Remove all appropriate properties from all schema. In this case
// we don't have to be
// concerned with aliases, they are handled implicitly from the
// actual properties.
for (Iterator it = xmpImpl.GetRoot().IterateChildren(); it.HasNext();)
{
XMPNode schema = (XMPNode)it.Next();
if (RemoveSchemaChildren(schema, doAllProperties))
{
it.Remove();
}
}
}
}
}
