public AttributeRequiredConditionToValue(OpenXmlQualifiedName requiredAttribute, OpenXmlQualifiedName conditionAttribute, string value)
: base(SemanticValidationLevel.Element)
{
_requiredAttribute = requiredAttribute;
_conditionAttribute = conditionAttribute;
_value = value;
}
public AttributeAbsentConditionToValue(OpenXmlQualifiedName absentAttribute, OpenXmlQualifiedName conditionAttribute, params string[] values)
: base(SemanticValidationLevel.Element)
{
_absentAttribute = absentAttribute;
_conditionAttribute = conditionAttribute;
_values = values;
}
public AttributeValueLessEqualToAnother(OpenXmlQualifiedName attribute, OpenXmlQualifiedName otherAttribute, bool canEqual)
: base(SemanticValidationLevel.Element)
{
_attribute = attribute;
_otherAttribute = otherAttribute;
_canEqual = canEqual;
}
public UniqueAttributeValueConstraint(OpenXmlQualifiedName attribute, bool caseSensitive, OpenXmlQualifiedName?parent)
: base(SemanticValidationLevel.Part)
{
_attribute = attribute;
_parent = parent;
_comparer = caseSensitive ? StringComparer.Ordinal : StringComparer.OrdinalIgnoreCase;
}
public AttributeValueConditionToAnother(OpenXmlQualifiedName attribute, OpenXmlQualifiedName conditionAttribute, string[] values, string[] otherValues)
: base(SemanticValidationLevel.Element)
{
_attribute = attribute;
_conditionAttribute = conditionAttribute;
_values = values;
_otherValues = otherValues;
}
public RelationshipTypeConstraint(OpenXmlQualifiedName attribute, string type)
: base(SemanticValidationLevel.Part)
{
Debug.Assert(!string.IsNullOrEmpty(type));
_attribute = attribute;
_type = type;
}
public IndexReferenceConstraint(OpenXmlQualifiedName attribute, string referencedPart, OpenXmlQualifiedName?referencedElementParent, OpenXmlQualifiedName referencedElement, string referencedElementName, int indexBase)
: base(SemanticValidationLevel.Package)
{
_attribute = attribute;
_refPartType = referencedPart;
_refElement = referencedElement;
_refElementParent = referencedElementParent;
_indexBase = indexBase;
}
/// <summary>
/// Initializes a new instance of the SchemaAttrAttribute.
/// </summary>
/// <param name="qname">Qualified name of item.</param>
/// <remarks>This will be removed once the concept of id can be removed. Please use <see cref="SchemaAttrAttribute(string, string)"/></remarks>
public SchemaAttrAttribute(string qname)
{
if (string.IsNullOrEmpty(qname))
{
throw new ArgumentNullException(nameof(qname));
}
_qname = qname;
}
public AttributeValueSetConstraint(OpenXmlQualifiedName attribute, bool isValid, string[] valueSet)
: base(SemanticValidationLevel.Element)
{
Debug.Assert(valueSet.Length > 0);
_attribute = attribute;
_isValidValueSet = isValid;
_valueSet = valueSet;
}
/// <summary>
/// Initializes a new instance of the SchemaAttrAttribute.
/// </summary>
/// <param name="ns">Specifies the namespace of the schema attribute.</param>
/// <param name="tag">Specifies the Tag name of the schema attribute.</param>
public SchemaAttrAttribute(string ns, string tag)
{
if (string.IsNullOrEmpty(tag))
{
throw new ArgumentNullException(nameof(tag));
}
_qname = new OpenXmlQualifiedName(ns, tag);
}
public AttributeValueLengthConstraint(OpenXmlQualifiedName attribute, int minLength, int maxLength)
: base(SemanticValidationLevel.Element)
{
Debug.Assert(minLength >= 0);
Debug.Assert(maxLength >= 0);
Debug.Assert(maxLength >= minLength);
_attribute = attribute;
_maxLength = maxLength;
_minLength = minLength;
}
public ReferenceExistConstraint(OpenXmlQualifiedName refAttribute, string part, OpenXmlQualifiedName element, string elementName, OpenXmlQualifiedName attribute)
: base(SemanticValidationLevel.Package)
{
Debug.Assert(!string.IsNullOrEmpty(part));
_refAttribute = refAttribute;
_partPath = part;
_element = element;
_elementName = elementName;
_attribute = attribute;
}
public AttributeValueRangeConstraint(OpenXmlQualifiedName attribute, bool isValid, double minValue, bool minInclusive, double maxValue, bool maxInclusive)
: base(SemanticValidationLevel.Element)
{
Debug.Assert(minValue <= maxValue);
_attribute = attribute;
_isValidRange = isValid;
_minValue = minValue;
_maxValue = maxValue;
_minInclusive = minInclusive;
_maxInclusive = maxInclusive;
}
/// <summary>
/// Initializes a new instance of the OpenXmlUnknownElement class using
/// the supplied element name.
/// </summary>
/// <param name="name">
/// The element name.
/// </param>
public OpenXmlUnknownElement(string name)
: this()
{
if (name is null)
{
throw new ArgumentNullException(nameof(name));
}
var schema = OpenXmlQualifiedName.Parse(name);
_prefix = schema.Namespace.Prefix;
_tagName = schema.Name;
}
/// <summary>
/// Trys to create an OpenXmlElement from the specified namespace URI and local name.
/// </summary>
/// <param name="parent">The parent element.</param>
/// <param name="fileFormat">The specified file format version.</param>
/// <param name="namespaceUri">The namespace URI of the requested child element.</param>
/// <param name="localName">The local name of the requested child element.</param>
/// <returns>A new OpenXmlElement if the parent element can contains a child with the specified namespace and local name. Otherwise, returns null.</returns>
internal static OpenXmlElement?TryCreateValidChild(this OpenXmlElement parent, FileFormatVersions fileFormat, string namespaceUri, string localName)
{
Debug.Assert(parent is OpenXmlCompositeElement);
var newElement = parent.CreateElement(OpenXmlQualifiedName.Create(namespaceUri, string.Empty, localName));
if (newElement is OpenXmlUnknownElement || !newElement.IsInVersion(fileFormat))
{
return(null);
}
return(newElement);
}
public AttributeValuePatternConstraint(OpenXmlQualifiedName attribute, string pattern)
: base(SemanticValidationLevel.Element)
{
Debug.Assert(!string.IsNullOrEmpty(pattern));
_attribute = attribute;
if (!pattern.StartsWith("^", StringComparison.Ordinal) || !pattern.EndsWith("$", StringComparison.Ordinal))
{
pattern = string.Concat("^", pattern, "$");
}
_pattern = new Regex(pattern, RegexOptions.Compiled);
}
internal ElementMetadata(
ReadOnlyArray <AttributeMetadata> attributes,
ReadOnlyArray <IValidator> validators,
ReadOnlyArray <IValidator> constraints,
FileFormatVersions version,
OpenXmlQualifiedName qname,
CompiledParticle?particle,
Lazy <ElementLookup> lookup)
{
Attributes = attributes;
Validators = validators;
Constraints = constraints;
Availability = version;
QName = qname;
Particle = particle;
_children = lookup;
}
protected static bool TryFindAttribute(OpenXmlElement element, OpenXmlQualifiedName attribute, out AttributeCollection.AttributeEntry result)
{
result = default;
foreach (var entry in element.ParsedState.Attributes)
{
// Some schematron expressions don't have the right namespace, so we'll allow that if there's no exact match
if (string.Equals(entry.Property.QName.Name, attribute.Name, StringComparison.Ordinal))
{
result = entry;
if (entry.Property.QName.Namespace.Equals(attribute.Namespace))
{
return(true);
}
}
}
return(!result.IsNil);
}
public AttributeMutualExclusive(OpenXmlQualifiedName attribute)
: this(new[] { attribute })
{
}
public AttributeEntry this[in OpenXmlQualifiedName qname] => this[GetIndex(qname)];
public AttributeMutualExclusive(OpenXmlQualifiedName attribute1, OpenXmlQualifiedName attribute2, OpenXmlQualifiedName attribute3, OpenXmlQualifiedName attribute4, OpenXmlQualifiedName attribute5, OpenXmlQualifiedName attribute6)
: this(new[] { attribute1, attribute2, attribute3, attribute4, attribute5, attribute6 })
{
}
public RelationshipExistConstraint(OpenXmlQualifiedName attribute)
: base(SemanticValidationLevel.Part)
{
_attribute = attribute;
}
/// <summary>
/// Populates the XML into a strong typed DOM tree.
/// </summary>
/// <param name="xmlReader">The XmlReader to read the XML content.</param>
/// <param name="loadMode">Specifies a load mode that is either lazy or full.</param>
private protected override void Populate(XmlReader xmlReader, OpenXmlLoadMode loadMode)
{
LoadAttributes(xmlReader);
if (!xmlReader.IsEmptyElement)
{
xmlReader.Read(); // read this element
while (!xmlReader.EOF)
{
// O15:#3024890, OpenXmlCompositeElement ignores the Whitespace NodeType.
if (xmlReader.NodeType == XmlNodeType.Whitespace)
{
xmlReader.Skip();
continue;
}
else if (xmlReader.NodeType == XmlNodeType.EndElement)
{
Debug.Assert(string.Equals(xmlReader.LocalName, LocalName, StringComparison.Ordinal));
xmlReader.Skip(); // move to next node
break;
}
OpenXmlElement element = ElementFactory(xmlReader);
// set parent before Load( ) call. AlternateContentChoice need parent info on loading.
element.Parent = this;
bool isACB = element is AlternateContent;
if (isACB && element.OpenXmlElementContext is not null)
{
element.OpenXmlElementContext.ACBlockLevel++;
}
bool mcContextPushed = false;
if (!(element is OpenXmlMiscNode))
{
// push MC context based on the context of the child element to be loaded
mcContextPushed = PushMcContext(xmlReader);
}
//Process the element according to the MC behavior
var action = ElementAction.Normal;
if (OpenXmlElementContext is not null && OpenXmlElementContext.MCSettings.ProcessMode != DocumentFormat.OpenXml.Packaging.MarkupCompatibilityProcessMode.NoProcess)
{
action = OpenXmlElementContext.MCContext.GetElementAction(element, OpenXmlElementContext.MCSettings.TargetFileFormatVersions);
}
element.Load(xmlReader, loadMode);
if (mcContextPushed)
{
PopMcContext();
}
if (isACB && element.OpenXmlElementContext is not null)
{
element.OpenXmlElementContext.ACBlockLevel--;
}
switch (action)
{
case ElementAction.Normal:
{
AddANode(element);
break;
}
case ElementAction.Ignore:
{
element.Parent = null;
continue;
}
case ElementAction.ProcessContent:
{
element.Parent = null;
while (element.ChildElements.Count > 0)
{
if (element.FirstChild is not OpenXmlElement node)
{
break;
}
node.Remove();
var newnode = default(OpenXmlElement);
// If node is an UnknowElement, we should try to see whether the parent element can load the node as strong typed element
if (node is OpenXmlUnknownElement)
{
newnode = CreateElement(OpenXmlQualifiedName.Create(node.NamespaceUri, node.Prefix, node.LocalName));
if (!(newnode is OpenXmlUnknownElement))
{
// The following method will load teh element in MCMode.Full
// since the node is already MC-processed when loading as unknown type, full loading the outerXml is fine
newnode.OuterXml = node.OuterXml;
// unnecessary xmlns attribute will be added, remove it.
RemoveUnnecessaryExtAttr(node, newnode);
}
else
{
newnode = null;
}
}
if (newnode is not null)
{
AddANode(newnode);
}
else
{
//append the original node
AddANode(node);
}
}
break;
}
case ElementAction.ACBlock:
{
if (element is not AlternateContent acb)
{
break;
}
var effectiveNode = OpenXmlElementContext?.MCContext.GetContentFromACBlock(acb, OpenXmlElementContext.MCSettings.TargetFileFormatVersions);
if (effectiveNode is null)
{
break;
}
element.Parent = null;
effectiveNode.Parent = null;
while (effectiveNode.FirstChild is not null)
{
var node = effectiveNode.FirstChild;
node.Remove();
AddANode(node);
node.CheckMustUnderstandAttr();
}
break;
}
}
}
}
else
{
xmlReader.Skip();
}
// Set raw outer xml to empty to indicate that it passed
RawOuterXml = string.Empty;
}
public AttributeCannotOmitConstraint(OpenXmlQualifiedName attribute)
: base(SemanticValidationLevel.Element)
{
_attribute = attribute;
}
/// <summary>
/// Load the DOM tree from the Open XML part.
/// </summary>
/// <param name="openXmlPart">The part this root element to be loaded from.</param>
/// <param name="partStream">The stream of the part.</param>
/// <returns>
/// Returns true when the part stream is loaded successfully into this root element.
/// Returns false when the part stream does not contain any xml element.
/// </returns>
/// <exception cref="InvalidDataException">Thrown when the part stream contains an incorrect root element.</exception>
internal bool LoadFromPart(OpenXmlPart openXmlPart, Stream partStream)
{
if (partStream.Length < 4)
{
// The XmlReader.Read() method requires at least four bytes from the data stream in order to begin parsing.
return(false);
}
var context = RootElementContext;
// set MaxCharactersInDocument to limit the part size on loading DOM.
context.XmlReaderSettings.MaxCharactersInDocument = openXmlPart.MaxCharactersInPart;
#if FEATURE_XML_PROHIBIT_DTD
context.XmlReaderSettings.ProhibitDtd = true; // set true explicitly for security fix
#else
context.XmlReaderSettings.DtdProcessing = DtdProcessing.Prohibit; // set to prohibit explicitly for security fix
#endif
using (var xmlReader = XmlConvertingReaderFactory.Create(partStream, context.XmlReaderSettings, openXmlPart.OpenXmlPackage.StrictRelationshipFound))
{
context.MCSettings = openXmlPart.MCSettings;
xmlReader.Read();
if (xmlReader.NodeType == XmlNodeType.XmlDeclaration)
{
var standaloneAttribute = xmlReader.GetAttribute("standalone");
if (standaloneAttribute is not null)
{
_standaloneDeclaration = standaloneAttribute.Equals("yes", StringComparison.OrdinalIgnoreCase);
}
}
if (!xmlReader.EOF)
{
xmlReader.MoveToContent();
}
if (xmlReader.EOF ||
xmlReader.NodeType != XmlNodeType.Element ||
!xmlReader.IsStartElement())
{
//the stream does NOT contains any xml element.
return(false);
}
var qname = new OpenXmlQualifiedName(xmlReader.NamespaceURI, xmlReader.LocalName);
if (!qname.Namespace.IsKnown || !QName.Equals(qname))
{
var elementQName = new XmlQualifiedName(xmlReader.LocalName, xmlReader.NamespaceURI).ToString();
var msg = SR.Format(ExceptionMessages.Fmt_PartRootIsInvalid, elementQName, XmlQualifiedName.ToString());
throw new InvalidDataException(msg);
}
// remove all children and clear all attributes
OuterXml = string.Empty;
var mcContextPushed = PushMcContext(xmlReader);
Load(xmlReader, context.LoadMode);
if (mcContextPushed)
{
PopMcContext();
}
}
return(true);
}
public AttributeMutualExclusive(OpenXmlQualifiedName attribute1, OpenXmlQualifiedName attribute2, OpenXmlQualifiedName attribute3)
: this(new[] { attribute1, attribute2, attribute3 })
{
}
