/// <summary>Whether the types contained in the set has mappings for friendly feeds are V1 compatible or not</summary>
/// <param name="provider">Data service provider instance.</param>
/// <returns>False if there's any type in this set which has friendly feed mappings with KeepInContent=false. True otherwise.</returns>
internal bool EpmIsV1Compatible(DataServiceProviderWrapper provider)
{
#if DEBUG
Debug.Assert(provider != null, "provider != null");
Debug.Assert(this.resourceSet != null, "this.resourceSet != null");
Debug.Assert(this.isReadOnly, "EpmIsV1Compatible - entity set settings not initialized.");
#endif
if (!this.epmIsV1Compatible.HasValue)
{
// Go through all types contained in the set. If any one type is EpmIsV1Compatible == false,
// the whole set is EpmIsV1Compatible=false.
ResourceType baseType = this.resourceSet.ResourceType;
bool isV1Compatible = baseType.EpmIsV1Compatible;
// If the base type is not epm v1 compatible or it has no derived type, we need not look any further.
if (isV1Compatible && provider.HasDerivedTypes(baseType))
{
foreach (ResourceType derivedType in provider.GetDerivedTypes(baseType))
{
if (!derivedType.EpmIsV1Compatible)
{
// We can stop as soon as we find the first type that is not epm v1 compatible.
isV1Compatible = false;
break;
}
}
}
this.epmIsV1Compatible = isV1Compatible;
}
return(this.epmIsV1Compatible.Value);
}
private void CheckHierarchy(DataServiceProviderWrapper provider)
{
if (!this.epmMinDSPV.HasValue)
{
System.Data.Services.Providers.ResourceType resourceType = this.resourceSet.ResourceType;
bool hasEntityPropertyMappings = resourceType.HasEntityPropertyMappings;
DataServiceProtocolVersion epmMinimumDataServiceProtocolVersion = resourceType.EpmMinimumDataServiceProtocolVersion;
bool flag2 = false;
bool flag3 = this.GetEntitySerializableProperties(provider, resourceType).Any <ResourceProperty>(p => p.TypeKind == ResourceTypeKind.EntityType);
bool isOpenType = resourceType.IsOpenType;
Version metadataVersion = resourceType.MetadataVersion;
if (provider.HasDerivedTypes(resourceType))
{
foreach (System.Data.Services.Providers.ResourceType type2 in provider.GetDerivedTypes(resourceType))
{
if (type2.EpmMinimumDataServiceProtocolVersion > epmMinimumDataServiceProtocolVersion)
{
epmMinimumDataServiceProtocolVersion = type2.EpmMinimumDataServiceProtocolVersion;
}
hasEntityPropertyMappings |= type2.HasEntityPropertyMappings;
bool flag5 = this.GetEntitySerializablePropertiesDeclaredOnTheResourceType(provider, type2).Any <ResourceProperty>(p => p.TypeKind == ResourceTypeKind.EntityType);
flag3 |= flag5;
flag2 |= type2.HasNamedStreamsDeclaredOnThisType | flag5;
metadataVersion = WebUtil.RaiseVersion(metadataVersion, type2.MetadataVersion);
isOpenType |= type2.IsOpenType;
if (((epmMinimumDataServiceProtocolVersion == DataServiceProtocolVersion.V3) && (metadataVersion == RequestDescription.Version3Dot0)) && (flag2 && isOpenType))
{
break;
}
}
}
this.hasEntityPropertyMappings = hasEntityPropertyMappings;
this.epmMinDSPV = new DataServiceProtocolVersion?(epmMinimumDataServiceProtocolVersion);
this.hasNavigationPropertyOrNamedStreamOnDerivedTypes = flag2;
this.hasAccessibleNavigationProperty = flag3;
this.hasOpenTypes = isOpenType;
this.metadataVersion = metadataVersion;
}
}
internal void ApplyWildcardsAndSort(DataServiceProviderWrapper provider)
{
Func <ProjectionNode, bool> predicate = null;
if (this.projectSubtree)
{
for (int i = this.nodes.Count - 1; i >= 0; i--)
{
ExpandedProjectionNode node = this.nodes[i] as ExpandedProjectionNode;
if (node != null)
{
node.projectSubtree = true;
node.ApplyWildcardsAndSort(provider);
}
else
{
this.nodes.RemoveAt(i);
}
}
this.projectAllImmediateProperties = false;
this.projectAllImmediateOperations = false;
}
else
{
for (int j = this.nodes.Count - 1; j >= 0; j--)
{
ExpandedProjectionNode node2 = this.nodes[j] as ExpandedProjectionNode;
if (this.ProjectAllImmediateProperties && (node2 == null))
{
this.nodes.RemoveAt(j);
}
else if (node2 != null)
{
node2.ApplyWildcardsAndSort(provider);
}
}
if (this.nodes.Count > 0)
{
List <System.Data.Services.Providers.ResourceType> resourceTypesInMetadataOrder = new List <System.Data.Services.Providers.ResourceType> {
this.ResourceType
};
if (predicate == null)
{
predicate = n => !System.Data.Services.Providers.ResourceType.CompareReferences(n.TargetResourceType, this.ResourceType);
}
List <ProjectionNode> source = this.nodes.Where <ProjectionNode>(predicate).ToList <ProjectionNode>();
if (source.Count > 0)
{
using (IEnumerator <System.Data.Services.Providers.ResourceType> enumerator = provider.GetDerivedTypes(this.ResourceType).GetEnumerator())
{
Func <ProjectionNode, bool> func = null;
System.Data.Services.Providers.ResourceType rt;
while (enumerator.MoveNext())
{
rt = enumerator.Current;
if (func == null)
{
func = node => node.TargetResourceType == rt;
}
if (source.FirstOrDefault <ProjectionNode>(func) != null)
{
resourceTypesInMetadataOrder.Add(rt);
}
}
}
}
this.nodes = SortNodes(this.nodes, resourceTypesInMetadataOrder);
}
}
}
