/// <summary>
/// Verify Entry.Core.4624
/// </summary>
/// <param name="context">Service context</param>
/// <param name="info">out parameter to return violation information when rule fail</param>
/// <returns>true if rule passes; false otherwise</returns>
public override bool?Verify(ServiceContext context, out ExtensionRuleViolationInfo info)
{
if (context == null)
{
throw new ArgumentNullException("context");
}
bool?passed = null;
info = null;
// Get all properties.
XmlDocument xmlDoc = new XmlDocument();
xmlDoc.LoadXml(context.ResponsePayload);
XmlNamespaceManager nsmgr = new XmlNamespaceManager(xmlDoc.NameTable);
nsmgr.AddNamespace("m", Constants.V3NSMetadata);
string MeataNS = Constants.V3NSMetadata;
string DataNs = Constants.V3NSData;
if (context.Version == ODataVersion.V4)
{
nsmgr.AddNamespace("m", Constants.NSMetadata);
MeataNS = Constants.NSMetadata;
DataNs = Constants.V4NSData;
}
XmlNodeList xmlNodeList = xmlDoc.SelectNodes(@"//m:properties/*", nsmgr);
List <string> namesWithCollectionType = AtomSchemaHelper.GetAllComplexNameWithCollectionType(context.MetadataDocument, context.EntityTypeShortName);
foreach (XmlNode xmlNode in xmlNodeList)
{
if (namesWithCollectionType.Contains(xmlNode.LocalName) && xmlNode.NamespaceURI.Equals(DataNs) && xmlNode.Attributes["type", MeataNS] != null)
{
string metadataTypeValue = xmlNode.Attributes["type", MeataNS].Value;
if (AtomSchemaHelper.IsNamespaceOrAliasInCollection(metadataTypeValue) || AtomSchemaHelper.IsNamespaceOrAliasInCollection(metadataTypeValue))
{
passed = true;
}
else
{
passed = false;
info = new ExtensionRuleViolationInfo(this.ErrorMessage, context.Destination, context.ResponsePayload);
break;
}
}
}
return(passed);
}
/// <summary>
/// Verify Entry.Core.4717
/// </summary>
/// <param name="context">Service context</param>
/// <param name="info">out parameter to return violation information when rule fail</param>
/// <returns>true if rule passes; false otherwise</returns>
public override bool?Verify(ServiceContext context, out ExtensionRuleViolationInfo info)
{
if (context == null)
{
throw new ArgumentNullException("context");
}
bool?passed = null;
info = null;
List <string> xmlNodeTypes = new List <string>();
XmlDocument xmlDoc = new XmlDocument();
xmlDoc.LoadXml(context.ResponsePayload);
XmlNamespaceManager nsmgr = new XmlNamespaceManager(xmlDoc.NameTable);
nsmgr.AddNamespace("m", Constants.NSMetadata);
XmlNodeList xmlNodeList = xmlDoc.SelectNodes(@"//m:properties/*", nsmgr);
foreach (XmlNode xmlNode in xmlNodeList)
{
if (xmlNode.NamespaceURI.Equals(Constants.V4NSData) && xmlNode.Attributes["type", Constants.NSMetadata] != null)
{
string xmlNodeName = xmlNode.LocalName;
if (!AtomSchemaHelper.IsBuiltInPrimitiveTypes(xmlNodeName, context, out xmlNodeTypes))
{
string metadataTypeValue = xmlNode.Attributes["type", Constants.NSMetadata].Value;
if (metadataTypeValue.StartsWith("#"))
{
passed = true;
}
else
{
passed = false;
info = new ExtensionRuleViolationInfo(this.ErrorMessage, context.Destination, context.ResponsePayload);
break;
}
}
}
}
return(passed);
}
/// <summary>
/// Verify Entry.Core.4620
/// </summary>
/// <param name="context">Service context</param>
/// <param name="info">out parameter to return violation information when rule fail</param>
/// <returns>true if rule passes; false otherwise</returns>
public override bool?Verify(ServiceContext context, out ExtensionRuleViolationInfo info)
{
if (context == null)
{
throw new ArgumentNullException("context");
}
bool?passed = null;
info = null;
List <string> xmlNodeTypes = new List <string>();
// Whether odata.type value is namespace- or alias-qualified the instance's type
bool isNamespaceValue = false;
bool isAliasValue = false;
// Use the XPath query language to access the metadata document and get all Namespace and Alias value.
string xpath = @"//*[local-name()='DataServices']/*[local-name()='Schema']";
List <string> appropriateNamespace = MetadataHelper.GetPropertyValues(context, xpath, "Namespace");
List <string> appropriateAlias = MetadataHelper.GetPropertyValues(context, xpath, "Alias");
XmlDocument xmlDoc = new XmlDocument();
xmlDoc.LoadXml(context.ResponsePayload);
XmlNamespaceManager nsmgr = new XmlNamespaceManager(xmlDoc.NameTable);
nsmgr.AddNamespace("m", Constants.V3NSMetadata);
string MeataNS = Constants.V3NSMetadata;
string DataNs = Constants.V3NSData;
if (context.Version == ODataVersion.V4)
{
nsmgr.AddNamespace("m", Constants.NSMetadata);
MeataNS = Constants.NSMetadata;
DataNs = Constants.V4NSData;
}
XmlNodeList xmlNodeList = xmlDoc.SelectNodes(@"//m:properties/*", nsmgr);
foreach (XmlNode xmlNode in xmlNodeList)
{
if (xmlNode.NamespaceURI.Equals(DataNs) && xmlNode.Attributes["type", MeataNS] != null)
{
string xmlNodeName = xmlNode.LocalName;
if (!AtomSchemaHelper.IsBuiltInPrimitiveTypes(xmlNodeName, context, out xmlNodeTypes))
{
string metadataTypeValue = xmlNode.Attributes["type", MeataNS].Value;
if (appropriateNamespace.Count != 0)
{
// Verify the annoatation start with namespace.
foreach (string currentvalue in appropriateNamespace)
{
if (metadataTypeValue.Contains(currentvalue))
{
isNamespaceValue = true;
break;
}
else
{
isNamespaceValue = false;
}
}
}
if (appropriateAlias.Count != 0)
{
// Verify the annoatation start with alias.
foreach (string currentvalue in appropriateAlias)
{
if (metadataTypeValue.Contains(currentvalue))
{
isAliasValue = true;
break;
}
else
{
isAliasValue = false;
}
}
}
if (isNamespaceValue || isAliasValue)
{
passed = true;
continue;
}
else
{
passed = false;
info = new ExtensionRuleViolationInfo(this.ErrorMessage, context.Destination, context.ResponsePayload);
break;
}
}
}
}
return(passed);
}
/// <summary>
/// Verify Entry.Core.4627
/// </summary>
/// <param name="context">Service context</param>
/// <param name="info">out parameter to return violation information when rule fail</param>
/// <returns>true if rule passes; false otherwise</returns>
public override bool?Verify(ServiceContext context, out ExtensionRuleViolationInfo info)
{
if (context == null)
{
throw new ArgumentNullException("context");
}
bool?passed = null;
info = null;
XmlDocument xmlDoc = new XmlDocument();
xmlDoc.LoadXml(context.ResponsePayload);
string metadataNs = ODataVersion.V4 == context.Version ? Constants.NSMetadata : Constants.V3NSMetadata;
XmlNodeList xmlNodeList = xmlDoc.SelectNodes(@"//metadata:properties/*", ODataNamespaceManager.Instance);
List <string> collectedComplexTypeNames = AtomSchemaHelper.GetAllComplexNameWithCollectionType(context.MetadataDocument, context.EntityTypeShortName);
foreach (XmlNode xmlNode in xmlNodeList)
{
if (collectedComplexTypeNames.Contains(xmlNode.LocalName) && xmlNode.HasChildNodes)
{
string basedComplexTypeName =
xmlNode.Attributes["type", metadataNs]
.Value
.Remove(0, 1)
.RemoveCollectionFlag();
List <string> propNames = GetAllPropertyNamesFromComplexType(context.MetadataDocument, basedComplexTypeName.GetLastSegment());
foreach (XmlElement xElem in xmlNode)
{
if (xElem.LocalName.Equals("element"))
{
var nodes = xElem.SelectNodes("./*", ODataNamespaceManager.Instance);
bool flag = false;
foreach (XmlNode node in nodes)
{
string propName = node.LocalName;
if ("link" == node.LocalName)
{
if (null == node.Attributes["href"])
{
continue;
}
string hrefAttrib = node.Attributes["href"].Value;
propName = hrefAttrib.Remove(0, hrefAttrib.LastIndexOf("/") + 1);
}
if (!propNames.Contains(propName))
{
flag = true;
break;
}
}
if (flag)
{
if (xElem.HasAttribute("type", metadataNs))
{
string derivedComplexTypeName = xElem.GetAttribute("type", metadataNs).Remove(0, 1);
if (derivedComplexTypeName == basedComplexTypeName)
{
continue;
}
if (IsDerivedComplexType(context, derivedComplexTypeName.GetLastSegment(), basedComplexTypeName))
{
passed = true;
}
else
{
passed = false;
info = new ExtensionRuleViolationInfo(this.ErrorMessage, context.Destination, context.ResponsePayload);
break;
}
}
else
{
passed = false;
info = new ExtensionRuleViolationInfo(this.ErrorMessage, context.Destination, context.ResponsePayload);
break;
}
}
}
}
if (passed == false)
{
break;
}
}
}
return(passed);
}
/// <summary>
/// Verify Entry.Core.4617
/// </summary>
/// <param name="context">Service context</param>
/// <param name="info">out parameter to return violation information when rule fail</param>
/// <returns>true if rule passes; false otherwise</returns>
public override bool?Verify(ServiceContext context, out ExtensionRuleViolationInfo info)
{
if (context == null)
{
throw new ArgumentNullException("context");
}
bool?passed = null;
info = null;
string qualifiedName = "Edm.";
List <string> xmlNodeTypes = new List <string>();
XmlDocument xmlDoc = new XmlDocument();
xmlDoc.LoadXml(context.ResponsePayload);
XmlNamespaceManager nsmgr = new XmlNamespaceManager(xmlDoc.NameTable);
nsmgr.AddNamespace("m", Constants.V3NSMetadata);
string MeataNS = Constants.V3NSMetadata;
string DataNs = Constants.V3NSData;
if (context.Version == ODataVersion.V4)
{
nsmgr.AddNamespace("m", Constants.NSMetadata);
MeataNS = Constants.NSMetadata;
DataNs = Constants.V4NSData;
}
XmlNodeList xmlNodeList = xmlDoc.SelectNodes(@"//m:properties/*", nsmgr);
foreach (XmlNode xmlNode in xmlNodeList)
{
if (xmlNode.NamespaceURI.Equals(DataNs) && xmlNode.Attributes["type", MeataNS] != null)
{
string xmlNodeName = xmlNode.LocalName;
if (AtomSchemaHelper.IsBuiltInPrimitiveTypes(xmlNodeName, context, out xmlNodeTypes))
{
foreach (string xmlNodeType in xmlNodeTypes)
{
string unqualifiedName = xmlNodeType.Remove(0, qualifiedName.Length);
string metadataTypeValue = xmlNode.Attributes["type", MeataNS].Value;
if (metadataTypeValue.Equals(unqualifiedName))
{
passed = true;
}
else
{
passed = false;
info = new ExtensionRuleViolationInfo(this.ErrorMessage, context.Destination, context.ResponsePayload);
break;
}
}
if (passed == false)
{
break;
}
}
}
}
return(passed);
}
