void AddElementToSchema(XmlSchemaElement element, string elementNs, XmlSchemaSet schemaSet)
{
OperationDescription parentOperation = this.operation;
if (parentOperation.OperationMethod != null)
{
XmlQualifiedName qname = new XmlQualifiedName(element.Name, elementNs);
OperationElement existingElement;
if (ExportedMessages.ElementTypes.TryGetValue(qname, out existingElement))
{
if (existingElement.Operation.OperationMethod == parentOperation.OperationMethod)
return;
if (!SchemaHelper.IsMatch(element, existingElement.Element))
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR.GetString(SR.CannotHaveTwoOperationsWithTheSameElement5, parentOperation.OperationMethod.DeclaringType, parentOperation.OperationMethod.Name, qname, existingElement.Operation.OperationMethod.DeclaringType, existingElement.Operation.Name)));
}
return;
}
else
{
ExportedMessages.ElementTypes.Add(qname, new OperationElement(element, parentOperation));
}
}
SchemaHelper.AddElementToSchema(element, SchemaHelper.GetSchema(elementNs, schemaSet), schemaSet);
}
public string GetXml(bool validate)
{
XNamespace ns = "http://sd.ic.gc.ca/SLDR_Schema_Definition_en";
var spectrum_licences = getLicences();
XDocument doc = new XDocument(new XElement("spectrum_licence_data_registry", spectrum_licences));
foreach (XElement e in doc.Root.DescendantsAndSelf())
{
if (e.Name.Namespace == "")
e.Name = ns + e.Name.LocalName;
}
var errors = new StringBuilder();
if (validate)
{
XmlSchemaSet set = new XmlSchemaSet();
var schema = getMainSchema();
set.Add(null, schema);
doc.Validate(set, (sender, args) => { errors.AppendLine(args.Message); });
}
//return errors.Length > 0 ? errors.ToString() : doc.ToString();
var result = errors.Length > 0 ? "Validation Errors: " + errors.ToString() : getDocumentAsString(doc);
return result;
}
public void Import(XmlSchemaSet schemas)
{
if (schemas == null)
throw System.Runtime.Serialization.DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentNullException("schemas"));
InternalImport(schemas, null, null, null);
}
private static XmlSchemaSet LoadSchema(Stream xsd)
{
var reader = XmlReader.Create(xsd);
var set = new XmlSchemaSet();
set.Add(null, reader);
return set;
}
private string Validate(string path)
{
var sc = new XmlSchemaSet();
string dir = @"..\..\..\..\Schemas\Collada\";
sc.Add("http://www.collada.org/2008/03/COLLADASchema", dir + "collada_schema_1_5.xsd");
return Validate(path, sc);
}
public void v2()
{
XmlSchemaSet sc = new XmlSchemaSet();
try
{
XmlSchema Schema1 = sc.Add(null, TestData._XsdAuthor);
CError.Compare(sc.Count, 1, "AddCount");
CError.Compare(sc.Contains(Schema1), true, "AddContains");
CError.Compare(sc.IsCompiled, false, "AddIsCompiled");
XmlSchema Schema2 = XmlSchema.Read(new StreamReader(new FileStream(TestData._XsdNoNs, FileMode.Open, FileAccess.Read)), null);
sc.Compile();
CError.Compare(sc.Count, 1, "Compile");
CError.Compare(sc.Contains(Schema1), true, "Contains");
sc.Reprocess(Schema2);
CError.Compare(sc.Count, 1, "Reprocess");
CError.Compare(sc.Contains(Schema2), true, "Contains");
}
catch (ArgumentException e)
{
_output.WriteLine(e.ToString());
CError.Compare(sc.Count, 1, "AE");
return;
}
Assert.True(false);
}
public static XmlQualifiedName GetSchema(XmlSchemaSet schemaSet)
{
String wikiPageWebPartSchemaString = "<?xml version=\"1.0\" encoding=\"utf-8\"?>" +
"<xsd:schema targetNamespace=\"http://schemas.dev.office.com/PnP/2015/12/ProvisioningSchema\" " +
"elementFormDefault=\"qualified\" " +
"xmlns=\"http://schemas.dev.office.com/PnP/2015/12/ProvisioningSchema\" " +
"xmlns:pnp=\"http://schemas.dev.office.com/PnP/2015/12/ProvisioningSchema\" " +
"xmlns:xsd=\"http://www.w3.org/2001/XMLSchema\">" +
"<xsd:complexType name=\"WikiPageWebPart\">" +
"<xsd:all>" +
"<xsd:element name=\"Contents\" minOccurs=\"1\" maxOccurs=\"1\">" +
"<xsd:complexType>" +
"<xsd:sequence>" +
"<xsd:any processContents=\"lax\" namespace=\"##any\" minOccurs=\"0\" />" +
"</xsd:sequence>" +
"</xsd:complexType>" +
"</xsd:element>" +
"</xsd:all>" +
"<xsd:attribute name=\"Title\" type=\"xsd:string\" use=\"required\" />" +
"<xsd:attribute name=\"Row\" type=\"xsd:int\" use=\"required\" />" +
"<xsd:attribute name=\"Column\" type=\"xsd:int\" use=\"required\" />" +
"</xsd:complexType>" +
"</xsd:schema>";
XmlSchema webPartSchema = XmlSchema.Read(new StringReader(wikiPageWebPartSchemaString), null);
schemaSet.XmlResolver = new XmlUrlResolver();
schemaSet.Add(webPartSchema);
return (new XmlQualifiedName("WikiPageWebPart", XMLConstants.PROVISIONING_SCHEMA_NAMESPACE_2015_12));
}
public static System.Xml.Schema.XmlSchemaComplexType GetTypedDataSetSchema(System.Xml.Schema.XmlSchemaSet xs)
{
TypedDataSet ds = new TypedDataSet();
System.Xml.Schema.XmlSchemaComplexType type = new System.Xml.Schema.XmlSchemaComplexType();
System.Xml.Schema.XmlSchemaSequence sequence = new System.Xml.Schema.XmlSchemaSequence();
xs.Add(ds.GetSchemaSerializable());
if (PublishLegacyWSDL())
{
System.Xml.Schema.XmlSchemaAny any = new System.Xml.Schema.XmlSchemaAny();
any.Namespace = ds.Namespace;
sequence.Items.Add(any);
}
else
{
System.Xml.Schema.XmlSchemaAny any1 = new System.Xml.Schema.XmlSchemaAny();
any1.Namespace = "http://www.w3.org/2001/XMLSchema";
any1.MinOccurs = new System.Decimal(0);
any1.ProcessContents = System.Xml.Schema.XmlSchemaContentProcessing.Lax;
sequence.Items.Add(any1);
System.Xml.Schema.XmlSchemaAny any2 = new System.Xml.Schema.XmlSchemaAny();
any2.Namespace = "urn:schemas-microsoft-com:xml-diffgram-v1";
any2.MinOccurs = new System.Decimal(0);
any2.ProcessContents = System.Xml.Schema.XmlSchemaContentProcessing.Lax;
sequence.Items.Add(any2);
sequence.MaxOccurs = System.Decimal.MaxValue;
System.Xml.Schema.XmlSchemaAttribute attribute = new System.Xml.Schema.XmlSchemaAttribute();
attribute.Name = "namespace";
attribute.FixedValue = ds.Namespace;
type.Attributes.Add(attribute);
}
type.Particle = sequence;
return(type);
}
static void Main()
{
XmlSchemaSet schemas = new XmlSchemaSet();
schemas.Add("", "../../../Content/catalog.xsd");
var document = XDocument.Load("../../catalog.xml");
Console.WriteLine("Validating XML file...");
bool errors = false;
document.Validate(schemas, (o, e) =>
{
Console.WriteLine("{0}", e.Message);
errors = true;
});
Console.WriteLine("XML file {0}", errors ? "did not validate" : "validated");
Console.WriteLine(new string('*', 40));
Console.WriteLine("Add something incorrect in \"catalog.xml\" like deleting the <year> tag");
document.Root.Elements("album").Elements("year").Remove();
//Console.WriteLine(document);
Console.WriteLine("Validating XML file...");
errors = false;
document.Validate(schemas, (o, e) =>
{
Console.WriteLine("{0}", e.Message);
errors = true;
});
}
public static bool IsXmlValid(string schemaFile, string xmlFile)
{
try
{
var valid = true;
var sc = new XmlSchemaSet();
sc.Add(string.Empty, schemaFile);
var settings = new XmlReaderSettings { ValidationType = ValidationType.Schema, Schemas = sc };
settings.ValidationEventHandler += delegate { valid = false; };
settings.ValidationFlags = XmlSchemaValidationFlags.ReportValidationWarnings;
settings.IgnoreWhitespace = true;
var reader = XmlReader.Create(xmlFile, settings);
try
{
while (reader.Read()) {}
}
catch (XmlException xmlException)
{
Console.WriteLine(xmlException);
}
return valid;
}
catch
{
return false;
}
}
//[Variation(Desc = "v2 - Contains with non existing ns", Priority = 0)]
public void v2()
{
XmlSchemaSet sc = new XmlSchemaSet();
sc.Add("xsdauthor", TestData._XsdAuthor);
Assert.Equal(sc.Contains("test"), false);
return;
}
public static XmlQualifiedName GetSchema(XmlSchemaSet xmlSchemaSet)
{
if (xmlSchemaSet == null)
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("xmlSchemaSet");
XmlQualifiedName eprType = EprType;
XmlSchema eprSchema = GetEprSchema();
ICollection schemas = xmlSchemaSet.Schemas(Addressing200408Strings.Namespace);
if (schemas == null || schemas.Count == 0)
xmlSchemaSet.Add(eprSchema);
else
{
XmlSchema schemaToAdd = null;
foreach (XmlSchema xmlSchema in schemas)
{
if (xmlSchema.SchemaTypes.Contains(eprType))
{
schemaToAdd = null;
break;
}
else
schemaToAdd = xmlSchema;
}
if (schemaToAdd != null)
{
foreach (XmlQualifiedName prefixNsPair in eprSchema.Namespaces.ToArray())
schemaToAdd.Namespaces.Add(prefixNsPair.Name, prefixNsPair.Namespace);
foreach (XmlSchemaObject schemaObject in eprSchema.Items)
schemaToAdd.Items.Add(schemaObject);
xmlSchemaSet.Reprocess(schemaToAdd);
}
}
return eprType;
}
public XmlSchemaValidator(XmlNameTable nameTable, XmlSchemaSet schemas, IXmlNamespaceResolver namespaceResolver, XmlSchemaValidationFlags validationFlags)
{
if (nameTable == null)
{
throw new ArgumentNullException("nameTable");
}
if (schemas == null)
{
throw new ArgumentNullException("schemas");
}
if (namespaceResolver == null)
{
throw new ArgumentNullException("namespaceResolver");
}
this.nameTable = nameTable;
this.nsResolver = namespaceResolver;
this.validationFlags = validationFlags;
if (((validationFlags & XmlSchemaValidationFlags.ProcessInlineSchema) != XmlSchemaValidationFlags.None) || ((validationFlags & XmlSchemaValidationFlags.ProcessSchemaLocation) != XmlSchemaValidationFlags.None))
{
this.schemaSet = new XmlSchemaSet(nameTable);
this.schemaSet.ValidationEventHandler += schemas.GetEventHandler();
this.schemaSet.CompilationSettings = schemas.CompilationSettings;
this.schemaSet.XmlResolver = schemas.GetResolver();
this.schemaSet.Add(schemas);
this.validatedNamespaces = new Hashtable();
}
else
{
this.schemaSet = schemas;
}
this.Init();
}
public ClrMappingInfo GenerateMapping(XmlSchemaSet schemas)
{
if (schemas == null)
{
throw new ArgumentNullException("schemas");
}
schemas.ValidationEventHandler += new ValidationEventHandler(Validationcallback);
schemas.Compile();
this.schemas = schemas;
if (schemaErrorCount > 0)
{
Console.WriteLine("Schema cannot be compiled. Class generation aborted");
return null;
}
// Execute transformations
try
{
Xml.Fxt.FxtLinq2XsdInterpreter.Run(schemas, configSettings.trafo);
}
catch (Xml.Fxt.FxtException)
{
Console.WriteLine("Schema cannot be transformed. Class generation aborted");
return null;
}
return GenerateMetaModel();
}
//[Variation(Desc = "v1 - Contains with null")]
public void v1()
{
XmlSchemaSet sc = new XmlSchemaSet();
Assert.Equal(sc.Contains((String)null), false);
return;
}
public DatabaseVersionSetup Load(TextReader reader)
{
var versionSetup = new DatabaseVersionSetup();
var shemas = new XmlSchemaSet();
Assembly assem = typeof(DatabaseVersionSetup).Assembly;
using (Stream stream = assem.GetManifestResourceStream("DatabaseVersionControl.Core.Xsd.DVCSchema.xsd"))
{
if (stream != null){
shemas.Add("", XmlReader.Create(stream));
}
else{
throw new Exception("Could not load embedded resource Xsd.DVCSchema.xsd");
}
}
XDocument element = XDocument.Load(reader);
element.Validate(shemas, (sender, e) =>
{ if (_exception != null) _exception(e); }, true);
var profiles = element.XPathSelectElements("//profiles/profile");
versionSetup.DefaultProfile = element.Root.Attribute("defaultProfile").Value;
LoadProfiles(versionSetup, profiles);
var databases = element.XPathSelectElements("//repositories/repository");
LoadRepositories(versionSetup, databases);
return versionSetup;
}
private static void ValidateXml(XDocument document, XmlSchemaSet schema)
{
document.Validate(schema, (obj, ev) =>
{
Console.WriteLine("{0}", ev.Message);
});
}
public static bool DeepEqualsWithNormalization(XDocument doc1, XDocument doc2,
XmlSchemaSet schemaSet)
{
XDocument d1 = Normalize(doc1, schemaSet);
XDocument d2 = Normalize(doc2, schemaSet);
return XNode.DeepEquals(d1, d2);
}
public bool validate()
{
try
{
XmlSchemaSet sc = new XmlSchemaSet();
// Add the schema to the collection.
sc.Add("urn:mites-schema", this.xsdFile);
// Set the validation settings.
XmlReaderSettings settings = new XmlReaderSettings();
settings.ValidationType = ValidationType.Schema;
settings.Schemas = sc;
settings.ValidationEventHandler += new ValidationEventHandler(ValidationCallBack);
// Create the XmlReader object.
XmlReader reader = XmlReader.Create(this.xmlFile, settings);
// Parse the file.
while (reader.Read())
{
;
}
return true;
}
catch (Exception e)
{
throw new Exception("Error in (SXML.ConfigurationReader,validate):" + e.ToString());
}
}
private static void LoadAndValidateInvoice(string xmlFilename, XmlSchemaSet invoiceSchemaSet)
{
UblLarsen.Ubl2.InvoiceType invoice = null;
using (FileStream fs = File.OpenRead(xmlFilename))
{
Console.WriteLine($"Processing {xmlFilename} ...");
// XDocument can contain any valid xml, don't know if it is an ubl invoice yet
XDocument xmlInvoice = XDocument.Load(fs);
if (!ValidateUblInvoiceDocument(xmlInvoice, invoiceSchemaSet))
{
Console.WriteLine("Invalid ubl invoice document, but I will try and read it anyway...");
}
// Reuse filestream and load into an InvoiceType instance by using XmlSerializer
fs.Position = 0;
XmlSerializer xs = new XmlSerializer(typeof(UblLarsen.Ubl2.InvoiceType));
try
{
invoice = (UblLarsen.Ubl2.InvoiceType)xs.Deserialize(fs);
}
catch (Exception ex)
{
Console.WriteLine("Deserialize: " + ex.Message);
}
}
if (invoice != null)
{
ShowInvoice(invoice);
}
}
public bool IsValid(Stream template)
{
if (template == null)
{
throw new ArgumentNullException("template");
}
// Load the template into an XDocument
XDocument xml = XDocument.Load(template);
// Load the XSD embedded resource
Stream stream = typeof(XMLPnPSchemaV201508Formatter)
.Assembly
.GetManifestResourceStream("OfficeDevPnP.Core.Framework.Provisioning.Providers.Xml.ProvisioningSchema-2015-08.xsd");
// Prepare the XML Schema Set
XmlSchemaSet schemas = new XmlSchemaSet();
schemas.Add(XMLConstants.PROVISIONING_SCHEMA_NAMESPACE_2015_08,
new XmlTextReader(stream));
Boolean result = true;
xml.Validate(schemas, (o, e) =>
{
Diagnostics.Log.Error(e.Exception, "SchemaFormatter", "Template is not valid: {0}", e.Message);
result = false;
});
return (result);
}
public static void Main()
{
XmlSchemaSet schemas = new XmlSchemaSet();
schemas.Add("urn:catalogue", "..//..//xml/catalogue.xsd");
XDocument XmlDocument = XDocument.Load("..//..//xml/catalogue.xml");
List<string> errorMessages = new List<string>();
XmlDocument.Validate(schemas, (obj, error) =>
{
errorMessages.Add(error.Message);
});
IPrinter printer = new ConsolePrinter();
if (errorMessages.Count == 0)
{
printer.Print("Valid catalogue.xml");
}
else
{
printer.Print(errorMessages);
}
}
public void ValidateSave()
{
WorldEntity world = createTestWorld();
XElement xElement = WorldTransformer.Instance.ToXElement(world, TransformerSettings.WorldNamespace + "World");
xElement.Save("unittestsave.xml", SaveOptions.OmitDuplicateNamespaces);
XmlSchemaSet schemaSet = new XmlSchemaSet();
schemaSet.Add(null, "WorldSchema1.xsd");
XDocument xDocument = new XDocument(xElement);
xDocument.AddAnnotation(SaveOptions.OmitDuplicateNamespaces);
xDocument.Save("unittest2.xml", SaveOptions.OmitDuplicateNamespaces);
XElement x1 = new XElement(TransformerSettings.WorldNamespace + "Outer");
x1.Add(new XElement(TransformerSettings.WorldNamespace + "Inner"));
x1.Save("unittest3.xml", SaveOptions.OmitDuplicateNamespaces);
string val = "";
xDocument.Validate(schemaSet, (o, vea) => {
val += o.GetType().Name + "\n";
val += vea.Message + "\n";
}, true);
Assert.AreEqual("", val);
}
public bool ValidateXml(string inputXML, string xsdUri)
{
stringBuilder = new StringBuilder();
bool validated = false;
// Create the XmlSchemaSet class.
XmlSchemaSet sc = new XmlSchemaSet();
// Add the schema to the collection.
sc.Add(null, xsdUri);
// Set the validation settings.
XmlReaderSettings settings = new XmlReaderSettings();
settings.ValidationType = ValidationType.Schema;
settings.Schemas = sc;
settings.ConformanceLevel = ConformanceLevel.Auto;
settings.ValidationEventHandler += new ValidationEventHandler(ValidationCallBack);
XmlTextReader reader = new XmlTextReader(new StringReader(inputXML));
while (reader.Read())
{ }
if (stringBuilder.ToString() == String.Empty)
validated = true;
return validated;
}
/// <summary>
/// Load an Schema From A File Location
/// </summary>
/// <param name="SchemaFileLocation">Schema File Location</param>
/// <param name="TargetNamespace">Default Namespace - Could be a blank string</param>
/// <returns>XmlSchemaSet Object</returns>
public static XmlSchemaSet LoadSchemaSetFromFileLocation(string SchemaFileLocation, string TargetNamespace)
{
//Make sure the file is there
if (!File.Exists(SchemaFileLocation))
{
throw new FileNotFoundException("Can't Find Schema File In: " + SchemaFileLocation);
}
//Make sure its a .xsd file
if (!string.Equals(new FileInfo(SchemaFileLocation).Extension, ".xsd", StringComparison.OrdinalIgnoreCase))
{
throw new InvalidDataException("Schema File Must Be Of Extension .xsd");
}
//*************Done with validation*************
//Schema To Load
var SchemaSet = new XmlSchemaSet();
//Add the file xsd file to the path
SchemaSet.Add(TargetNamespace, SchemaFileLocation);
//Compile The Schema
SchemaSet.Compile();
//Return the XMLSchemaSet
return SchemaSet;
}
private static XmlSchemaSet LoadXsdFile(string xsdPath)
{
XmlSchemaSet xsdSchema = new XmlSchemaSet();
xsdSchema.Add(string.Empty, xsdPath);
return xsdSchema;
}
private static void PrintValidationResult(XDocument doc, XmlSchemaSet schema, string file)
{
doc.Validate(schema, (obj, ev) =>
{
Console.WriteLine("* {0} * {1}",file, ev.Message);
});
}
public void UnitTestValidate()
{
XmlSchemaSet schemas = new XmlSchemaSet();
schemas.Add(Resource.GetXmlSchema("StealFocus.Core.Tests", "StealFocus.Core.Tests.Xml.Resources.Schema.xsd"));
XmlDocument xmlDocument = Resource.GetXmlDocument("StealFocus.Core.Tests", "StealFocus.Core.Tests.Xml.Resources.Document.xml");
XmlValidator.Validate(xmlDocument, schemas);
}
public void Add ()
{
XmlSchemaSet ss = new XmlSchemaSet ();
XmlDocument doc = new XmlDocument ();
doc.LoadXml ("<xs:schema xmlns:xs='http://www.w3.org/2001/XMLSchema' />");
ss.Add (null, new XmlNodeReader (doc)); // null targetNamespace
ss.Compile ();
// same document, different targetNamespace
ss.Add ("ab", new XmlNodeReader (doc));
// Add(null, xmlReader) -> targetNamespace in the schema
doc.LoadXml ("<xs:schema xmlns:xs='http://www.w3.org/2001/XMLSchema' targetNamespace='urn:foo' />");
ss.Add (null, new XmlNodeReader (doc));
Assert.AreEqual (3, ss.Count);
bool chameleon = false;
bool ab = false;
bool urnfoo = false;
foreach (XmlSchema schema in ss.Schemas ()) {
if (schema.TargetNamespace == null)
chameleon = true;
else if (schema.TargetNamespace == "ab")
ab = true;
else if (schema.TargetNamespace == "urn:foo")
urnfoo = true;
}
Assert.IsTrue (chameleon, "chameleon schema missing");
Assert.IsTrue (ab, "target-remapped schema missing");
Assert.IsTrue (urnfoo, "target specified in the schema ignored");
}
public SoapEditorProxy(Connections.ConnectionData connData, ServiceDescription description, XmlSchemaSet schemas)
{
_connData = connData;
_descrip = description;
_schemas = schemas;
_helper = new XmlCompletionDataProvider(schemas, "http://schemas.xmlsoap.org/soap/envelope/"
, "soapenv", () => "xmlns:soap=\"" + description.TargetNamespace + "\""
, e => (e.Name == "Envelope" && e.QualifiedName.Namespace == "http://schemas.xmlsoap.org/soap/envelope/")
|| TypeMatchesAction(e.QualifiedName, this.Action));
_baseUrl = new Uri(_connData.Url).GetLeftPart(UriPartial.Path);
switch (_connData.Authentication)
{
case Connections.Authentication.Windows:
_cred = CredentialCache.DefaultNetworkCredentials;
break;
case Connections.Authentication.Explicit:
_cred = new NetworkCredential(_connData.UserName, _connData.Password);
break;
}
_actionUrls = _descrip.Services.OfType<Service>()
.SelectMany(s => s.Ports.OfType<Port>().Where(SoapPort))
.SelectMany(p => _descrip.Bindings[p.Binding.Name].Operations.OfType<OperationBinding>())
.Select(o => new { Name = o.Name, Address = o.Extensions.OfType<SoapOperationBinding>().First().SoapAction })
.Distinct()
.ToDictionary(a => a.Name, a => a.Address);
}
public static void LoadEhrStatusSchema(System.Xml.Schema.XmlSchemaSet xs)
{
if (!xs.Contains(OpenEhrNamespace))
{
System.Xml.Schema.XmlSchema ehrStatusSchema = GetOpenEhrSchema("EhrStatus");
ehrStatusSchema.Includes.RemoveAt(0);
System.Xml.Schema.XmlSchema structureSchema = GetOpenEhrSchema("Structure");
foreach (System.Xml.Schema.XmlSchemaObject item in structureSchema.Items)
{
ehrStatusSchema.Items.Add(item);
}
System.Xml.Schema.XmlSchema baseTypesSchema = GetOpenEhrSchema("BaseTypes");
foreach (System.Xml.Schema.XmlSchemaObject item in baseTypesSchema.Items)
{
ehrStatusSchema.Items.Add(item);
}
xs.Add(ehrStatusSchema);
xs.Compile();
}
}
public static void LoadStructureSchema(System.Xml.Schema.XmlSchemaSet xs)
{
if (!xs.Contains(OpenEhrNamespace))
{
if (structureSchema == null)
{
lock (structureSchemaLock)
{
if (structureSchema == null)
{
System.Xml.Schema.XmlSchema tempSchema = GetOpenEhrSchema("Structure");
tempSchema.Includes.RemoveAt(0);
System.Xml.Schema.XmlSchema includeSchema = GetOpenEhrSchema("BaseTypes");
foreach (System.Xml.Schema.XmlSchemaObject item in includeSchema.Items)
{
tempSchema.Items.Add(item);
}
structureSchema = tempSchema;
}
}
}
xs.Add(structureSchema);
}
}
public static void LoadCompositionSchema(System.Xml.Schema.XmlSchemaSet xs)
{
if (!xs.Contains(OpenEhrNamespace))
{
System.Xml.Schema.XmlSchema compositionSchema = GetOpenEhrSchema("Composition");
System.Xml.Schema.XmlSchema contentSchema = GetOpenEhrSchema("Content");
compositionSchema.Includes.RemoveAt(0);
foreach (System.Xml.Schema.XmlSchemaObject item in contentSchema.Items)
{
compositionSchema.Items.Add(item);
}
System.Xml.Schema.XmlSchema structureSchema = GetOpenEhrSchema("Structure");
foreach (System.Xml.Schema.XmlSchemaObject item in structureSchema.Items)
{
compositionSchema.Items.Add(item);
}
System.Xml.Schema.XmlSchema baseTypesSchema = GetOpenEhrSchema("BaseTypes");
foreach (System.Xml.Schema.XmlSchemaObject item in baseTypesSchema.Items)
{
compositionSchema.Items.Add(item);
}
xs.Add(compositionSchema);
xs.Compile();
}
}
public SchemaValidator(string schemaNamespace, string schemaPath)
{
if (schemaNamespace == null)
{
throw new ArgumentNullException("schemaNamespace");
}
if (schemaNamespace.Length == 0)
{
throw new ArgumentException("schema namespace cannot be zero length!");
}
if (schemaPath == null)
{
throw new ArgumentNullException("schemaPath");
}
if (schemaPath.Length == 0)
{
throw new ArgumentException("schemaPath cannot be of zero length!");
}
if (!File.Exists(schemaPath))
{
throw new ArgumentException("Schema: " + schemaPath + " cannot be located!");
}
schemaSet = new XmlSchemaSet();
schemaSet.Add(schemaNamespace, schemaPath);
schemaSet.Compile();
}
public bool IsValid(string xml, System.Xml.Schema.XmlSchemaSet sc, bool reportWarnings = false)
{
_xml = xml;
// Create reader settings
System.Xml.XmlReaderSettings settings = new System.Xml.XmlReaderSettings();
// Attach event handler whic will be fired when validation error occurs
settings.ValidationEventHandler += XmlReader_ValidationCallBack;
// Set validation type to schema
settings.ValidationType = System.Xml.ValidationType.Schema;
if (reportWarnings)
{
settings.ValidationFlags |= System.Xml.Schema.XmlSchemaValidationFlags.ReportValidationWarnings;
}
//settings.ValidationFlags = settings.ValidationFlags Or System.Xml.Schema.XmlSchemaValidationFlags.ProcessInlineSchema
//settings.ValidationFlags = settings.ValidationFlags Or System.Xml.Schema.XmlSchemaValidationFlags.ProcessSchemaLocation
// Add to the collection of schemas in readerSettings
settings.Schemas = sc;
//settings.ProhibitDtd = False
// Create object of XmlReader using XmlReaderSettings
System.IO.StringReader xmlMs = new System.IO.StringReader(xml);
System.Xml.XmlReader reader = System.Xml.XmlReader.Create(xmlMs, settings);
Exceptions = new List <System.Xml.Schema.XmlSchemaException>();
// Parse the file.
while (reader.Read())
{
}
return(Exceptions.Count == 0);
}
public bool IsValid(string xml, System.Xml.Schema.XmlSchema xd, bool reportWarnings = false)
{
// Create the schema object
var sc = new System.Xml.Schema.XmlSchemaSet();
sc.Add(xd);
return(IsValid(xml, sc, reportWarnings));
}
public MmlWriter()
{
string schemapath = System.Environment.CurrentDirectory + "\\MML23\\xsd";
MmlSchemaSet = new System.Xml.Schema.XmlSchemaSet();
foreach (string xsdfile in System.IO.Directory.GetFiles(schemapath))
{
MmlSchemaSet.Add(null, xsdfile);
}
}
public static void LoadBaseTypesSchema(System.Xml.Schema.XmlSchemaSet xs)
{
if (!xs.Contains(OpenEhrNamespace))
{
if (baseTypesSchema == null)
{
lock (baseTypesSchemaLock)
{
if (baseTypesSchema == null)
{
baseTypesSchema = GetOpenEhrSchema("BaseTypes");
}
}
}
xs.Add(baseTypesSchema);
}
}
/// <summary>
/// Validates an XML document against Exchange.xsd schema
/// </summary>
/// <param name="doc2validate">XML document to be validated</param>
public static void AgainstScheme(XmlDocument doc2validate)
{
System.Xml.Schema.XmlSchemaSet schemas = new System.Xml.Schema.XmlSchemaSet();
schemas.Add(null, System.IO.Path.Combine(AppDomain.CurrentDomain.BaseDirectory, @"Scheme\Exchange.xsd"));
try
{
XDocument doc = XDocument.Parse(doc2validate.InnerXml);
doc.Validate(schemas, (o, e) =>
{
throw new Exception(e.Message);
});
}
catch (Exception ex)
{
throw new Exception("XML could not be validated! It is not well-formed or does not comply with XSD.", ex);
}
}
/// <summary>
/// Validate an Xml According to the passed schema
/// </summary>
/// <param name="xmlSchema">XsdSchema</param>
public virtual void Validate(string xmlSchema)
{
var xml = _currentXmlBag.GetRawXml();
if (string.IsNullOrEmpty(xml))
{
throw new InvalidOperationException("Non è possibile validare un xml vuoto");
}
if (string.IsNullOrEmpty(xmlSchema))
{
throw new ArgumentNullException(nameof(xmlSchema));
}
var schemas = new System.Xml.Schema.XmlSchemaSet();
schemas.Add(string.Empty, System.Xml.XmlReader.Create(new System.IO.StringReader(xmlSchema)));
var doc = XDocument.Parse(xml);
var validationErrors = new List <XsdValidationInfo>();
var errors = false;
doc.Validate(
schemas,
(o, e) =>
{
validationErrors.Add(new XsdValidationInfo(e.Message, e.Exception));
errors = true;
});
if (errors)
{
throw new XsdValidationException(validationErrors);
}
}
public static IEnumerable fnWebSendXMLDataKFHHomeSearch(
SqlString PostURL,
SqlString Method,
SqlString ContentType,
SqlXml XMLData,
SqlString P12CertPath,
SqlString P12CertPass,
SqlInt32 Timeout,
SqlString SchemaURI,
SqlString RootName,
SqlString SuccessNode,
SqlString SuccessValue,
SqlBoolean UniqueNodeValues,
SqlString XPathReturnValue
)
{
// creates a collection to store the row values ( might have to make this a scalar row rather then multi-rowed )
ArrayList resultCollection = new ArrayList();
// logs the time the row had begun processing
SqlDateTime _StartedTS = DateTime.Now;
// stores the URL of the request and stores any xml input as bytes
Uri URL = null;
byte[] postBytes = null;
// if the required fields post url and method are not provided then...
if (PostURL.IsNull || PostURL.Value == "" || Method.IsNull)
{
resultCollection.Add(new PostResult(null, null, false, true, "The [Post URL] was missing or the [Method] was missing.", STATUS_CODES.FAILED_VALIDATION, null));
return(resultCollection);
}
// if the methods are not correctly set to the only valid values then...
if (Method.Value != "POST" && Method.Value != "GET")
{
resultCollection.Add(new PostResult(null, null, false, true, "The [Method] provided was not either POST or GET.", STATUS_CODES.FAILED_VALIDATION, null));
return(resultCollection);
}
// check to see if the url is correctly formed otherwise...
if (Uri.TryCreate(PostURL.Value, UriKind.RelativeOrAbsolute, out URL) == false)
{
resultCollection.Add(new PostResult(null, null, false, true, "The [URL] provided was incorrectly formatted.", STATUS_CODES.FAILED_VALIDATION, null));
return(resultCollection);
}
// if xml schema has been specified but no xml has been passed then...
if (!SchemaURI.IsNull && XMLData.IsNull)
{
resultCollection.Add(new PostResult(null, null, false, true, "The [Schema URI] was provided but [XML Data] was not.", STATUS_CODES.FAILED_VALIDATION, null)); return(resultCollection);
}
// check to see if we can access the schema .xsd file otherwise...
if (!SchemaURI.IsNull && System.IO.File.Exists(SchemaURI.Value) == false)
{
resultCollection.Add(new PostResult(null, null, false, true, "The [Schema URI] was provided but could not be loaded because it could not be found.", STATUS_CODES.FAILED_VALIDATION, null));
return(resultCollection);
}
// if xml specific fields are available but no xml has been passed then...
if ((!RootName.IsNull || !SuccessNode.IsNull || !SuccessValue.IsNull) && XMLData.IsNull)
{
resultCollection.Add(new PostResult(null, null, false, true, "The [Root Name] or [Success Node] or [Success Value] was provided but the [XML Data] was missing.", STATUS_CODES.FAILED_VALIDATION, null));
return(resultCollection);
}
// if certificate pass is specified but no certificate file has then...
if (!P12CertPass.IsNull && P12CertPath.IsNull)
{
resultCollection.Add(new PostResult(null, null, false, true, "The [P12 Cert Pass] was provided but the [P12 Cert Path] is missing.", STATUS_CODES.FAILED_VALIDATION, null));
return(resultCollection);
}
// check to see if we can access the certificate file otherwise...
if (!P12CertPath.IsNull && System.IO.File.Exists(P12CertPath.Value) == false)
{
resultCollection.Add(new PostResult(null, null, false, true, "The [P12 Cert Path] was provided but could not be loaded because it could not be found.", STATUS_CODES.FAILED_VALIDATION, null));
return(resultCollection);
}
// check that the certificate provided can be opened before performing major code...
if (!P12CertPath.IsNull)
{
try
{
if (!P12CertPass.IsNull)
{
new X509Certificate2(P12CertPath.Value, P12CertPass.Value);
}
else
{
new X509Certificate2(P12CertPath.Value);
}
}
catch (Exception ex)
{
resultCollection.Add(new PostResult(null, null, false, true, String.Format("Certificate exception. {0}. {1}. {2}.", ex.Source, ex.Message, ex.StackTrace), STATUS_CODES.FAILED_VALIDATION, null));
return(resultCollection);
}
}
// check if any xml data has been passed to the clr
using (var stringWriter = new StringWriter())
{
if (!XMLData.IsNull)
{
// prepare xml variable
XmlDocument2 xDoc = new XmlDocument2();
try
{
// rename root node if applicable
if (!RootName.IsNull)
{
XmlDocument2 _xDoc = new XmlDocument2();
_xDoc.LoadXml(XMLData.Value);
XmlElement _xDocNewRoot = xDoc.CreateElement(RootName.Value);
xDoc.AppendChild(_xDocNewRoot);
_xDocNewRoot.InnerXml = _xDoc.DocumentElement.InnerXml;
}
else
{
// otherwise just load the xml exactly as provided
xDoc.LoadXml(XMLData.Value);
}
// add the xml declaration if it doesn't exist
if (xDoc.FirstChild.NodeType != XmlNodeType.XmlDeclaration)
{
XmlDeclaration xmlDec = xDoc.CreateXmlDeclaration("1.0", "UTF-8", null);
XmlElement root = xDoc.DocumentElement;
xDoc.InsertBefore(xmlDec, root);
}
// if the schema file has been specified then validate otherwise skip
if (!SchemaURI.IsNull)
{
System.Xml.Schema.XmlSchemaSet schemas = new System.Xml.Schema.XmlSchemaSet();
schemas.Add("", SchemaURI.Value);
xDoc.Schemas.Add(schemas);
if (!UniqueNodeValues.IsNull)
{
xDoc.UniqueNodeValues = UniqueNodeValues.Value;
}
xDoc.Validate(ValidationEventHandler);
}
// adds any validation errors to the output rows and stops processing if errors were found
if (xDoc.ValidationErrors.Count > 0)
{
resultCollection.AddRange(xDoc.ValidationErrors);
return(resultCollection);
}
// Save the xml as a string
using (var xmlTextWriter = XmlWriter.Create(stringWriter))
{
xDoc.WriteTo(xmlTextWriter);
xmlTextWriter.Flush();
}
// get the bytes for the xml document
//postBytes = Encoding.UTF8.GetBytes(xDoc.OuterXml);
UTF8Encoding encoding = new UTF8Encoding();
postBytes = encoding.GetBytes(xDoc.InnerXml);
//Revisions:
//json String Variable
// byte[] byteData = new System.Text.ASCIIEncoding().GetBytes(json);
}
catch (Exception ex)
{
string errorMsg = String.Format("XML Parse exception. {0}. {1}. {2}.", ex.Source, ex.Message, ex.StackTrace);
resultCollection.Add(new PostResult(stringWriter.GetStringBuilder().ToString(), null, false, true, errorMsg, STATUS_CODES.XML_ERROR, null, _StartedTS));
return(resultCollection);
}
}
if (Timeout.IsNull)
{
Timeout = 20;
}
if (ContentType.IsNull)
{
ContentType = "*/*";
}
// Set the SecurityProtocol
System.Net.ServicePointManager.SecurityProtocol = SecurityProtocolType.Tls12;
// create the web request object after validation succeeds
HttpWebRequest webRequest;
try
{
// create the http request
webRequest = (HttpWebRequest)HttpWebRequest.Create(URL);
// setup the connection settings
webRequest.Method = Method.Value;
webRequest.ContentType = ContentType.Value;
webRequest.Accept = ContentType.Value;
webRequest.Timeout = (Timeout.Value * 1000);
webRequest.SendChunked = true;
webRequest.KeepAlive = false;
}
catch (Exception ex)
{
string errorMsg = String.Format("WebRequest Create exception. {0}. {1}. {2}.", ex.Source, ex.Message, ex.StackTrace);
resultCollection.Add(new PostResult(stringWriter.GetStringBuilder().ToString(), null, false, true, errorMsg, STATUS_CODES.FAILURE, null, _StartedTS));
return(resultCollection);
}
try
{
// add the P12 certificate to the request if specified
if (!P12CertPath.IsNull)
{
// load with password if specified
if (!P12CertPass.IsNull)
{
webRequest.ClientCertificates.Add(new X509Certificate2(P12CertPath.Value, P12CertPass.Value));
}
else
{
webRequest.ClientCertificates.Add(new X509Certificate2(P12CertPath.Value));
}
}
}
catch (Exception ex)
{
string errorMsg = String.Format("Certificate exception. {0}. {1}. {2}.", ex.Source, ex.Message, ex.StackTrace);
resultCollection.Add(new PostResult(stringWriter.GetStringBuilder().ToString(), null, false, true, errorMsg, STATUS_CODES.CERTIFICATE_ERROR, null, _StartedTS));
return(resultCollection);
}
// post the request
if (Method.Value == "POST")
{
try
{
using (StreamWriter postStream = new StreamWriter(webRequest.GetRequestStream(), Encoding.UTF8))
{
try
{
// post the data as bytes to the request stream
if (postBytes != null)
{
postStream.Write(System.Text.Encoding.UTF8.GetString(postBytes));
postStream.Flush();
//postStream.BaseStream.Write(postBytes, 0, postBytes.Length);
}
}
catch (Exception ex)
{
string errorMsg = String.Format("StreamWriter exception. {0}. {1}. {2}.", ex.Source, ex.Message, ex.StackTrace);
resultCollection.Add(new PostResult(stringWriter.GetStringBuilder().ToString(), null, false, true, errorMsg, STATUS_CODES.GET_REQUEST_STREAM, null, _StartedTS, DateTime.Now));
return(resultCollection);
}
finally
{
postStream.Close();
}
}
}
catch (Exception ex)
{
string errorMsg = String.Format("Web request exception. {0}. {1}. {2}.", ex.Source, ex.Message, ex.StackTrace);
resultCollection.Add(new PostResult(stringWriter.GetStringBuilder().ToString(), null, false, true, errorMsg, STATUS_CODES.GET_REQUEST_STREAM, null, _StartedTS, DateTime.Now));
return(resultCollection);
}
}
string response = string.Empty;
HttpWebResponse objResponse = null;
// get the response (also used for GET)
try
{
objResponse = (HttpWebResponse)webRequest.GetResponse();
if (webRequest.HaveResponse == true)
{
using (StreamReader responseStream = new StreamReader(objResponse.GetResponseStream()))
{
try
{
// get the result of the post
response = responseStream.ReadToEnd();
// see if the response is in xml format or not
XmlDocument doc = null;
if (response.IndexOf("<", 0) <= 2)
{
doc = new XmlDocument();
try { doc.LoadXml(response); }
catch (Exception) { doc = null; }
}
// if the response is expected in xml format
if (doc != null)
{
// check for a success value and node if specified...
if (!SuccessNode.IsNull && !SuccessValue.IsNull)
{
try
{
// use the response xml and get the success node(s) specified in the xpath
XmlNodeList nodeSuccess = doc.SelectNodes(SuccessNode.Value);
using (XmlNodeReader xnr = new XmlNodeReader(doc))
{
if (nodeSuccess.Count == 0)
{
resultCollection.Add(new PostResult(stringWriter.GetStringBuilder().ToString(), new SqlXml(xnr), false, false, null, STATUS_CODES.XML_XPATH_RESULT_NODE_MISSING,
ReturnStringFromXPath(XPathReturnValue, ref doc), _StartedTS, DateTime.Now));
}
else
{
// loop through each node we need to validate and get the value
IEnumerator EN = nodeSuccess.GetEnumerator();
while (EN.MoveNext() == true)
{
if (((XmlNode)EN.Current).InnerText == SuccessValue.Value)
{
resultCollection.Add(new PostResult(stringWriter.GetStringBuilder().ToString(), new SqlXml(xnr), true, false, null, STATUS_CODES.SUCCESS,
ReturnStringFromXPath(XPathReturnValue, ref doc), _StartedTS, DateTime.Now));
}
else
{
resultCollection.Add(new PostResult(stringWriter.GetStringBuilder().ToString(), new SqlXml(xnr), false, true, null, STATUS_CODES.FAILURE,
ReturnStringFromXPath(XPathReturnValue, ref doc), _StartedTS, DateTime.Now));
}
}
}
}
}
catch (Exception ex)
{
string errorMsg = String.Format("XML reader exception. {0}. {1}. {2}.", ex.Source, ex.Message, ex.StackTrace);
resultCollection.Add(new PostResult(stringWriter.GetStringBuilder().ToString(), null, false, true, errorMsg, STATUS_CODES.FAILURE,
ReturnStringFromXPath(XPathReturnValue, ref doc), _StartedTS, DateTime.Now));
return(resultCollection);
}
}
else
{
// if we're not checking for a success node then just return the xml response
using (XmlNodeReader xnr = new XmlNodeReader(doc))
{
resultCollection.Add(new PostResult(stringWriter.GetStringBuilder().ToString(), new SqlXml(xnr), true, false, null, STATUS_CODES.SUCCESS,
ReturnStringFromXPath(XPathReturnValue, ref doc), _StartedTS, DateTime.Now));
}
}
}
else
{
// all other requests return in plain text in the additional info column
resultCollection.Add(new PostResult(stringWriter.GetStringBuilder().ToString(), null, true, false, response, STATUS_CODES.SUCCESS,
ReturnStringFromXPath(XPathReturnValue, ref doc), _StartedTS, DateTime.Now));
}
}
catch (Exception ex)
{
string errorMsg = String.Format("StreamWriter exception. {0}. {1}. {2}.", ex.Source, ex.Message, ex.StackTrace);
resultCollection.Add(new PostResult(stringWriter.GetStringBuilder().ToString(), null, false, true, errorMsg, STATUS_CODES.FAILURE, null, _StartedTS, DateTime.Now));
return(resultCollection);
}
finally
{
responseStream.Close();
}
}
}
}
catch (Exception ex)
{
string errorMsg = String.Format("Web response exception. {0}. {1}. {2}.", ex.Source, ex.Message, ex.StackTrace);
resultCollection.Add(new PostResult(stringWriter.GetStringBuilder().ToString(), null, false, true, errorMsg, STATUS_CODES.FAILURE, null, _StartedTS, DateTime.Now));
return(resultCollection);
}
finally
{
if (objResponse != null)
{
objResponse.Close();
}
}
}
return(resultCollection);
}
public override ArrayList ExpectedParticles(ValidationState context, bool isRequiredOnly, XmlSchemaSet schemaSet)
{
ArrayList particles = new ArrayList();
int[] numArray = this.transitionTable[context.CurrentState.State];
if (numArray != null)
{
for (int i = 0; i < (numArray.Length - 1); i++)
{
if (numArray[i] != -1)
{
XmlSchemaParticle p = (XmlSchemaParticle)this.symbols.GetParticle(i);
if (p != null)
{
ContentValidator.AddParticleToExpected(p, schemaSet, particles);
}
}
}
}
return(particles);
}
public override ArrayList ExpectedParticles(ValidationState context, bool isRequiredOnly, XmlSchemaSet schemaSet)
{
ArrayList particles = new ArrayList();
BitSet set = context.CurPos[context.CurrentState.CurPosIndex];
for (int i = set.NextSet(-1); i != -1; i = set.NextSet(i))
{
XmlSchemaParticle p = (XmlSchemaParticle)this.positions[i].particle;
if (p != null)
{
ContentValidator.AddParticleToExpected(p, schemaSet, particles);
}
}
return(particles);
}
public static System.Xml.XmlQualifiedName ProvideSchema(System.Xml.Schema.XmlSchemaSet xs)
{
return(new System.Xml.XmlQualifiedName("time", "http://www.w3.org/2001/XMLSchema"));
}
/// <summary>
/// Validate a <see cref="XAttribute"/>
/// </summary>
/// <param name="source">Extension point</param>
/// <param name="partialValidationType">An <see cref="XmlSchemaAttribute"/> or
/// <see cref="XmlSchemaType"/> object used to initialize the partial validation
/// context</param>
/// <param name="schemas">The <see cref="XmlSchemaSet"/> used for validation</param>
/// <param name="validationEventHandler">The <see cref="ValidationEventHandler"/> that
/// receives schema validation warnings and errors encountered during schema
/// validation</param>
public static void Validate(this XAttribute source, XmlSchemaObject partialValidationType, XmlSchemaSet schemas, ValidationEventHandler?validationEventHandler)
{
source.Validate(partialValidationType, schemas, validationEventHandler, false);
}
/// <summary>
/// Validate a <see cref="XAttribute"/>
/// </summary>
/// <param name="source">Extension point</param>
/// <param name="partialValidationType">An <see cref="XmlSchemaAttribute"/> or
/// <see cref="XmlSchemaType"/> object used to initialize the partial validation
/// context</param>
/// <param name="schemas">The <see cref="XmlSchemaSet"/> used for validation</param>
/// <param name="validationEventHandler">The <see cref="ValidationEventHandler"/> that
/// receives schema validation warnings and errors encountered during schema
/// validation</param>
/// <param name="addSchemaInfo">If enabled the <see cref="XAttribute"/> is augmented with PSVI
/// in the form of <see cref="IXmlSchemaInfo"/> annotations, default attributes and
/// default element values</param>
public static void Validate(this XAttribute source, XmlSchemaObject partialValidationType, XmlSchemaSet schemas, ValidationEventHandler?validationEventHandler, bool addSchemaInfo)
{
if (source == null)
{
throw new ArgumentNullException(nameof(source));
}
if (partialValidationType == null)
{
throw new ArgumentNullException(nameof(partialValidationType));
}
if (schemas == null)
{
throw new ArgumentNullException(nameof(schemas));
}
new XNodeValidator(schemas, validationEventHandler).Validate(source, partialValidationType, addSchemaInfo);
}
/// <summary>
/// produces a validator which validates XML AASX files.
/// </summary>
/// <returns>initialized validator</returns>
public static XmlValidator NewXmlValidator()
{
// Load the schema files
var files = GetSchemaResources(SerializationFormat.XML);
if (files == null)
{
throw new InvalidOperationException("No XML schema files could be found in the resources.");
}
var xmlSchemaSet = new System.Xml.Schema.XmlSchemaSet();
xmlSchemaSet.XmlResolver = new System.Xml.XmlUrlResolver();
try
{
Assembly myAssembly = Assembly.GetExecutingAssembly();
foreach (var schemaFn in files)
{
using (Stream schemaStream = myAssembly.GetManifestResourceStream(schemaFn))
{
using (XmlReader schemaReader = XmlReader.Create(schemaStream))
{
xmlSchemaSet.Add(null, schemaReader);
}
}
}
}
catch (Exception ex)
{
throw new FileNotFoundException(
$"Error accessing embedded resource schema files: {ex.Message}");
}
var newRecs = new AasValidationRecordList();
// set up messages
xmlSchemaSet.ValidationEventHandler += (object sender, System.Xml.Schema.ValidationEventArgs e) =>
{
newRecs.Add(
new AasValidationRecord(
AasValidationSeverity.Serialization, null,
$"{e?.Exception?.LineNumber}, {e?.Exception?.LinePosition}: {e?.Message}"));
};
// compile
try
{
xmlSchemaSet.Compile();
}
catch (Exception ex)
{
throw new InvalidOperationException(
$"Error compiling schema files: {ex.Message}");
}
if (newRecs.Count > 0)
{
var parts = new List <string> {
$"Failed to compile the schema files:"
};
parts.AddRange(newRecs.Select <AasValidationRecord, string>((r) => r.Message));
throw new InvalidOperationException(string.Join(Environment.NewLine, parts));
}
return(new XmlValidator(xmlSchemaSet));
}
/// <summary>
/// Validate a <see cref="XDocument"/>
/// </summary>
/// <param name="source">Extension point</param>
/// <param name="schemas">The <see cref="XmlSchemaSet"/> used for validation</param>
/// <param name="validationEventHandler">The <see cref="ValidationEventHandler"/>
/// that receives schema validation warnings and errors encountered during schema
/// validation</param>
public static void Validate(this XDocument source, XmlSchemaSet schemas, ValidationEventHandler?validationEventHandler)
{
source.Validate(schemas, validationEventHandler, false);
}
private static System.Xml.XmlQualifiedName GetSchema(System.Xml.Schema.XmlSchemaSet xs)
{
xs.ResolveQuerySchema();
return(new System.Xml.XmlQualifiedName("RecordDescriptor", Namespaces.Query));
}
internal XmlSchemaCollection(XmlSchemaSet schemaSet)
{
this.schemaSet = schemaSet;
}
public static void Validate(this XDocument document, XmlSchemaSet schemas, ValidationEventHandler handler, bool addSchemaInfo)
{
throw new NotImplementedException();
}
public static System.Xml.XmlQualifiedName ExportSchema(System.Xml.Schema.XmlSchemaSet schemas)
{
System.Runtime.Serialization.XmlSerializableServices.AddDefaultSchema(schemas, typeName);
return(typeName);
}
internal XmlValidator(XmlSchemaSet xmlSchemaSet)
{
this.xmlSchemaSet = xmlSchemaSet;
}
internal void CopyFromCompiledSet(XmlSchemaSet otherSet)
{
SortedList sortedSchemas = otherSet.SortedSchemas;
bool flag = this.schemas.Count == 0;
ArrayList list2 = new ArrayList();
SchemaInfo info = new SchemaInfo();
for (int i = 0; i < sortedSchemas.Count; i++)
{
XmlSchema byIndex = (XmlSchema)sortedSchemas.GetByIndex(i);
Uri baseUri = byIndex.BaseUri;
if (this.schemas.ContainsKey(byIndex.SchemaId) || (((baseUri != null) && (baseUri.OriginalString.Length != 0)) && (this.schemaLocations[baseUri] != null)))
{
list2.Add(byIndex);
}
else
{
this.schemas.Add(byIndex.SchemaId, byIndex);
if ((baseUri != null) && (baseUri.OriginalString.Length != 0))
{
this.schemaLocations.Add(baseUri, byIndex);
}
string targetNamespace = this.GetTargetNamespace(byIndex);
if (this.targetNamespaces[targetNamespace] == null)
{
this.targetNamespaces.Add(targetNamespace, targetNamespace);
}
}
}
this.VerifyTables();
foreach (XmlSchemaElement element in otherSet.GlobalElements.Values)
{
if (!this.AddToTable(this.elements, element.QualifiedName, element))
{
goto Label_026E;
}
}
foreach (XmlSchemaAttribute attribute in otherSet.GlobalAttributes.Values)
{
if (!this.AddToTable(this.attributes, attribute.QualifiedName, attribute))
{
goto Label_026E;
}
}
foreach (XmlSchemaType type in otherSet.GlobalTypes.Values)
{
if (!this.AddToTable(this.schemaTypes, type.QualifiedName, type))
{
goto Label_026E;
}
}
this.ProcessNewSubstitutionGroups(otherSet.SubstitutionGroups, false);
info.Add(this.cachedCompiledInfo, this.eventHandler);
info.Add(otherSet.CompiledInfo, this.eventHandler);
this.cachedCompiledInfo = info;
if (flag)
{
this.isCompiled = true;
this.compileAll = false;
}
return;
Label_026E:
foreach (XmlSchema schema2 in sortedSchemas.Values)
{
if (!list2.Contains(schema2))
{
this.Remove(schema2, false);
}
}
foreach (XmlSchemaElement element2 in otherSet.GlobalElements.Values)
{
if (!list2.Contains((XmlSchema)element2.Parent))
{
this.elements.Remove(element2.QualifiedName);
}
}
foreach (XmlSchemaAttribute attribute2 in otherSet.GlobalAttributes.Values)
{
if (!list2.Contains((XmlSchema)attribute2.Parent))
{
this.attributes.Remove(attribute2.QualifiedName);
}
}
foreach (XmlSchemaType type2 in otherSet.GlobalTypes.Values)
{
if (!list2.Contains((XmlSchema)type2.Parent))
{
this.schemaTypes.Remove(type2.QualifiedName);
}
}
}
/// <summary>
/// Validate a <see cref="XAttribute"/>
/// </summary>
/// <param name="source">Extension point</param>
/// <param name="partialValidationType">An <see cref="XmlSchemaAttribute"/> or
/// <see cref="XmlSchemaType"/> object used to initialize the partial validation
/// context</param>
/// <param name="schemas">The <see cref="XmlSchemaSet"/> used for validation</param>
/// <param name="validationEventHandler">The <see cref="ValidationEventHandler"/> that
/// receives schema validation warnings and errors encountered during schema
/// validation</param>
/// <param name="addSchemaInfo">If enabled the <see cref="XAttribute"/> is augmented with PSVI
/// in the form of <see cref="IXmlSchemaInfo"/> annotations, default attributes and
/// default element values</param>
public static void Validate(this XAttribute source, XmlSchemaObject partialValidationType, XmlSchemaSet schemas, ValidationEventHandler?validationEventHandler, bool addSchemaInfo)
{
ArgumentNullException.ThrowIfNull(source);
ArgumentNullException.ThrowIfNull(partialValidationType);
ArgumentNullException.ThrowIfNull(schemas);
new XNodeValidator(schemas, validationEventHandler).Validate(source, partialValidationType, addSchemaInfo);
}
public void Add(XmlSchemaSet schemas)
{
if (schemas == null)
{
throw new ArgumentNullException("schemas");
}
if (this != schemas)
{
bool lockTaken = false;
bool flag2 = false;
try
{
Label_0017:
Monitor.TryEnter(this.InternalSyncObject, ref lockTaken);
if (!lockTaken)
{
goto Label_0017;
}
Monitor.TryEnter(schemas.InternalSyncObject, ref flag2);
if (!flag2)
{
Monitor.Exit(this.InternalSyncObject);
lockTaken = false;
Thread.Yield();
goto Label_0017;
}
if (schemas.IsCompiled)
{
this.CopyFromCompiledSet(schemas);
}
else
{
bool flag3 = false;
string ns = null;
foreach (XmlSchema schema2 in schemas.SortedSchemas.Values)
{
ns = schema2.TargetNamespace;
if (ns == null)
{
ns = string.Empty;
}
if ((!this.schemas.ContainsKey(schema2.SchemaId) && (this.FindSchemaByNSAndUrl(schema2.BaseUri, ns, null) == null)) && (this.Add(schema2.TargetNamespace, schema2) == null))
{
flag3 = true;
break;
}
}
if (flag3)
{
foreach (XmlSchema schema3 in schemas.SortedSchemas.Values)
{
this.schemas.Remove(schema3.SchemaId);
this.schemaLocations.Remove(schema3.BaseUri);
}
}
}
}
finally
{
if (lockTaken)
{
Monitor.Exit(this.InternalSyncObject);
}
if (flag2)
{
Monitor.Exit(schemas.InternalSyncObject);
}
}
}
}
public static void Validate(this XAttribute attribute, XmlSchemaObject partialValidationType, XmlSchemaSet schemas, ValidationEventHandler handler)
{
throw new NotImplementedException();
}
public bool SendFilledDocument(int compilationRequestId, string username, string service, string token, string dataStr)
{
XmlDocument data = new XmlDocument();
data.LoadXml(dataStr);
Storage.StorageManager manager = new Storage.StorageManager();
Storage.CompilationRequest compilationRequest = manager.getEntityByID <Storage.CompilationRequest>(compilationRequestId);
if (compilationRequest == null)
{
return(false);
}
Storage.Publication publication = compilationRequest.Publication;
IComputableWorkflow cw;
if (publication.isPublic)
{
//pubblico
cw = (IComputableWorkflow)manager.getWorkflowByPublication(publication);
}
else
{
//privato
if (token == null || !compilationRequest.token.Equals(token))
{
return(false);
}
Storage.Contact contact = compilationRequest.Contact;
if (username == null || service == null ||
!(contact.externalUserID.Equals(username) && (contact.Service.nameService.Equals(service))))
{
return(false);
}
if (compilationRequest.compiled)
{
return(false);
}
cw = (IComputableWorkflow)manager.getWorkflowByPublication(publication);
}
cw.setWFname(publication.namePublication);
System.Xml.Schema.XmlSchemaSet schema = cw.GetCollectedDocumentSchemas();
data.Schemas = schema;
try
{
data.Validate(null);
}
catch (XmlSchemaValidationException)
{
return(false);
}
Storage.Result res = null;
System.Xml.Linq.XElement dataXElement = Storage.StorageManager.xmlDocumentToXElement(data);
res = (Storage.Result)manager.addResult(compilationRequest.compilReqID, dataXElement);
if (res == null)
{
return(false);
}
else
{
return(true);
}
}
public static void Validate(this XAttribute source, XmlSchemaObject partialValidationType, XmlSchemaSet schemas, ValidationEventHandler validationEventHandler, bool addSchemaInfo)
{
if (source == null)
{
throw new ArgumentNullException("source");
}
if (schemas == null)
{
throw new ArgumentNullException("schemas");
}
var nsmgr = new XmlNamespaceManager(new NameTable());
var v = new XmlSchemaValidator(nsmgr.NameTable, schemas, nsmgr, XmlSchemaValidationFlags.None);
if (validationEventHandler != null)
{
v.ValidationEventHandler += validationEventHandler;
}
if (partialValidationType != null)
{
v.Initialize(partialValidationType);
}
else
{
v.Initialize();
}
var xi = addSchemaInfo ? new XmlSchemaInfo() : null;
v.ValidateAttribute(source.Name.LocalName, source.Name.NamespaceName, source.Value, xi);
}
public static void Validate(this XElement element, XmlSchemaObject partialValidationType, XmlSchemaSet schemas, ValidationEventHandler handler, bool addSchemaInfo)
{
throw new NotImplementedException();
}