public static bool IsNotSortable(IEdmProperty edmProperty, IEdmProperty pathEdmProperty,
IEdmStructuredType pathEdmStructuredType, IEdmModel edmModel, bool enableOrderBy)
{
QueryableRestrictionsAnnotation annotation = GetPropertyRestrictions(edmProperty, edmModel);
if (annotation != null && annotation.Restrictions.NotSortable)
{
return(true);
}
else
{
if (pathEdmStructuredType == null)
{
pathEdmStructuredType = edmProperty.DeclaringType;
}
ModelBoundQuerySettings querySettings = GetModelBoundQuerySettings(pathEdmProperty,
pathEdmStructuredType, edmModel);
if (!enableOrderBy)
{
return(!querySettings.Sortable(edmProperty.Name));
}
bool enable;
if (querySettings.OrderByConfigurations.TryGetValue(edmProperty.Name, out enable))
{
return(!enable);
}
else
{
return(querySettings.DefaultEnableOrderBy == false);
}
}
}
public override void Apply(PropertyConfiguration edmProperty,
StructuralTypeConfiguration structuralTypeConfiguration,
Attribute attribute,
ODataConventionModelBuilder model)
{
if (edmProperty == null)
{
throw Error.ArgumentNull("edmProperty");
}
if (!edmProperty.AddedExplicitly)
{
PageAttribute pageAttribute = attribute as PageAttribute;
ModelBoundQuerySettings querySettings = edmProperty.QueryConfiguration.GetModelBoundQuerySettingsOrDefault();
if (pageAttribute.MaxTop < 0)
{
querySettings.MaxTop = null;
}
else
{
querySettings.MaxTop = pageAttribute.MaxTop;
}
if (pageAttribute.PageSize > 0)
{
querySettings.PageSize = pageAttribute.PageSize;
}
}
}
public void Validate_Throws_IfMaxDepthLessThanLevels(int level)
{
// Arrange
string expand = string.Format("Parent($levels={0})", level + 1);
var validator = new SelectExpandQueryValidator(new DefaultQuerySettings {
EnableExpand = true
});
var builder = new ODataConventionModelBuilder();
builder.EntitySet <ODataLevelsTest.LevelsEntity>("Entities");
IEdmModel model = builder.GetEdmModel();
var context = new ODataQueryContext(model, typeof(ODataLevelsTest.LevelsEntity));
context.RequestContainer = new MockContainer();
var selectExpandQueryOption = new SelectExpandQueryOption(null, expand, context);
IEdmStructuredType customerType =
model.SchemaElements.First(e => e.Name.Equals("LevelsEntity")) as IEdmStructuredType;
ModelBoundQuerySettings querySettings = new ModelBoundQuerySettings();
querySettings.ExpandConfigurations.Add("Parent", new ExpandConfiguration
{
ExpandType = SelectExpandType.Allowed,
MaxDepth = level
});
model.SetAnnotationValue(customerType, querySettings);
// Act & Assert
ExceptionAssert.Throws <ODataException>(
() => validator.Validate(selectExpandQueryOption, new ODataValidationSettings {
MaxExpansionDepth = 0
}),
String.Format(CultureInfo.CurrentCulture, MaxExpandDepthExceededErrorString, level));
}
public void ValidateDoesNotThrow_IfExpansionDepthIsZero_QuerySettings()
{
// Arrange
string expand =
"Orders($expand=Customer($expand=Orders($expand=Customer($expand=Orders($expand=Customer)))))";
SelectExpandQueryValidator validator = new SelectExpandQueryValidator(new DefaultQuerySettings {
EnableExpand = true
});
CustomersModelWithInheritance model = new CustomersModelWithInheritance();
model.Model.SetAnnotationValue(model.Customer, new ClrTypeAnnotation(typeof(Customer)));
ODataQueryContext queryContext = new ODataQueryContext(model.Model, typeof(Customer));
queryContext.RequestContainer = new MockContainer();
SelectExpandQueryOption selectExpandQueryOption = new SelectExpandQueryOption(null, expand, queryContext);
IEdmStructuredType customerType =
model.Model.SchemaElements.First(e => e.Name.Equals("Customer")) as IEdmStructuredType;
ModelBoundQuerySettings querySettings = new ModelBoundQuerySettings();
querySettings.ExpandConfigurations.Add("Orders", new ExpandConfiguration
{
ExpandType = SelectExpandType.Allowed,
MaxDepth = 0
});
model.Model.SetAnnotationValue(customerType, querySettings);
// Act & Assert
ExceptionAssert.DoesNotThrow(
() => validator.Validate(selectExpandQueryOption, new ODataValidationSettings {
MaxExpansionDepth = 0
}));
}
/// <summary>
/// Get the page size.
/// </summary>
/// <param name="responseValue">The response value.</param>
/// <param name="singleResultCollection">The content as SingleResult.Queryable.</param>
/// <param name="actionDescriptor">The action context, i.e. action and controller name.</param>
/// <param name="modelFunction">A function to get the model.</param>
/// <param name="path">The OData path.</param>
/// <param name="createErrorAction">A function used to generate error response.</param>
private void GetModelBoundPageSize(
object responseValue,
IQueryable singleResultCollection,
IWebApiActionDescriptor actionDescriptor,
Func <Type, IEdmModel> modelFunction,
ODataPath path,
Action <HttpStatusCode, string, Exception> createErrorAction)
{
ODataQueryContext queryContext = null;
try
{
queryContext = GetODataQueryContext(responseValue, singleResultCollection, actionDescriptor, modelFunction, path);
}
catch (InvalidOperationException e)
{
createErrorAction(
HttpStatusCode.BadRequest,
Error.Format(SRResources.UriQueryStringInvalid, e.Message),
e);
return;
}
ModelBoundQuerySettings querySettings = EdmLibHelpers.GetModelBoundQuerySettings(queryContext.TargetProperty,
queryContext.TargetStructuredType,
queryContext.Model);
if (querySettings != null && querySettings.PageSize.HasValue)
{
_querySettings.ModelBoundPageSize = querySettings.PageSize;
}
}
private void GetModelBoundPageSize(ODataQueryContext queryContext, ObjectContent responseContent,
HttpRequestMessage request, HttpActionDescriptor actionDescriptor,
HttpActionExecutedContext actionExecutedContext)
{
try
{
queryContext = GetODataQueryContext(responseContent.Value, request, actionDescriptor);
}
catch (InvalidOperationException e)
{
actionExecutedContext.Response = request.CreateErrorResponse(
HttpStatusCode.BadRequest,
Error.Format(SRResources.UriQueryStringInvalid, e.Message),
e);
return;
}
ModelBoundQuerySettings querySettings = EdmLibHelpers.GetModelBoundQuerySettings(queryContext.TargetProperty,
queryContext.TargetStructuredType,
queryContext.Model);
if (querySettings != null && querySettings.PageSize.HasValue)
{
_querySettings.ModelBoundPageSize = querySettings.PageSize;
}
}
public static bool IsNotCountable(
IEdmProperty property,
IEdmStructuredType structuredType,
IEdmModel edmModel,
bool enableCount)
{
if (property != null)
{
QueryableRestrictionsAnnotation annotation = GetPropertyRestrictions(property, edmModel);
if (annotation != null && annotation.Restrictions.NotCountable)
{
return(true);
}
}
ModelBoundQuerySettings querySettings = GetModelBoundQuerySettings(property, structuredType, edmModel);
if (querySettings != null &&
((!querySettings.Countable.HasValue && !enableCount) || querySettings.Countable == false))
{
return(true);
}
return(false);
}
public override void Apply(PropertyConfiguration edmProperty,
StructuralTypeConfiguration structuralTypeConfiguration,
Attribute attribute,
ODataConventionModelBuilder model)
{
if (edmProperty == null)
{
throw Error.ArgumentNull("edmProperty");
}
if (!edmProperty.AddedExplicitly)
{
FilterAttribute filterAttribute = attribute as FilterAttribute;
ModelBoundQuerySettings querySettings = edmProperty.QueryConfiguration.GetModelBoundQuerySettingsOrDefault();
if (querySettings.FilterConfigurations.Count == 0)
{
querySettings.CopyFilterConfigurations(filterAttribute.FilterConfigurations);
}
else
{
foreach (var property in filterAttribute.FilterConfigurations.Keys)
{
querySettings.FilterConfigurations[property] =
filterAttribute.FilterConfigurations[property];
}
}
if (filterAttribute.FilterConfigurations.Count == 0)
{
querySettings.DefaultEnableFilter = filterAttribute.DefaultEnableFilter;
}
}
}
public void Validate_DepthChecks_QuerySettings(string expand, int maxExpansionDepth)
{
// Arrange
SelectExpandQueryValidator validator = new SelectExpandQueryValidator(new DefaultQuerySettings {
EnableExpand = true
});
CustomersModelWithInheritance model = new CustomersModelWithInheritance();
model.Model.SetAnnotationValue(model.Customer, new ClrTypeAnnotation(typeof(Customer)));
ODataQueryContext queryContext = new ODataQueryContext(model.Model, typeof(Customer));
queryContext.RequestContainer = new MockContainer();
SelectExpandQueryOption selectExpandQueryOption = new SelectExpandQueryOption(null, expand, queryContext);
selectExpandQueryOption.LevelsMaxLiteralExpansionDepth = 1;
IEdmStructuredType customerType =
model.Model.SchemaElements.First(e => e.Name.Equals("Customer")) as IEdmStructuredType;
ModelBoundQuerySettings querySettings = new ModelBoundQuerySettings();
querySettings.ExpandConfigurations.Add("Orders", new ExpandConfiguration
{
ExpandType = SelectExpandType.Allowed,
MaxDepth = maxExpansionDepth
});
model.Model.SetAnnotationValue(customerType, querySettings);
// Act & Assert
ExceptionAssert.Throws <ODataException>(
() => validator.Validate(selectExpandQueryOption, new ODataValidationSettings {
MaxExpansionDepth = maxExpansionDepth + 1
}),
String.Format(CultureInfo.CurrentCulture, MaxExpandDepthExceededErrorString, maxExpansionDepth));
}
public void ValidateThrowException_IfNotExpandable_QuerySettings()
{
// Arrange
CustomersModelWithInheritance model = new CustomersModelWithInheritance();
model.Model.SetAnnotationValue(model.Customer, new ClrTypeAnnotation(typeof(Customer)));
ODataQueryContext queryContext = new ODataQueryContext(model.Model, typeof(Customer));
queryContext.RequestContainer = new MockContainer();
SelectExpandQueryValidator validator = SelectExpandQueryValidator.GetSelectExpandQueryValidator(queryContext);
SelectExpandQueryOption selectExpandQueryOption = new SelectExpandQueryOption(null, "Orders", queryContext);
IEdmStructuredType customerType =
model.Model.SchemaElements.First(e => e.Name.Equals("Customer")) as IEdmStructuredType;
ModelBoundQuerySettings querySettings = new ModelBoundQuerySettings();
querySettings.ExpandConfigurations.Add("Orders", new ExpandConfiguration
{
ExpandType = SelectExpandType.Disabled,
MaxDepth = 0
});
model.Model.SetAnnotationValue(customerType, querySettings);
// Act & Assert
ExceptionAssert.Throws <ODataException>(
() => validator.Validate(selectExpandQueryOption, new ODataValidationSettings()),
"The property 'Orders' cannot be used in the $expand query option.");
}
public override void Apply(PropertyConfiguration edmProperty,
StructuralTypeConfiguration structuralTypeConfiguration,
Attribute attribute,
ODataConventionModelBuilder model)
{
if (edmProperty == null)
{
throw Error.ArgumentNull("edmProperty");
}
if (!edmProperty.AddedExplicitly)
{
SelectAttribute selectAttribute = attribute as SelectAttribute;
ModelBoundQuerySettings querySettings =
edmProperty.QueryConfiguration.GetModelBoundQuerySettingsOrDefault();
if (querySettings.SelectConfigurations.Count == 0)
{
querySettings.CopySelectConfigurations(selectAttribute.SelectConfigurations);
}
else
{
foreach (var property in selectAttribute.SelectConfigurations.Keys)
{
querySettings.SelectConfigurations[property] =
selectAttribute.SelectConfigurations[property];
}
}
if (selectAttribute.SelectConfigurations.Count == 0)
{
querySettings.DefaultSelectType = selectAttribute.DefaultSelectType;
}
}
}
private static ModelBoundQuerySettings GetModelBoundQuerySettings <T>(T key, IEdmModel edmModel,
DefaultQuerySettings defaultQuerySettings = null)
where T : IEdmElement
{
Contract.Assert(edmModel != null);
if (key == null)
{
return(null);
}
else
{
ModelBoundQuerySettings querySettings = edmModel.GetAnnotationValue <ModelBoundQuerySettings>(key);
if (querySettings == null)
{
querySettings = new ModelBoundQuerySettings();
if (defaultQuerySettings != null &&
(!defaultQuerySettings.MaxTop.HasValue || defaultQuerySettings.MaxTop > 0))
{
querySettings.MaxTop = defaultQuerySettings.MaxTop;
}
}
return(querySettings);
}
}
void VisitMaxTop(ModelBoundQuerySettings querySettings)
{
if (querySettings.MaxTop != null && querySettings.MaxTop.Value > 0)
{
context.MaxTop = querySettings.MaxTop;
}
}
public static bool IsNotSelectable(IEdmProperty edmProperty, IEdmProperty pathEdmProperty,
IEdmStructuredType pathEdmStructuredType, IEdmModel edmModel, bool enableSelect)
{
if (pathEdmStructuredType == null)
{
pathEdmStructuredType = edmProperty.DeclaringType;
}
ModelBoundQuerySettings querySettings = GetModelBoundQuerySettings(pathEdmProperty,
pathEdmStructuredType, edmModel);
if (!enableSelect)
{
return(!querySettings.Selectable(edmProperty.Name));
}
SelectExpandType enable;
if (querySettings.SelectConfigurations.TryGetValue(edmProperty.Name, out enable))
{
return(enable == SelectExpandType.Disabled);
}
else
{
return(querySettings.DefaultSelectType == SelectExpandType.Disabled);
}
}
public override void Apply(PropertyConfiguration edmProperty,
StructuralTypeConfiguration structuralTypeConfiguration,
Attribute attribute,
ODataConventionModelBuilder model)
{
if (edmProperty == null)
{
throw Error.ArgumentNull("edmProperty");
}
if (!edmProperty.AddedExplicitly)
{
ExpandAttribute expandAttribute = attribute as ExpandAttribute;
ModelBoundQuerySettings querySettings = edmProperty.QueryConfiguration.GetModelBoundQuerySettingsOrDefault();
if (querySettings.ExpandConfigurations.Count == 0)
{
querySettings.CopyExpandConfigurations(expandAttribute.ExpandConfigurations);
}
else
{
foreach (var property in expandAttribute.ExpandConfigurations.Keys)
{
querySettings.ExpandConfigurations[property] =
expandAttribute.ExpandConfigurations[property];
}
}
if (expandAttribute.ExpandConfigurations.Count == 0)
{
querySettings.DefaultExpandType = expandAttribute.DefaultExpandType;
querySettings.DefaultMaxDepth = expandAttribute.DefaultMaxDepth ?? ODataValidationSettings.DefaultMaxExpansionDepth;
}
}
}
public static IEnumerable <IEdmNavigationProperty> GetAutoExpandNavigationProperties(
IEdmProperty pathProperty, IEdmStructuredType pathStructuredType, IEdmModel edmModel,
bool isSelectPresent = false, ModelBoundQuerySettings querySettings = null)
{
List <IEdmNavigationProperty> autoExpandNavigationProperties = new List <IEdmNavigationProperty>();
IEdmEntityType baseEntityType = pathStructuredType as IEdmEntityType;
if (baseEntityType != null)
{
List <IEdmEntityType> entityTypes = new List <IEdmEntityType>();
entityTypes.Add(baseEntityType);
entityTypes.AddRange(GetAllDerivedEntityTypes(baseEntityType, edmModel));
foreach (var entityType in entityTypes)
{
IEnumerable <IEdmNavigationProperty> navigationProperties = entityType == baseEntityType
? entityType.NavigationProperties()
: entityType.DeclaredNavigationProperties();
if (navigationProperties != null)
{
autoExpandNavigationProperties.AddRange(
navigationProperties.Where(
navigationProperty =>
IsAutoExpand(navigationProperty, pathProperty, entityType, edmModel,
isSelectPresent, querySettings)));
}
}
}
return(autoExpandNavigationProperties);
}
/// <summary>
/// Gets the <see cref="ModelBoundQuerySettings"/> or create it depends on the default settings.
/// </summary>
internal ModelBoundQuerySettings GetModelBoundQuerySettingsOrDefault()
{
if (_querySettings == null)
{
_querySettings = new ModelBoundQuerySettings(ModelBoundQuerySettings.DefaultModelBoundQuerySettings);
}
return(_querySettings);
}
void VisitMaxTop(ModelBoundQuerySettings querySettings)
{
Contract.Requires(querySettings != null);
if (querySettings.MaxTop != null && querySettings.MaxTop.Value > 0)
{
context.MaxTop = querySettings.MaxTop;
}
}
private static ModelBoundQuerySettings GetMergedPropertyQuerySettings(
ModelBoundQuerySettings propertyQuerySettings, ModelBoundQuerySettings propertyTypeQuerySettings)
{
ModelBoundQuerySettings mergedQuerySettings = new ModelBoundQuerySettings(propertyQuerySettings);
if (propertyTypeQuerySettings != null)
{
if (!mergedQuerySettings.PageSize.HasValue)
{
mergedQuerySettings.PageSize =
propertyTypeQuerySettings.PageSize;
}
if (mergedQuerySettings.MaxTop == 0 && propertyTypeQuerySettings.MaxTop != 0)
{
mergedQuerySettings.MaxTop =
propertyTypeQuerySettings.MaxTop;
}
if (!mergedQuerySettings.Countable.HasValue)
{
mergedQuerySettings.Countable = propertyTypeQuerySettings.Countable;
}
if (mergedQuerySettings.OrderByConfigurations.Count == 0 &&
!mergedQuerySettings.DefaultEnableOrderBy.HasValue)
{
mergedQuerySettings.CopyOrderByConfigurations(propertyTypeQuerySettings.OrderByConfigurations);
mergedQuerySettings.DefaultEnableOrderBy = propertyTypeQuerySettings.DefaultEnableOrderBy;
}
if (mergedQuerySettings.FilterConfigurations.Count == 0 &&
!mergedQuerySettings.DefaultEnableFilter.HasValue)
{
mergedQuerySettings.CopyFilterConfigurations(propertyTypeQuerySettings.FilterConfigurations);
mergedQuerySettings.DefaultEnableFilter = propertyTypeQuerySettings.DefaultEnableFilter;
}
if (mergedQuerySettings.SelectConfigurations.Count == 0 &&
!mergedQuerySettings.DefaultSelectType.HasValue)
{
mergedQuerySettings.CopySelectConfigurations(propertyTypeQuerySettings.SelectConfigurations);
mergedQuerySettings.DefaultSelectType = propertyTypeQuerySettings.DefaultSelectType;
}
if (mergedQuerySettings.ExpandConfigurations.Count == 0 &&
!mergedQuerySettings.DefaultExpandType.HasValue)
{
mergedQuerySettings.CopyExpandConfigurations(
propertyTypeQuerySettings.ExpandConfigurations);
mergedQuerySettings.DefaultExpandType = propertyTypeQuerySettings.DefaultExpandType;
mergedQuerySettings.DefaultMaxDepth = propertyTypeQuerySettings.DefaultMaxDepth;
}
}
return(mergedQuerySettings);
}
bool IsExpandEnabled(ModelBoundQuerySettings querySettings)
{
if (!querySettings.DefaultExpandType.HasValue)
{
return(AllowedQueryOptions.HasFlag(Expand) ||
querySettings.ExpandConfigurations.Any(p => p.Value.ExpandType != Disabled));
}
return(querySettings.DefaultExpandType.Value != Disabled ||
querySettings.ExpandConfigurations.Any(p => p.Value.ExpandType != Disabled));
}
bool IsSelectEnabled(ModelBoundQuerySettings querySettings)
{
if (!querySettings.DefaultSelectType.HasValue)
{
return(AllowedQueryOptions.HasFlag(Select) ||
querySettings.SelectConfigurations.Any(p => p.Value != Disabled));
}
return(querySettings.DefaultSelectType.Value != Disabled ||
querySettings.SelectConfigurations.Any(p => p.Value != Disabled));
}
bool IsFilterEnabled(ModelBoundQuerySettings querySettings)
{
if (!querySettings.DefaultEnableFilter.HasValue)
{
return(AllowedQueryOptions.HasFlag(Filter) ||
querySettings.FilterConfigurations.Any(p => p.Value));
}
return(querySettings.DefaultEnableFilter.Value ||
querySettings.FilterConfigurations.Any(p => p.Value));
}
bool IsOrderByEnabled(ModelBoundQuerySettings querySettings)
{
if (!querySettings.DefaultEnableOrderBy.HasValue)
{
return(AllowedQueryOptions.HasFlag(OrderBy) ||
querySettings.OrderByConfigurations.Any(p => p.Value));
}
return(querySettings.DefaultEnableOrderBy.Value ||
querySettings.OrderByConfigurations.Any(p => p.Value));
}
private static void AddPropertiesQuerySettings(this EdmModel model,
Dictionary <IEdmProperty, ModelBoundQuerySettings> edmPropertiesQuerySettings)
{
foreach (KeyValuePair <IEdmProperty, ModelBoundQuerySettings> edmPropertiesQuerySetting in
edmPropertiesQuerySettings)
{
IEdmProperty edmProperty = edmPropertiesQuerySetting.Key;
ModelBoundQuerySettings querySettings = edmPropertiesQuerySetting.Value;
model.SetAnnotationValue(edmProperty, querySettings);
}
}
private static void AddStructuredTypeQuerySettings(this EdmModel model,
Dictionary <IEdmStructuredType, ModelBoundQuerySettings> edmStructuredTypeQuerySettings)
{
foreach (
KeyValuePair <IEdmStructuredType, ModelBoundQuerySettings> edmStructuredTypeQuerySetting in
edmStructuredTypeQuerySettings)
{
IEdmStructuredType structuredType = edmStructuredTypeQuerySetting.Key;
ModelBoundQuerySettings querySettings = edmStructuredTypeQuerySetting.Value;
model.SetAnnotationValue(structuredType, querySettings);
}
}
void VisitCount(ModelBoundQuerySettings querySettings)
{
Contract.Requires(querySettings != null);
if (querySettings.Countable == true)
{
AllowedQueryOptions |= Count;
}
else
{
AllowedQueryOptions &= ~Count;
}
}
public static bool IsTopLimitExceeded(IEdmProperty property, IEdmStructuredType structuredType,
IEdmModel edmModel, int top, DefaultQuerySettings defaultQuerySettings, out int maxTop)
{
maxTop = 0;
ModelBoundQuerySettings querySettings = GetModelBoundQuerySettings(property, structuredType, edmModel,
defaultQuerySettings);
if (querySettings != null && top > querySettings.MaxTop)
{
maxTop = querySettings.MaxTop.Value;
return(true);
}
return(false);
}
void VisitCount(ModelBoundQuerySettings querySettings)
{
if (!querySettings.Countable.HasValue)
{
return;
}
if (querySettings.Countable.Value)
{
AllowedQueryOptions |= Count;
}
else
{
AllowedQueryOptions &= ~Count;
}
}
public void ValidatePassWhenQuerySettingsLimitIsNotReached()
{
// Arrange
ODataValidationSettings settings = new ODataValidationSettings()
{
MaxTop = 20
};
ModelBoundQuerySettings modelBoundQuerySettings = new ModelBoundQuerySettings();
modelBoundQuerySettings.MaxTop = 20;
ODataQueryContext context = ValidationTestHelper.CreateCustomerContext();
context.Model.SetAnnotationValue(context.ElementType as IEdmStructuredType, modelBoundQuerySettings);
// Act & Assert
ExceptionAssert.DoesNotThrow(() => _validator.Validate(new TopQueryOption("20", context), settings));
}
public static IEnumerable <IEdmStructuralProperty> GetAutoSelectProperties(
IEdmProperty pathProperty,
IEdmStructuredType pathStructuredType,
IEdmModel edmModel,
ModelBoundQuerySettings querySettings = null)
{
List <IEdmStructuralProperty> autoSelectProperties = new List <IEdmStructuralProperty>();
IEdmEntityType baseEntityType = pathStructuredType as IEdmEntityType;
if (baseEntityType != null)
{
List <IEdmEntityType> entityTypes = new List <IEdmEntityType>();
entityTypes.Add(baseEntityType);
entityTypes.AddRange(GetAllDerivedEntityTypes(baseEntityType, edmModel));
foreach (var entityType in entityTypes)
{
IEnumerable <IEdmStructuralProperty> properties = entityType == baseEntityType
? entityType.StructuralProperties()
: entityType.DeclaredStructuralProperties();
if (properties != null)
{
autoSelectProperties.AddRange(
properties.Where(
property =>
IsAutoSelect(property, pathProperty, entityType, edmModel,
querySettings)));
}
}
}
else if (pathStructuredType != null)
{
IEnumerable <IEdmStructuralProperty> properties = pathStructuredType.StructuralProperties();
if (properties != null)
{
autoSelectProperties.AddRange(
properties.Where(
property =>
IsAutoSelect(property, pathProperty, pathStructuredType, edmModel,
querySettings)));
}
}
return(autoSelectProperties);
}
