protected override Expression VisitConstant(ConstantExpression node)
{
if (node.Value is OeEnumerableStub enumerableStub)
{
IQueryable query = null;
if (_queryableSource != null)
{
query = _queryableSource(enumerableStub.EntitySet);
if (query != null && query.Expression is MethodCallExpression)
{
return(query.Expression);
}
}
if (query == null)
{
Db.OeEntitySetAdapter entitySetAdapter = _edmModel.GetEntitySetAdapter(enumerableStub.EntitySet);
query = entitySetAdapter.GetEntitySet(_dataContext);
}
return(Expression.Constant(query));
}
return(node);
}
protected override Expression VisitConstant(ConstantExpression node)
{
if (node.Value is OeEnumerableStub enumerableStub)
{
IQueryable?query = null;
if (_queryableSource != null)
{
query = _queryableSource(enumerableStub.EntitySet);
if (query != null && query.Expression is MethodCallExpression)
{
return(query.Expression);
}
}
if (query == null)
{
if (_dataContext == null)
{
throw new InvalidOperationException("If function queryableSource return null dataContext must be not null");
}
Db.OeEntitySetAdapter entitySetAdapter = _edmModel.GetEntitySetAdapter(enumerableStub.EntitySet);
query = entitySetAdapter.GetEntitySet(_dataContext);
}
return(query.Expression);
}
return(node);
}
public Db.OeAsyncEnumerator GetAsyncEnumerator(ODataUri odataUri, Stream requestStream, OeRequestHeaders headers, Object dataContext, out bool isScalar)
{
isScalar = true;
var importSegment = (OperationImportSegment)odataUri.Path.LastSegment;
IReadOnlyList<KeyValuePair<String, Object>> parameters = OeOperationHelper.GetParameters(_edmModel, importSegment, odataUri.ParameterAliasNodes, requestStream, headers.ContentType);
IEdmOperationImport operationImport = importSegment.OperationImports.Single();
IEdmEntitySet entitySet = OeOperationHelper.GetEntitySet(operationImport);
if (entitySet == null)
{
if (operationImport.Operation.ReturnType == null)
return _dataAdapter.OperationAdapter.ExecuteProcedureNonQuery(dataContext, operationImport.Name, parameters);
Type returnType = _edmModel.GetClrType(operationImport.Operation.ReturnType.Definition);
if (operationImport.Operation.ReturnType.IsCollection())
{
isScalar = false;
returnType = typeof(IEnumerable<>).MakeGenericType(returnType);
}
if (_edmModel.IsDbFunction(operationImport.Operation))
return _dataAdapter.OperationAdapter.ExecuteFunctionPrimitive(dataContext, operationImport.Name, parameters, returnType);
else
return _dataAdapter.OperationAdapter.ExecuteProcedurePrimitive(dataContext, operationImport.Name, parameters, returnType);
}
isScalar = false;
Db.OeEntitySetAdapter entitySetAdapter = _dataAdapter.EntitySetAdapters.Find(entitySet);
if (_edmModel.IsDbFunction(operationImport.Operation))
return _dataAdapter.OperationAdapter.ExecuteFunctionReader(dataContext, operationImport.Name, parameters, entitySetAdapter);
else
return _dataAdapter.OperationAdapter.ExecuteProcedureReader(dataContext, operationImport.Name, parameters, entitySetAdapter);
}
internal OeQueryContext(IEdmModel edmModel, ODataUri odataUri,
IEdmEntitySet entitySet, IReadOnlyList <OeParseNavigationSegment> parseNavigationSegments,
bool isCountSegment, int pageSize, bool navigationNextLink, bool isDatabaseNullHighestValue,
OeMetadataLevel metadataLevel, Db.OeEntitySetAdapter entitySetAdapter)
{
EntitySetAdapter = entitySetAdapter;
EdmModel = edmModel;
ODataUri = odataUri;
EntitySet = entitySet;
ParseNavigationSegments = parseNavigationSegments;
IsCountSegment = isCountSegment;
PageSize = pageSize;
NavigationNextLink = navigationNextLink;
IsDatabaseNullHighestValue = isDatabaseNullHighestValue;
MetadataLevel = metadataLevel;
var visitor = new OeQueryNodeVisitor(edmModel, Expression.Parameter(entitySetAdapter.EntityType));
JoinBuilder = new Translators.OeJoinBuilder(visitor);
if (pageSize > 0 || (odataUri.OrderBy != null && odataUri.Skip != null && odataUri.Top != null))
{
SkipTokenNameValues = OeSkipTokenParser.CreateNameValues(edmModel, odataUri.OrderBy, odataUri.SkipToken);
}
}
public override IEnumerable Read(Stream response)
{
String entitySetName = ResponseReader.GetEntitSetName(response);
response.Position = 0;
Db.OeEntitySetAdapter entitySetMetaAdatpter = TestHelper.FindEntitySetAdapterByName(base.EntitySetAdapters, entitySetName);
return(base.Read(response, entitySetMetaAdatpter));
}
public virtual IEnumerable Read(Stream response)
{
String entitySetName = GetEntitSetName(response);
response.Position = 0;
Db.OeEntitySetAdapter entitySetMetaAdatpter = EntitySetAdapters.FindByEntitySetName(entitySetName);
return(ReadImpl(response, entitySetMetaAdatpter));
}
public override IEnumerable Read(Stream response)
{
String entitySetName = ResponseReader.GetEntitSetName(response);
response.Position = 0;
Db.OeEntitySetAdapter entitySetMetaAdatpter = base.EntitySetAdapters.FindByEntitySetName(entitySetName);
return(base.ReadImpl(response, entitySetMetaAdatpter));
}
public virtual IEnumerable Read(Stream response)
{
String entitySetName = GetEntitSetName(response);
response.Position = 0;
Db.OeEntitySetAdapter entitySetMetaAdatpter = TestHelper.FindEntitySetAdapterByName(EntitySetAdapters, entitySetName);
return(Read(response, entitySetMetaAdatpter));
}
public OeQueryContext(IEdmModel edmModel, ODataUri odataUri, Db.OeEntitySetAdapter entitySetAdapter)
{
EdmModel = edmModel;
ODataUri = odataUri;
EntitySetAdapter = entitySetAdapter;
ParseNavigationSegments = Array.Empty <OeParseNavigationSegment>();
MetadataLevel = OeMetadataLevel.Minimal;
}
protected override Object CreateEntity(ODataResourceBase resource, IReadOnlyList <NavigationInfo> navigationProperties)
{
Db.OeEntitySetAdapter entitySetAdapter = TestHelper.FindEntitySetAdapterByTypeName(EntitySetAdapters, resource.TypeName);
Type entityType = entitySetAdapter.EntityType;
var openType = (SortedDictionary <String, Object>)CreateEntity(entityType, resource);
Dictionary <PropertyInfo, NavigationInfo> propertyInfos = null;
foreach (NavigationInfo navigationInfo in navigationProperties)
{
Object value = navigationInfo.Value;
if (navigationInfo.Count != null || navigationInfo.NextPageLink != null)
{
PropertyInfo clrProperty = entityType.GetProperty(navigationInfo.Name);
if (value == null && navigationInfo.NextPageLink != null)
{
if (navigationInfo.IsCollection)
{
value = new List <SortedDictionary <String, Object> >();
}
else
{
value = new SortedDictionary <String, Object>();
}
}
base.NavigationProperties.Add(value, navigationInfo);
if (propertyInfos == null)
{
propertyInfos = new Dictionary <PropertyInfo, NavigationInfo>(navigationProperties.Count);
base.NavigationInfoEntities.Add(openType, propertyInfos);
}
propertyInfos.Add(clrProperty, navigationInfo);
}
if (value == null)
{
PropertyInfo clrProprety = entityType.GetProperty(navigationInfo.Name);
Type type = OeExpressionHelper.GetCollectionItemTypeOrNull(clrProprety.PropertyType);
if (type == null)
{
type = clrProprety.PropertyType;
}
if (OeExpressionHelper.IsEntityType(type))
{
value = DBNull.Value;
}
}
openType.Add(navigationInfo.Name, value);
}
return(openType);
}
public OeQueryContext CreateQueryContext(ODataUri odataUri, IEdmEntitySet entitySet, OeMetadataLevel metadataLevel)
{
OePropertyAccessor[] accessors = OePropertyAccessor.CreateFromType(_edmModel.GetClrType(entitySet), entitySet);
Db.OeEntitySetAdapter entitySetAdapter = _dataAdapter.EntitySetAdapters.Find(entitySet);
return(new OeQueryContext(_edmModel, odataUri, entitySetAdapter)
{
EntryFactory = new OeEntryFactory(entitySet, accessors, null),
MetadataLevel = metadataLevel
});
}
public OeQueryContext CreateQueryContext(ODataUri odataUri, int pageSize, bool navigationNextLink, OeMetadataLevel metadataLevel)
{
List <OeParseNavigationSegment> navigationSegments = null;
if (odataUri.Path.LastSegment is KeySegment ||
odataUri.Path.LastSegment is NavigationPropertySegment)
{
navigationSegments = new List <OeParseNavigationSegment>();
ODataPathSegment previousSegment = null;
foreach (ODataPathSegment segment in odataUri.Path)
{
if (segment is NavigationPropertySegment navigationSegment)
{
navigationSegments.Add(new OeParseNavigationSegment(navigationSegment, null));
}
else if (segment is KeySegment keySegment)
{
IEdmEntitySet previousEntitySet;
navigationSegment = null;
if (previousSegment is EntitySetSegment)
{
var previousEntitySetSegment = previousSegment as EntitySetSegment;
previousEntitySet = previousEntitySetSegment.EntitySet;
}
else if (previousSegment is NavigationPropertySegment)
{
navigationSegment = previousSegment as NavigationPropertySegment;
previousEntitySet = (IEdmEntitySet)navigationSegment.NavigationSource;
}
else
{
throw new InvalidOperationException("invalid segment");
}
FilterClause keyFilter = CreateFilterClause(previousEntitySet, keySegment.Keys);
navigationSegments.Add(new OeParseNavigationSegment(navigationSegment, keyFilter));
}
previousSegment = segment;
}
}
var entitySetSegment = (EntitySetSegment)odataUri.Path.FirstSegment;
if (pageSize > 0)
{
odataUri.Top = pageSize;
IEdmEntitySet resultEntitySet = OeParseNavigationSegment.GetEntitySet(navigationSegments) ?? entitySetSegment.EntitySet;
odataUri.OrderBy = OeSkipTokenParser.GetUniqueOrderBy(_edmModel, resultEntitySet, odataUri.OrderBy, odataUri.Apply);
}
Db.OeEntitySetAdapter entitySetAdapter = _edmModel.GetEntitySetAdapter(entitySetSegment.EntitySet);
bool isCountSegment = odataUri.Path.LastSegment is CountSegment;
return(new OeQueryContext(_edmModel, odataUri, navigationSegments, isCountSegment, pageSize, navigationNextLink, metadataLevel, entitySetAdapter));
}
private static Db.OeEntitySetAdapterCollection CreateEntitySetAdapters(DynamicTypeDefinitionManager typeDefinitionManager)
{
var entitySetAdapters = new Db.OeEntitySetAdapter[typeDefinitionManager.TypeDefinitions.Count];
int i = 0;
foreach (DynamicTypeDefinition typeDefinition in typeDefinitionManager.TypeDefinitions)
{
entitySetAdapters[i++] = CreateEntitySetAdapter(typeDefinition.DynamicTypeType, typeDefinition.TableEdmName, typeDefinition.IsQueryType);
}
return(new Db.OeEntitySetAdapterCollection(entitySetAdapters));
}
protected override Expression VisitConstant(ConstantExpression node)
{
if (node.Type.IsGenericType && (node.Type.GetGenericTypeDefinition() == typeof(IEnumerable <>) || node.Type.GetGenericTypeDefinition() == typeof(IQueryable <>)))
{
Db.OeEntitySetAdapter entitySetAdapter = _entitySetAdapters.FindByClrType(node.Type.GetGenericArguments()[0]);
IQueryable query = entitySetAdapter.GetEntitySet(_dataContext);
return(Expression.Constant(query));
}
return(base.VisitConstant(node));
}
public static ODataResult <T> OData <T>(this HttpContext httpContext, IEnumerable <T> entities)
{
var edmModel = (IEdmModel)httpContext.RequestServices.GetService(typeof(IEdmModel));
var odataUri = new ODataUri()
{
ServiceRoot = UriHelper.GetBaseUri(httpContext.Request)
};
Db.OeEntitySetAdapter entitySetAdapter = GetEntitySetAdapter(edmModel, typeof(T));
IEdmEntitySet entitySet = edmModel.EntityContainer.FindEntitySet(entitySetAdapter.EntitySetName);
return(new ODataResult <T>(edmModel, odataUri, entitySet, entities.ToAsyncEnumerable().GetEnumerator()));
}
public OeQueryContext(IEdmModel edmModel, ODataUri odataUri, Db.OeEntitySetAdapter entitySetAdapter)
{
EdmModel = edmModel;
ODataUri = odataUri;
EntitySetAdapter = entitySetAdapter;
var visitor = new OeQueryNodeVisitor(Expression.Parameter(entitySetAdapter.EntityType));
_joinBuilder = new Translators.OeJoinBuilder(visitor);
MetadataLevel = OeMetadataLevel.Minimal;
ParseNavigationSegments = Array.Empty <OeParseNavigationSegment>();
SkipTokenNameValues = Array.Empty <OeSkipTokenNameValue>();
}
protected virtual Object CreateEntity(ODataResourceBase resource, IReadOnlyList <NavigationInfo> navigationProperties)
{
Db.OeEntitySetAdapter entitySetAdapter = TestHelper.FindEntitySetAdapterByTypeName(EntitySetAdapters, resource.TypeName);
Object entity = CreateEntity(entitySetAdapter.EntityType, resource);
Dictionary <PropertyInfo, NavigationInfo> propertyInfos = null;
foreach (NavigationInfo navigationInfo in navigationProperties)
{
PropertyInfo clrProperty = entitySetAdapter.EntityType.GetProperty(navigationInfo.Name);
Object value = navigationInfo.Value;
if ((navigationInfo.Count == null && navigationInfo.NextPageLink == null))
{
if (clrProperty.GetSetMethod() != null)
{
clrProperty.SetValue(entity, value);
}
}
else
{
if (value == null && navigationInfo.NextPageLink != null)
{
if (navigationInfo.IsCollection)
{
value = CreateCollection(clrProperty.PropertyType);
}
else
{
value = Activator.CreateInstance(clrProperty.PropertyType);
}
}
clrProperty.SetValue(entity, value);
if (value != null)
{
NavigationProperties.Add(value, navigationInfo);
}
if (propertyInfos == null)
{
propertyInfos = new Dictionary <PropertyInfo, NavigationInfo>(navigationProperties.Count);
NavigationInfoEntities.Add(entity, propertyInfos);
}
propertyInfos.Add(clrProperty, navigationInfo);
}
}
return(entity);
}
private ConstantExpression GetQueryConstantExpression(Expression node)
{
if (node.Type.IsGenericType && node.Type.GetGenericTypeDefinition() == typeof(IQueryable <>))
{
Db.OeEntitySetAdapter entitySetAdapter = _entitySetAdapters.FindByClrType(node.Type.GetGenericArguments()[0]);
IQueryable query = entitySetAdapter.GetEntitySet(_dataContext);
if (_query == null && entitySetAdapter.EntityType == typeof(T))
{
_query = (IQueryable <T>)query;
}
return(Expression.Constant(query));
}
return(null);
}
public OeQueryContext CreateQueryContext(ODataUri odataUri, OeMetadataLevel metadataLevel)
{
var importSegment = (OperationImportSegment)odataUri.Path.FirstSegment;
IEdmEntitySet entitySet = OeOperationHelper.GetEntitySet(importSegment.OperationImports.Single());
if (entitySet == null)
return null;
Type clrType = _edmModel.GetClrType(entitySet.EntityType());
OePropertyAccessor[] accessors = OePropertyAccessor.CreateFromType(clrType, entitySet);
Db.OeEntitySetAdapter entitySetAdapter = _dataAdapter.EntitySetAdapters.Find(entitySet);
return new OeQueryContext(_edmModel, odataUri, null, false, 0, false, metadataLevel, entitySetAdapter)
{
EntryFactory = OeEntryFactory.CreateEntryFactory(entitySet, accessors),
};
}
private static Db.OeEntitySetAdapter GetEntitySetAdapter(IEdmModel edmModel, Type entityType)
{
Db.OeDataAdapter dataAdapter = edmModel.GetDataAdapter(edmModel.EntityContainer);
Db.OeEntitySetAdapter entitySetAdapter = dataAdapter.EntitySetAdapters.Find(entityType);
if (entitySetAdapter != null)
{
return(entitySetAdapter);
}
foreach (IEdmModel refModel in edmModel.ReferencedModels)
{
return(GetEntitySetAdapter(refModel, entityType));
}
throw new InvalidOperationException("Entity type " + entityType.FullName + " not found in edm model");
}
public OeQueryContext CreateQueryContext(ODataUri odataUri, int pageSize, bool navigationNextLink, OeMetadataLevel metadataLevel)
{
IReadOnlyList <OeParseNavigationSegment> navigationSegments = OeParseNavigationSegment.GetNavigationSegments(odataUri.Path);
var entitySetSegment = (EntitySetSegment)odataUri.Path.FirstSegment;
if (pageSize > 0)
{
odataUri.Top = pageSize;
IEdmEntitySet resultEntitySet = OeParseNavigationSegment.GetEntitySet(navigationSegments) ?? entitySetSegment.EntitySet;
odataUri.OrderBy = OeSkipTokenParser.GetUniqueOrderBy(_edmModel, resultEntitySet, odataUri.OrderBy, odataUri.Apply);
}
Db.OeEntitySetAdapter entitySetAdapter = _edmModel.GetEntitySetAdapter(entitySetSegment.EntitySet);
bool isCountSegment = odataUri.Path.LastSegment is CountSegment;
return(new OeQueryContext(_edmModel, odataUri, navigationSegments, isCountSegment, pageSize, navigationNextLink, metadataLevel, entitySetAdapter));
}
private static Db.OeEntitySetAdapterCollection CreateEntitySetAdapters(IModel efModel)
{
var entitySetAdapters = new List <Db.OeEntitySetAdapter>();
foreach (PropertyInfo property in typeof(T).GetProperties())
{
if (typeof(IQueryable).IsAssignableFrom(property.PropertyType))
{
Type entityType = property.PropertyType.GetGenericArguments()[0];
bool isDbQuery = efModel.FindEntityType(entityType).FindPrimaryKey() == null;
Db.OeEntitySetAdapter entitySetAdapter = CreateEntitySetAdapter(entityType, property.Name, isDbQuery);
entitySetAdapters.Add(entitySetAdapter);
}
}
return(new Db.OeEntitySetAdapterCollection(entitySetAdapters.ToArray()));
}
public OeQueryContext CreateQueryContext(ODataUri odataUri, OeMetadataLevel metadataLevel)
{
var importSegment = (OperationImportSegment)odataUri.Path.FirstSegment;
IEdmEntitySet entitySet = OeOperationHelper.GetEntitySet(importSegment.OperationImports.Single());
if (entitySet == null)
{
return(null);
}
OePropertyAccessor[] accessors = OePropertyAccessor.CreateFromType(_edmModel.GetClrType(entitySet), entitySet);
Db.OeEntitySetAdapter entitySetAdapter = _dataAdapter.EntitySetAdapters.Find(entitySet);
return(new OeQueryContext(_edmModel, odataUri, entitySetAdapter)
{
EntryFactory = new OeEntryFactory(entitySet, accessors, Array.Empty <OePropertyAccessor>()),
MetadataLevel = metadataLevel
});
}
protected Object CreateEntity(ODataResource resource, IReadOnlyList <NavigationProperty> navigationProperties)
{
Db.OeEntitySetAdapter entitySetAdapter = EntitySetAdapters.FindByTypeName(resource.TypeName);
Object entity = OeEdmClrHelper.CreateEntity(entitySetAdapter.EntityType, resource);
Dictionary <PropertyInfo, ODataResourceSetBase> propertyInfos = null;
foreach (NavigationProperty navigationProperty in navigationProperties)
{
PropertyInfo clrProperty = entitySetAdapter.EntityType.GetProperty(navigationProperty.Name);
Object value = navigationProperty.Value;
if (navigationProperty.ResourceSet == null || (navigationProperty.ResourceSet.Count == null && navigationProperty.ResourceSet.NextPageLink == null))
{
if (clrProperty.GetSetMethod() != null)
{
clrProperty.SetValue(entity, value);
}
continue;
}
if (value == null && navigationProperty.ResourceSet.NextPageLink != null)
{
value = CreateCollection(clrProperty.PropertyType);
}
clrProperty.SetValue(entity, value);
if (value is IEnumerable collection)
{
NavigationProperties.Add(collection, navigationProperty.ResourceSet);
if (propertyInfos == null)
{
propertyInfos = new Dictionary <PropertyInfo, ODataResourceSetBase>(navigationProperties.Count);
NavigationPropertyEntities.Add(entity, propertyInfos);
}
propertyInfos.Add(clrProperty, navigationProperty.ResourceSet);
}
}
return(entity);
}
internal OeQueryContext(IEdmModel edmModel, ODataUri odataUri,
IEdmEntitySet entitySet, IReadOnlyList <OeParseNavigationSegment> parseNavigationSegments,
bool isCountSegment, int pageSize, bool navigationNextLink, bool isDatabaseNullHighestValue,
OeMetadataLevel metadataLevel, ref Db.OeEntitySetAdapter entitySetAdapter)
{
EntitySetAdapter = entitySetAdapter;
EdmModel = edmModel;
ODataUri = odataUri;
EntitySet = entitySet;
ParseNavigationSegments = parseNavigationSegments;
IsCountSegment = isCountSegment;
PageSize = pageSize;
NavigationNextLink = navigationNextLink;
MetadataLevel = metadataLevel;
if (pageSize > 0 || (odataUri.OrderBy != null && odataUri.Skip != null && odataUri.Top != null))
{
IEdmEntityType edmEntityType = OeGetParser.GetEntityType(odataUri.Path, parseNavigationSegments);
SkipTokenParser = new OeSkipTokenParser(edmModel, edmEntityType, isDatabaseNullHighestValue, odataUri.OrderBy);
}
}
private void AddToEntitySet(Object dataContext, OeOperationMessage operation)
{
Db.OeEntitySetAdapter entitySetAdapter = _dataAdapter.GetEntitySetAdapter(operation.EntityItem.EntitySet.Name);
switch (operation.Method)
{
case ODataConstants.MethodDelete:
entitySetAdapter.RemoveEntity(dataContext, operation.EntityItem.Entity);
break;
case ODataConstants.MethodPatch:
entitySetAdapter.AttachEntity(dataContext, operation.EntityItem.Entity);
break;
case ODataConstants.MethodPost:
entitySetAdapter.AddEntity(dataContext, operation.EntityItem.Entity);
break;
default:
throw new NotImplementedException(operation.Method);
}
}
protected IEnumerable Read(Stream response, Db.OeEntitySetAdapter entitySetMetaAdatpter)
{
ResourceSet = null;
NavigationProperties.Clear();
NavigationInfoEntities.Clear();
IODataResponseMessage responseMessage = new Infrastructure.OeInMemoryMessage(response, null, _serviceProvider);
var settings = new ODataMessageReaderSettings()
{
EnableMessageStreamDisposal = false, Validations = ValidationKinds.None
};
using (var messageReader = new ODataMessageReader(responseMessage, settings, EdmModel))
{
IEdmEntitySet entitySet = OeEdmClrHelper.GetEntitySet(EdmModel, entitySetMetaAdatpter.EntitySetName);
ODataReader reader = messageReader.CreateODataResourceSetReader(entitySet, entitySet.EntityType());
var stack = new Stack <StackItem>();
while (reader.Read())
{
switch (reader.State)
{
case ODataReaderState.ResourceSetStart:
if (stack.Count == 0)
{
ResourceSet = (ODataResourceSetBase)reader.Item;
}
else
{
stack.Peek().ResourceSet = (ODataResourceSetBase)reader.Item;
}
break;
case ODataReaderState.ResourceStart:
stack.Push(new StackItem((ODataResource)reader.Item));
break;
case ODataReaderState.ResourceEnd:
StackItem stackItem = stack.Pop();
if (reader.Item != null)
{
if (stack.Count == 0)
{
yield return(CreateRootEntity((ODataResource)stackItem.Item, stackItem.NavigationProperties, entitySetMetaAdatpter.EntityType));
}
else
{
stack.Peek().AddEntry(CreateEntity((ODataResource)stackItem.Item, stackItem.NavigationProperties));
}
}
break;
case ODataReaderState.NestedResourceInfoStart:
stack.Push(new StackItem((ODataNestedResourceInfo)reader.Item));
break;
case ODataReaderState.NestedResourceInfoEnd:
StackItem item = stack.Pop();
stack.Peek().AddLink((ODataNestedResourceInfo)item.Item, item.Value, item.ResourceSet);
break;
}
}
}
}
public IEnumerable <T> Read <T>(Stream response)
{
Db.OeEntitySetAdapter entitySetMetaAdatpter = TestHelper.FindEntitySetAdapterByClrType(EntitySetAdapters, typeof(T));
return(Read(response, entitySetMetaAdatpter).Cast <T>());
}
public EdmModel BuildEdmModel(params IEdmModel[] refModels)
{
AddOperations();
Dictionary <Type, EntityTypeInfo> entityTypeInfos = BuildEntityTypes(refModels);
foreach (EntityTypeInfo typeInfo in entityTypeInfos.Values)
{
if (!typeInfo.IsRefModel)
{
typeInfo.BuildProperties(entityTypeInfos, _enumTypes, _complexTypes);
}
}
foreach (EntityTypeInfo typeInfo in entityTypeInfos.Values)
{
if (!typeInfo.IsRefModel)
{
foreach (FKeyInfo fkeyInfo in typeInfo.NavigationClrProperties)
{
fkeyInfo.BuildNavigationProperty();
}
}
}
var edmModel = new EdmModel(false);
edmModel.AddElements(_enumTypes.Values);
foreach (KeyValuePair <Type, EdmEnumType> enumType in _enumTypes)
{
edmModel.SetClrType(enumType.Value, enumType.Key);
}
edmModel.AddElements(_complexTypes.Values);
foreach (KeyValuePair <Type, EdmComplexType> complexType in _complexTypes)
{
edmModel.SetClrType(complexType.Value, complexType.Key);
}
var container = new EdmEntityContainer(_dataAdapter.DataContextType.Namespace, _dataAdapter.DataContextType.Name);
edmModel.SetDataAdapter(container, _dataAdapter);
var entitySets = new Dictionary <IEdmEntityType, EdmEntitySet>(entityTypeInfos.Count);
foreach (EntityTypeInfo typeInfo in entityTypeInfos.Values)
{
if (!typeInfo.IsRefModel)
{
edmModel.AddElement(typeInfo.EdmType);
edmModel.SetClrType(typeInfo.EdmType, typeInfo.ClrType);
}
Db.OeEntitySetAdapter entitySetAdapter = _dataAdapter.EntitySetAdapters.Find(typeInfo.ClrType);
if (entitySetAdapter != null)
{
EdmEntitySet entitySet = container.AddEntitySet(entitySetAdapter.EntitySetName, typeInfo.EdmType);
edmModel.SetEntitySetAdapter(entitySet, entitySetAdapter);
entitySets.Add(typeInfo.EdmType, entitySet);
}
}
var manyToManyBuilder = new ManyToManyBuilder(edmModel, _metadataProvider, entityTypeInfos);
foreach (EntityTypeInfo typeInfo in entityTypeInfos.Values)
{
if (!typeInfo.IsRefModel)
{
foreach (FKeyInfo fkeyInfo in typeInfo.NavigationClrProperties)
{
EdmEntitySet principal = entitySets[fkeyInfo.PrincipalInfo.EdmType];
EdmEntitySet dependent = entitySets[fkeyInfo.DependentInfo.EdmType];
if (fkeyInfo.DependentNavigationProperty == null)
{
principal.AddNavigationTarget(fkeyInfo.EdmNavigationProperty, dependent);
}
else
{
dependent.AddNavigationTarget(fkeyInfo.EdmNavigationProperty, principal);
if (fkeyInfo.EdmNavigationProperty.Partner != null)
{
principal.AddNavigationTarget(fkeyInfo.EdmNavigationProperty.Partner, dependent);
}
}
}
manyToManyBuilder.Build(typeInfo);
}
}
foreach (OeOperationConfiguration operationConfiguration in _operationConfigurations)
{
if (operationConfiguration.IsEdmFunction)
{
EdmFunction edmFunction = BuildFunction(operationConfiguration, entityTypeInfos);
edmModel.AddElement(edmFunction);
if (edmFunction.IsBound)
{
edmModel.SetMethodInfo(edmFunction, operationConfiguration.MethodInfo);
}
else
{
container.AddFunctionImport(operationConfiguration.ImportName, edmFunction, edmFunction.EntitySetPath);
edmModel.SetIsDbFunction(edmFunction, operationConfiguration.IsDbFunction);
}
}
else
{
EdmAction edmAction = BuildAction(operationConfiguration, entityTypeInfos);
edmModel.AddElement(edmAction);
container.AddActionImport(operationConfiguration.ImportName, edmAction);
edmModel.SetIsDbFunction(edmAction, operationConfiguration.IsDbFunction);
}
}
edmModel.AddElement(container);
_dataAdapter.SetEdmModel(edmModel);
foreach (IEdmModel refModel in refModels)
{
edmModel.AddReferencedModel(refModel);
}
return(edmModel);
}
protected override IAsyncEnumerable <Object> ExecuteReader(Object dataContext, String sql, IReadOnlyList <KeyValuePair <String, Object?> > parameters,
Db.OeEntitySetAdapter entitySetAdapter)
{
throw new NotSupportedException();
}
