public bool Validate( out string error ) { bool isValid = true; StringBuilder sb = new StringBuilder(); foreach (NamedValue factoryDefault in _factoryDefaults) { SchemaValidationResult svr = new SchemaValidationResult(); isValid &= factoryDefault.Validate( svr ); if (svr.HasErrors()) sb.Append( svr.ErrorMessage ).Append( ", " ); } if( sb.ToString().EndsWith( ", " ) ) sb.Length = sb.Length - 2; error = sb.ToString(); return isValid; }
public bool Validate(out string error) { error = null; bool isValid = true; var sb = new StringBuilder(); if (_legalDocuments.Items != null) { foreach (var document in _legalDocuments.Items) { var svr = new SchemaValidationResult(); isValid &= document.Validate(svr); if (svr.HasErrors()) sb.Append( svr.ErrorMessage ).Append( ", " ); } if (sb.ToString().EndsWith( ", " )) sb.Length = sb.Length - 2; error = sb.ToString(); } return isValid; }
public bool Validate(SchemaValidationResult errors) { object testSubject = this; return SchemaManager.Validate("urn:IEEE-1671:2010:Common", "IdentificationNumber", testSubject, errors); }
public bool Validate(SchemaValidationResult errors) { object testSubject = this; return SchemaManager.Validate("urn:IEEE-1671:2010:Common", "DatumType", testSubject, errors); }
public bool Validate(SchemaValidationResult errors) { object testSubject = this; return SchemaManager.Validate("urn:IEEE-1671:2010:Common", "hexadecimalArray", testSubject, errors); }
public bool Validate( SchemaValidationResult errors ) { object testSubject = this; return SchemaManager.Validate( ATMLCommon.HardwareCommonNameSpace, GetType().Name, testSubject, errors ); }
public static bool Validate( string nameSpace, string elementName, object testSubject, SchemaValidationResult schemaValidationResult) { bool isValid = true; XmlSchemaComplexType complexType; XmlSchemaElement element; if (GetComplexType( nameSpace, elementName, out complexType )) { isValid &= ValidateComplexType( complexType, testSubject, schemaValidationResult ); } else { if (Instance._schemaTypes.ContainsKey( nameSpace + ":" + elementName )) { int i = 0; } if (GetElement( nameSpace, elementName, out element )) { isValid &= ValidateElement( element, testSubject, schemaValidationResult ); } } return !schemaValidationResult.HasErrors(); }
public bool Validate(SchemaValidationResult errors) { object testSubject = this; return SchemaManager.Validate("urn:IEEE-1671:2010:HardwareCommon", "Switching", testSubject, errors); }
public new bool Validate( SchemaValidationResult errors ) { object testSubject = this; return SchemaManager.Validate( TestStationNameSpace, "TestStationDescription", testSubject, errors ); }
private static bool ProcessRestrictions( string value, SchemaValidationResult errors, XmlSchemaSimpleTypeRestriction restriction, string typeName, string name) { bool isValid = true; if (restriction == null) return false; foreach (object facet in restriction.Facets) { if (facet is XmlSchemaMinInclusiveFacet) { var lf = facet as XmlSchemaMinInclusiveFacet; if (!string.IsNullOrEmpty( value )) { int iResult; double dResult; if (( typeName.Contains( "int" ) && int.TryParse( value, out iResult ) && iResult < int.Parse( lf.Value ) ) || ( typeName.Contains( "dou" ) && double.TryParse( value, out dResult ) && dResult < double.Parse( lf.Value ) )) { errors.AddError( String.Format( "The value of {0} must not be less than {1}", name, lf.Value ) ); isValid = false; } } } else if (facet is XmlSchemaMinExclusiveFacet) { var lf = facet as XmlSchemaMinExclusiveFacet; if (!string.IsNullOrEmpty( value )) { int iResult; double dResult; if (( typeName.Contains( "int" ) && int.TryParse( value, out iResult ) && iResult <= int.Parse( lf.Value ) ) || ( typeName.Contains( "dou" ) && double.TryParse( value, out dResult ) && dResult <= double.Parse( lf.Value ) )) { errors.AddError( String.Format( "The value of {0} must not be less than or equal to {1}", name, lf.Value ) ); isValid = false; } } } else if (facet is XmlSchemaMaxInclusiveFacet) { var lf = facet as XmlSchemaMaxInclusiveFacet; if (!string.IsNullOrEmpty( value )) { int iResult; double dResult; if (( typeName.Contains( "int" ) && int.TryParse( value, out iResult ) && iResult > int.Parse( lf.Value ) ) || ( typeName.Contains( "dou" ) && double.TryParse( value, out dResult ) && dResult > double.Parse( lf.Value ) )) { errors.AddError( String.Format( "The value of {0} must not be greater than {1}", name, lf.Value ) ); isValid = false; } } } else if (facet is XmlSchemaMaxExclusiveFacet) { var lf = facet as XmlSchemaMaxExclusiveFacet; if (!string.IsNullOrEmpty( value )) { int iResult; double dResult; if (( typeName.Contains( "int" ) && int.TryParse( value, out iResult ) && iResult >= int.Parse( lf.Value ) ) || ( typeName.Contains( "dou" ) && double.TryParse( value, out dResult ) && dResult >= double.Parse( lf.Value ) )) { errors.AddError( String.Format( "The value of {0} must not be greater than or equal to {1}", name, lf.Value ) ); isValid = false; } } } else if (facet is XmlSchemaLengthFacet) { var lf = facet as XmlSchemaLengthFacet; if (!String.IsNullOrEmpty( value ) && value.Length > int.Parse( lf.Value )) { errors.AddError( String.Format( "The value's length must not excede {0} characters", lf.Value ) ); isValid = false; } } else if (facet is XmlSchemaMinLengthFacet) { var lf = facet as XmlSchemaMinLengthFacet; if (!String.IsNullOrEmpty( value ) && value.Length < int.Parse( lf.Value )) { errors.AddError( String.Format( "The value's length must not be less than {0} characters", lf.Value ) ); isValid = false; } } else if (facet is XmlSchemaMaxLengthFacet) { var lf = facet as XmlSchemaMaxLengthFacet; if (!String.IsNullOrEmpty( value ) && value.Length > int.Parse( lf.Value )) { errors.AddError( String.Format( "The value's length must not be greater than {0} characters", lf.Value ) ); isValid = false; } } else if (facet is XmlSchemaPatternFacet) { var spf = facet as XmlSchemaPatternFacet; Console.WriteLine( spf.Id + @" : " + spf.Value ); if (value != null && !Regex.Match( value, spf.Value ).Success) { errors.AddError( String.Format( "The \"{0}\" value must match the regular expression: {1}", name, spf.Value ) ); isValid = false; } } else if (facet is XmlSchemaEnumerationFacet) { //TODO:XmlSchemaEnumerationFacet int i = 0; } else if (facet is XmlSchemaTotalDigitsFacet) { //TODO:XmlSchemaTotalDigitsFacet int i = 0; } else if (facet is XmlSchemaWhiteSpaceFacet) { //TODO:XmlSchemaWhiteSpaceFacet int i = 0; } } return isValid; }
private void HardwareItemDescriptionControl_Validating( object sender, CancelEventArgs e ) { tabInterface.BackColor = Color.White; operationalRequirementsControl.HasErrors = false; interfaceListControl.HasErrors = false; legalDocumentListControl.HasErrors = false; errorProvider.SetError( interfaceListControl, "" ); errorProvider.SetError( operationalRequirementsControl, "" ); errorProvider.SetError( legalDocumentListControl, "" ); foreach (TabPage tabPage in tabPanelControl.TabPages) tabPage.ToolTipText = ""; //-------------------------------------------------------------------------------------------------------// //--- TODO: Would like to generically walk all the tab controls to validate and set the tooltip text. ---// //-------------------------------------------------------------------------------------------------------// string defError; if (factoryDefaultsListControl.FactoryDefaults != null && !factoryDefaultsListControl.Validate( out defError )) { errorProvider.SetError(factoryDefaultsListControl, defError ); tabDefaults.ToolTipText = defError; OnError(sender, errorProvider.GetError(this)); } if (identificationControl.Identification == null || string.IsNullOrEmpty( identificationControl.Identification.ModelName )) { errorProvider.SetError(identificationControl, Resources.errmsg_An_Identification_Model_Name_is_required_); tabIdentification.ToolTipText = Resources.errmsg_An_Identification_Model_Name_is_required_; e.Cancel = true; OnError(sender, errorProvider.GetError(this)); } if (operationalRequirementsControl.OperationalRequirements != null) { var errors = new SchemaValidationResult(); if (!operationalRequirementsControl.OperationalRequirements.Validate( errors )) { errorProvider.SetError( operationalRequirementsControl, errors.ErrorMessage ); tabRequirements.ToolTipText = errors.ErrorMessage; tabOperational.ToolTipText = errors.ErrorMessage; operationalRequirementsControl.HasErrors = true; OnError( sender, errors.ErrorMessage ); } } if (interfaceListControl.PhysicalInterface != null && ( interfaceListControl.PhysicalInterface.Items == null || (interfaceListControl.PhysicalInterface.Items != null && interfaceListControl.PhysicalInterface.Items.Count == 0 )) ) { errorProvider.SetError( interfaceListControl, Resources.errmsg_at_least_one_interface_item ); tabInterface.ToolTipText = Resources.errmsg_at_least_one_interface_item; interfaceListControl.HasErrors = true; OnError( sender, errorProvider.GetError( this ) ); } if (legalDocumentListControl.LegalDocuments != null) { string error; if (!legalDocumentListControl.Validate( out error )) { tabLegal.ToolTipText = error; legalDocumentListControl.HasErrors = true; errorProvider.SetError(legalDocumentListControl, error ); OnError(sender, errorProvider.GetError(this)); } } }
public static void ValidateToSchema( object item ) { MethodInfo miValidate = item.GetType().GetMethod( "Validate" ); if (miValidate == null) throw new Exception( string.Format( "{0} does not support the Validate Method", item.GetType().Name ) ); var errors = new SchemaValidationResult(); object[] p = {errors}; miValidate.Invoke( item, p ); if (errors.HasErrors()) { throw new Exception( string.Format( "This {0} has failed validation against the ATML Schema with the following errors:\n{1}", item.GetType().Name, errors.ErrorMessage ) ); } MessageBox.Show( string.Format( "This {0} has passed all validation against the ATML Schema.", item.GetType().Name ), @"V a l i d a t i o n", MessageBoxButtons.OK, MessageBoxIcon.Information ); }
private static bool ProcessPropertyInfo( object testSubject, SchemaValidationResult validationResults, PropertyInfo propertyInfo, Dictionary<string, XmlSchemaObject> xmlSchemaObjects, bool isValid) { string name = propertyInfo.Name; object oValue = propertyInfo.GetValue( testSubject, null ); bool ok2Run = false; if (oValue != null) { MethodInfo mmi = oValue.GetType().GetMethod( "Validate" ); var collection = oValue as ICollection; if (collection != null) { //Need to get the type of each item schema foreach (object obj in collection) { MethodInfo mi = obj.GetType().GetMethod( "Validate" ); if (mi != null) { var result = new SchemaValidationResult( name ); object[] p = {result}; try { mi.Invoke( obj, p ); object po = p[0]; validationResults.AddResult( result ); } catch (Exception) { int i = 0; } } } ok2Run = true; } else if (mmi != null) { var result = new SchemaValidationResult( name ); object[] p = {result}; mmi.Invoke( oValue, p ); validationResults.AddResult( result ); isValid = !result.HasErrors(); } else { ok2Run = true; } } else { ok2Run = true; } if (xmlSchemaObjects.ContainsKey( name ) && ok2Run) { string value = oValue != null ? oValue.ToString() : null; XmlSchemaObject schemaObject = xmlSchemaObjects[name]; var attribute = schemaObject as XmlSchemaAttribute; var element = schemaObject as XmlSchemaElement; if (attribute != null) isValid &= ValidateAttribute( attribute, value, validationResults ); if (element != null) { string ename = element.Name; string enamespace = element.QualifiedName.Namespace; bool isNillable = element.IsNillable; isValid &= ValidateElement( element, oValue, validationResults ); var sct = element.ElementSchemaType as XmlSchemaComplexType; if (sct != null) { //Validate(sct, o, errors); int i = 0; } //Validate(enamespace, ename, o, errors); } } else { int i = 0; } return isValid; }
public static bool ValidateElement( XmlSchemaElement element, object value, SchemaValidationResult errors ) { bool isValid = true; XmlSchemaType schemaType = element.ElementSchemaType; bool isNillable = element.IsNillable; string defaultValue = element.DefaultValue; decimal minOccurrs = element.MinOccurs; decimal maxOccurrs = element.MaxOccurs; //SchemaValidationResult errors = new SchemaValidationResult(element.Name ); var complexType = schemaType as XmlSchemaComplexType; var simpleType = schemaType as XmlSchemaSimpleType; if (minOccurrs > 0 && value == null && !isNillable) { isValid = false; errors.AddError( string.Format( "{0} cannot be null", element.Name ) ); } else if (complexType != null) { var collection = value as ICollection; if (collection != null) { XmlSchemaParticle contentTypeParticle = complexType.ContentTypeParticle; XmlSchemaParticle particle = complexType.Particle; XmlSchemaContentModel model = complexType.ContentModel; var sequence = particle as XmlSchemaSequence; if (sequence != null) { ProcessSequence( errors, sequence, collection, minOccurrs ); } } } else if (simpleType != null) { var union = simpleType.Content as XmlSchemaSimpleTypeUnion; var list = simpleType.Content as XmlSchemaSimpleTypeList; var restriction = simpleType.Content as XmlSchemaSimpleTypeRestriction; if (restriction != null) { XmlQualifiedName qname = simpleType.BaseXmlSchemaType.QualifiedName; String typeName = qname.Name; isValid &= ProcessRestrictions( value == null ? null : value.ToString(), errors, restriction, typeName, simpleType.Name ); } foreach (XmlSchemaObject contraint in element.Constraints) { var key = contraint as XmlSchemaKey; var keyRef = contraint as XmlSchemaKeyref; var unique = contraint as XmlSchemaUnique; if (key != null) { } if (keyRef != null) { } if (unique != null) { } } } XmlTypeCode tc = schemaType.TypeCode; //validationResult.AddResult( errors ); return isValid; }
public static bool ValidateComplexType( XmlSchemaComplexType complexType, object testSubject, SchemaValidationResult parentValidationResult) { bool isValid = true; var result = new SchemaValidationResult( testSubject.GetType().Name, testSubject ); var xmlSchemaObjects = new Dictionary<string, XmlSchemaObject>(); XmlSchemaContentModel contentModel = complexType.ContentModel; ExtractSequenceItems( complexType, xmlSchemaObjects ); parentValidationResult.AddResult( result ); if (contentModel != null) ExtractContentItems( contentModel, xmlSchemaObjects ); ExtractAttributes( complexType, xmlSchemaObjects ); PropertyInfo[] props = testSubject.GetType().GetProperties(); foreach (PropertyInfo propertyInfo in props) { try { isValid &= ProcessPropertyInfo( testSubject, result, propertyInfo, xmlSchemaObjects, isValid ); } catch (Exception e) { int i = 0; } } return result.HasErrors(); }
public static bool ValidateAttribute( XmlSchemaAttribute attribute, string value, SchemaValidationResult errors ) { bool isValid = true; XmlSchemaSimpleType attributeSchemaType = attribute.AttributeSchemaType; XmlSchemaUse use = attribute.Use; string name = attribute.Name; bool required = ( use == XmlSchemaUse.Required ); if (required && string.IsNullOrEmpty( value )) { isValid = false; errors.AddError( string.Format( "{0} is required\n", name ) ); } if (attributeSchemaType.Content is XmlSchemaSimpleTypeRestriction) { XmlQualifiedName qname = attributeSchemaType.BaseXmlSchemaType.QualifiedName; String typeName = qname.Name; var restriction = (XmlSchemaSimpleTypeRestriction) attributeSchemaType.Content; isValid &= ProcessRestrictions( value, errors, restriction, typeName, name ); } return isValid; }
public bool Validate( SchemaValidationResult errors ) { object testSubject = this; return SchemaManager.Validate( TestEquipmentNameSpace, "OperatingSystem", testSubject, errors ); }
public bool Validate( SchemaValidationResult errors ) { object testSubject = this; return SchemaManager.Validate( "urn:IEEE-1671.4:2009.03:TestConfiguration", "TestConfiguration", testSubject, errors ); }
public bool Validate(SchemaValidationResult errors) { object testSubject = this; return SchemaManager.Validate("urn:IEEE-1671:2010:HardwareCommon", "FacilitiesRequirements", testSubject, errors); }
public bool Validate(SchemaValidationResult errors) { object testSubject = this; return SchemaManager.Validate("urn:IEEE-1671.2:2012:InstrumentDescription", "Bus", testSubject, errors); }
public new bool Validate( SchemaValidationResult errors ) { object testSubject = this; return SchemaManager.Validate( ATMLCommon.TestEquipmentNameSpace, "TerminalBlock", testSubject, errors ); }
private static void ProcessSequence( SchemaValidationResult errors, XmlSchemaSequence sequence, ICollection collection, decimal minOccurrs) { foreach (XmlSchemaObject item in sequence.Items) { var se = item as XmlSchemaElement; var gr = item as XmlSchemaGroupRef; var sc = item as XmlSchemaChoice; var ss = item as XmlSchemaSequence; var sa = item as XmlSchemaAny; if (se != null) { decimal max = se.MaxOccurs; decimal min = se.MinOccurs; string maxString = se.MaxOccursString; string minString = se.MinOccursString; if (collection.Count > max) errors.AddError( string.Format( "{0} count may not be more than {1}", se.Name, string.IsNullOrEmpty( maxString ) ? "" + max : maxString ) ); if (collection.Count < min && minOccurrs > 0) errors.AddError( string.Format( "{0} count may not be less than {1}", se.Name, ( string.IsNullOrEmpty( minString ) ? "" + min : minString ) ) ); } else if (sc != null) { foreach (XmlSchemaObject scItem in sc.Items) { var scse = scItem as XmlSchemaElement; var scgr = scItem as XmlSchemaGroupRef; var scsc = scItem as XmlSchemaChoice; var scss = scItem as XmlSchemaSequence; var scsa = scItem as XmlSchemaAny; } } else if (ss != null) { //ProcessSequence(errors, ss, ICollection collection, } } }
public bool Validate( SchemaValidationResult errors ) { object testSubject = this; return SchemaManager.Validate( ATMLCommon.HardwareCommonNameSpace, "TriggerPropertyGroup", testSubject, errors ); }
public new bool Validate(SchemaValidationResult schemaValidationResult) { object testSubject = this; bool isValid = SchemaManager.Validate("urn:IEEE-1671:2010:Common", "Connector", testSubject, schemaValidationResult); return isValid; }
void TestEquipmentControl_Validating(object sender, CancelEventArgs e) { TestEquipment testEquipment = TestEquipment; if (testEquipment != null) { if (testEquipment.FacilitiesRequirements != null) { var svr = new SchemaValidationResult(); if (!testEquipment.FacilitiesRequirements.Validate( svr )) tabFacilities.ToolTipText = svr.ErrorMessage; } if (testEquipment.Controllers != null) { foreach (Controller controller in testEquipment.Controllers) { var svr = new SchemaValidationResult(); if (!controller.Validate(svr)) tabControllers.ToolTipText = svr.ErrorMessage; } } if (testEquipment.Software != null) { foreach (ItemDescription itemDescription in testEquipment.Software) { var svr = new SchemaValidationResult(); if (!itemDescription.Validate(svr)) tabSoftware.ToolTipText = svr.ErrorMessage; } } if (testEquipment.Paths != null) { foreach (Path item in testEquipment.Paths) { var svr = new SchemaValidationResult(); if (!item.Validate(svr)) tabPaths.ToolTipText = svr.ErrorMessage; } } if (testEquipment.Specifications != null) { var svr = new SchemaValidationResult(); if (!testEquipment.Specifications.Validate(svr)) tabSpecifications.ToolTipText = svr.ErrorMessage; } if (testEquipment.Switching != null) { var svr = new SchemaValidationResult(); if (!testEquipment.Switching.Validate(svr)) tabSwitching.ToolTipText = svr.ErrorMessage; } if (testEquipment.Resources != null) { foreach (Resource item in testEquipment.Resources) { var svr = new SchemaValidationResult(); if (!item.Validate(svr)) tabResources.ToolTipText = svr.ErrorMessage; } } if (testEquipment.Capabilities != null) { var svr = new SchemaValidationResult(); if (!testEquipment.Capabilities.Validate(svr)) tabCapabilities.ToolTipText = svr.ErrorMessage; } if (testEquipment.TerminalBlocks != null) { var svr = new SchemaValidationResult(); if (!testEquipment.TerminalBlocks.Validate(svr)) tabTerminalBlocks.ToolTipText = svr.ErrorMessage; } } }
public void AddResult( SchemaValidationResult result ) { _results.Add( result ); }