/// <summary>
/// Throws if the <see cref="OpenXmlPart"/> is not supported in the given version
/// </summary>
/// <param name="version">Version to check</param>
/// <param name="part">Part to validate</param>
public static void ThrowIfNotInVersion(this FileFormatVersions version, OpenXmlPart part)
{
version.ThrowExceptionIfFileFormatNotSupported(nameof(version));
if (!part.IsInVersion(version))
{
throw new InvalidOperationException(SR.Format(ExceptionMessages.PartIsNotInOfficeVersion, version.GetOfficeYear()));
}
}
private void ValidatePart(OpenXmlPart part, ValidationContext context)
{
// if the part is not defined in the specified version, then do not validate the content.
if (!part.IsInVersion(_cache.Version))
{
return;
}
/*******************
* DOM traversal is not performance bottleneck.
* Is this the good way that we separate the schema validation and the semantics validation?
*******************/
try
{
// Must be called before the call to PartRootElement { get; }
bool partRootElementLoaded = part.IsRootElementLoaded;
// Schema validation
using (context.Stack.Push(part: part, element: part.PartRootElement))
{
var lastErrorCount = context.Errors.Count;
if (part.PartRootElement != null)
{
_schemaValidator.Validate(context);
// TODO: Is this needed? It's set 8 lines up
using (context.Stack.Push(element: part.PartRootElement))
{
context.Events.OnPartValidationStarted(context);
_semanticValidator.Validate(context);
}
}
if (!partRootElementLoaded && context.Errors.Count == lastErrorCount)
{
// No new errors in this part. Release the DOM to GC memory.
part.SetPartRootElementToNull();
}
}
}
catch (System.Xml.XmlException e)
{
var errorInfo = new ValidationErrorInfo
{
ErrorType = ValidationErrorType.Schema,
Id = "ExceptionError",
Part = part,
Description = SR.Format(ValidationResources.ExceptionError, e.Message),
};
context.AddError(errorInfo);
}
}
/// <summary>
/// Throws if the <see cref="OpenXmlPart"/> is not supported in the given version
/// </summary>
/// <param name="version">Version to check</param>
/// <param name="part">Part to validate</param>
public static void ThrowIfNotInVersion(this FileFormatVersions version, OpenXmlPart part)
{
version.ThrowExceptionIfFileFormatNotSupported(nameof(version));
if (!part.IsInVersion(version))
{
var message = string.Format(CultureInfo.CurrentCulture, ExceptionMessages.PartIsNotInOfficeVersion, version.GetOfficeYear());
throw new InvalidOperationException(message);
}
}
public void ValidateValid(OpenXmlPart part)
{
var availability = part.GetType().GetCustomAttribute <OfficeAvailabilityAttribute>().OfficeVersion;
var versions = Enum.GetValues(typeof(FileFormatVersions))
.Cast <FileFormatVersions>()
.Where(v => v != FileFormatVersions.None);
foreach (var version in versions)
{
Assert.Equal(version.AtLeast(availability), part.IsInVersion(version));
}
}
private void ValidatePart(OpenXmlPart part, ValidationContext context)
{
// if the part is not defined in the specified version, then do not validate the content.
if (!part.IsInVersion(_validationSettings.FileFormat))
{
return;
}
/*******************
* DOM traversal is not performance bottleneck.
* Is this the good way that we separate the schema validation and the semantics validation?
*******************/
try
{
// Must be called before the call to PartRootElement { get; }
bool partRootElementLoaded = part.IsRootElementLoaded;
// schema validation
context.Part = part;
context.Element = part.PartRootElement;
var lastErrorCount = context.Errors.Count;
if (part.PartRootElement != null)
{
_schemaValidator.Validate(context);
context.Element = part.PartRootElement;
_semanticValidator.ClearConstraintState(SemanticValidationLevel.PartOnly);
_semanticValidator.Validate(context);
}
if (!partRootElementLoaded && context.Errors.Count == lastErrorCount)
{
// No new errors in this part. Release the DOM to GC memory.
part.SetPartRootElementToNull();
}
}
catch (System.Xml.XmlException e)
{
var errorInfo = new ValidationErrorInfo
{
ErrorType = ValidationErrorType.Schema,
Id = "ExceptionError",
Part = part,
Path = new XmlPath(part),
Description = string.Format(CultureInfo.CurrentUICulture, ValidationResources.ExceptionError, e.Message)
};
context.AddError(errorInfo);
}
}
/// <summary>
/// Validates the specified content in the OpenXmlPart.
/// </summary>
/// <param name="openXmlPart">The target OpenXmlPart.</param>
/// <returns>A set of validation erros.</returns>
/// <exception cref="ArgumentNullException">Thrown when the "openXmlPart" parameter is null.</exception>
/// <exception cref="InvalidOperationException">Throw when the specified part is not a defined part in the specified FileFormat version.</exception>
public IEnumerable <ValidationErrorInfo> Validate(OpenXmlPart openXmlPart)
{
if (openXmlPart == null)
{
throw new ArgumentNullException(nameof(openXmlPart));
}
var openXmlPackage = openXmlPart.OpenXmlPackage;
if (openXmlPackage.OpenSettings.MarkupCompatibilityProcessSettings.ProcessMode != MarkupCompatibilityProcessMode.NoProcess &&
openXmlPackage.OpenSettings.MarkupCompatibilityProcessSettings.TargetFileFormatVersions != FileFormat)
{
string exceptionMessage = string.Format(System.Globalization.CultureInfo.CurrentUICulture,
ExceptionMessages.DocumentFileFormatVersionMismatch,
openXmlPackage.OpenSettings.MarkupCompatibilityProcessSettings.TargetFileFormatVersions, FileFormat);
throw new InvalidOperationException(exceptionMessage);
}
if (!openXmlPart.IsInVersion(FileFormat))
{
if (openXmlPart is ExtendedPart)
{
throw new InvalidOperationException(ExceptionMessages.PartNotInVersion);
}
else
{
// All Office 2007 and 2010 parts are allowed in Office 2013.
switch (FileFormat)
{
case FileFormatVersions.Office2007:
throw new InvalidOperationException(ExceptionMessages.PartIsNotInOffice2007);
case FileFormatVersions.Office2010:
throw new InvalidOperationException(ExceptionMessages.PartIsNotInOffice2010);
case FileFormatVersions.Office2013: // Falls through...
default:
throw new InvalidOperationException(ExceptionMessages.PartIsNotInOffice2013);
}
}
}
return(ValidateCore(openXmlPart));
}
private void ValidatePart(OpenXmlPart part, ValidationContext context)
{
// if the part is not defined in the specified version, then do not validate the content.
if (!part.IsInVersion(_cache.Version))
{
return;
}
try
{
// Must be called before the call to PartRootElement { get; }
bool partRootElementLoaded = part.IsRootElementLoaded;
// Schema validation
using (context.Stack.Push(part: part, element: part.PartRootElement))
{
var lastErrorCount = context.Errors.Count;
if (part.PartRootElement is not null)
{
Validate(context);
}
if (!partRootElementLoaded && context.Errors.Count == lastErrorCount)
{
// No new errors in this part. Release the DOM to GC memory.
part.UnloadRootElement();
}
}
}
catch (System.Xml.XmlException e)
{
var errorInfo = new ValidationErrorInfo
{
ErrorType = ValidationErrorType.Schema,
Id = "ExceptionError",
Part = part,
Description = SR.Format(ValidationResources.ExceptionError, e.Message),
};
context.AddError(errorInfo);
}
}
/// <summary>
/// Validate the specified part.
/// </summary>
/// <param name="part">The OpenXmlPart to be validated.</param>
internal void ValidatePart(OpenXmlPart part)
{
// if the part is not defined in the specified version, then do not validate the content.
if ( ! part.IsInVersion(this.ValidationSettings.FileFormat))
{
return;
}
/*******************
* DOM traverse is not performance bottleneck.
* Is this the good way that we separate the schema validtion and the semantics validation?
*******************/
try
{
// Must be called before the call to PartRootElement { get; }
bool partRootElementLoaded = part.IsRootElementLoaded;
// schema validation
this.ValidationContext.Part = part;
this.ValidationContext.Element = part.PartRootElement;
var lastErrorCount = this.ValidationResult.Errors.Count;
if (part.PartRootElement != null)
{
this.SchemaValidator.Validate(this.ValidationContext);
this.ValidationContext.Element = part.PartRootElement;
this.SemanticValidator.ClearConstraintState(SemanticValidationLevel.PartOnly);
this.SemanticValidator.Validate(this.ValidationContext);
}
if (!partRootElementLoaded &&
this.ValidationResult.Errors.Count == lastErrorCount)
{
// No new errors in this part. Release the DOM to GC memary.
part.SetPartRootElementToNull();
}
}
catch (System.Xml.XmlException e)
{
ValidationErrorInfo errorInfo = new ValidationErrorInfo();
errorInfo.ErrorType = ValidationErrorType.Schema;
errorInfo.Id = "ExceptionError";
errorInfo.Part = part;
errorInfo.Path = new XmlPath(part);
errorInfo.Description = string.Format(System.Globalization.CultureInfo.CurrentUICulture,
ValidationResources.ExceptionError, e.Message);
this.ValidationResult.AddError(errorInfo);
}
}
/// <summary>
/// Validates the specified content in the OpenXmlPart.
/// </summary>
/// <param name="openXmlPart">The target OpenXmlPart.</param>
/// <returns>A set of validation erros.</returns>
/// <exception cref="ArgumentNullException">Thrown when the "openXmlPart" parameter is null.</exception>
/// <exception cref="InvalidOperationException">Throw when the specified part is not a defined part in the specified FileFormat version.</exception>
public IEnumerable <ValidationErrorInfo> Validate(OpenXmlPart openXmlPart)
{
if (openXmlPart == null)
{
throw new ArgumentNullException(nameof(openXmlPart));
}
var openXmlPackage = openXmlPart.OpenXmlPackage;
if (openXmlPackage.OpenSettings.MarkupCompatibilityProcessSettings.ProcessMode != MarkupCompatibilityProcessMode.NoProcess &&
openXmlPackage.OpenSettings.MarkupCompatibilityProcessSettings.TargetFileFormatVersions != this.FileFormat)
{
string exceptionMessage = string.Format(System.Globalization.CultureInfo.CurrentUICulture,
ExceptionMessages.DocumentFileFormatVersionMismatch,
openXmlPackage.OpenSettings.MarkupCompatibilityProcessSettings.TargetFileFormatVersions, this.FileFormat);
throw new InvalidOperationException(exceptionMessage);
}
if (!openXmlPart.IsInVersion(this.FileFormat))
{
if (openXmlPart is ExtendedPart)
{
throw new InvalidOperationException(ExceptionMessages.PartNotInVersion);
}
else
{
string strMessage;
// All Office 2007 and 2010 parts are allowed in Office 2013.
switch (this.FileFormat)
{
case FileFormatVersions.Office2007:
strMessage = ExceptionMessages.PartIsNotInOffice2007;
break;
case FileFormatVersions.Office2010:
strMessage = ExceptionMessages.PartIsNotInOffice2010;
break;
case FileFormatVersions.Office2013: // Falls through...
default:
strMessage = ExceptionMessages.PartIsNotInOffice2013;
break;
}
throw new InvalidOperationException(strMessage);
}
}
// Do NOT use "yield return" in this method, as "yield return" are deferred executed.
// Otherwise, the null check is not performed when the method is called, but rather, when the returned enumerator is moved for the first time.
// That means that the exception isn't thrown until possibly far, far away from the actual site of the error, which is potentially confusing.
OpenXmlPackage package = openXmlPart.OpenXmlPackage;
Debug.Assert(package != null);
ValidationResult validationResult = null;
switch (DocumentTypeDetector.GetDocumentType(package))
{
case OpenXmlDocumentType.Spreadsheet:
validationResult = this.SpreadsheetDocumentValidator.Validate(openXmlPart);
break;
case OpenXmlDocumentType.Wordprocessing:
validationResult = this.WordprocessingDocumentValidator.Validate(openXmlPart);
break;
case OpenXmlDocumentType.Presentation:
validationResult = this.PresentationDocumentValidator.Validate(openXmlPart);
break;
default:
throw new System.IO.InvalidDataException(ExceptionMessages.UnknownPackage);
}
return(this.YieldResult(validationResult));
}
/// <summary>
/// Validates the specified content in the OpenXmlPart.
/// </summary>
/// <param name="openXmlPart">The target OpenXmlPart.</param>
/// <returns>A set of validation erros.</returns>
/// <exception cref="ArgumentNullException">Thrown when the "openXmlPart" parameter is null.</exception>
/// <exception cref="InvalidOperationException">Throw when the specified part is not a defined part in the specified FileFormat version.</exception>
public IEnumerable<ValidationErrorInfo> Validate(OpenXmlPart openXmlPart)
{
if (openXmlPart == null)
{
throw new ArgumentNullException("openXmlPart");
}
var openXmlPackage = openXmlPart.OpenXmlPackage;
if (openXmlPackage.OpenSettings.MarkupCompatibilityProcessSettings.ProcessMode != MarkupCompatibilityProcessMode.NoProcess &&
openXmlPackage.OpenSettings.MarkupCompatibilityProcessSettings.TargetFileFormatVersions != this.FileFormat)
{
string exceptionMessage = string.Format(System.Globalization.CultureInfo.CurrentUICulture,
ExceptionMessages.DocumentFileFormatVersionMismatch,
openXmlPackage.OpenSettings.MarkupCompatibilityProcessSettings.TargetFileFormatVersions, this.FileFormat);
throw new InvalidOperationException(exceptionMessage);
}
if (!openXmlPart.IsInVersion(this.FileFormat))
{
if (openXmlPart is ExtendedPart)
{
throw new InvalidOperationException(ExceptionMessages.PartNotInVersion);
}
else
{
string strMessage;
// All Office 2007 and 2010 parts are allowed in Office 2013.
switch (this.FileFormat)
{
case FileFormatVersions.Office2007:
strMessage = ExceptionMessages.PartIsNotInOffice2007;
break;
case FileFormatVersions.Office2010:
strMessage = ExceptionMessages.PartIsNotInOffice2010;
break;
case FileFormatVersions.Office2013: // Falls through...
default:
strMessage = ExceptionMessages.PartIsNotInOffice2013;
break;
}
throw new InvalidOperationException(strMessage);
}
}
// Do NOT use "yield return" in this method, as "yield return" are deferred executed.
// Otherwise, the null check is not performed when the method is called, but rather, when the returned enumerator is moved for the first time.
// That means that the exception isn't thrown until possibly far, far away from the actual site of the error, which is potentially confusing.
OpenXmlPackage package = openXmlPart.OpenXmlPackage;
Debug.Assert(package != null);
ValidationResult validationResult = null;
switch (DocumentTypeDetector.GetDocumentType(package))
{
case OpenXmlDocumentType.Spreadsheet:
validationResult = this.SpreadsheetDocumentValidator.Validate(openXmlPart);
break;
case OpenXmlDocumentType.Wordprocessing:
validationResult = this.WordprocessingDocumentValidator.Validate(openXmlPart);
break;
case OpenXmlDocumentType.Presentation:
validationResult = this.PresentationDocumentValidator.Validate(openXmlPart);
break;
default:
throw new System.IO.InvalidDataException(ExceptionMessages.UnknownPackage);
}
return this.YieldResult(validationResult);
}