示例#1
0
        private IEdmEntitySet GetEntitySet(GraphQLFieldSelection selection)
        {
            var  listGraphType = (ListGraphType)_schema.Query.Fields.Single(f => f.Name == selection.Name.Value).ResolvedType;
            Type entityType    = listGraphType.ResolvedType.GetType().GetGenericArguments()[0];

            return(OeEdmClrHelper.GetEntitySet(_edmModel, entityType));
        }
示例#2
0
        public override void AttachEntity(Object dataContext, ODataResourceBase entry)
        {
            var dbContext = (DbContext)dataContext;
            InternalEntityEntry internalEntry = GetEntityEntry(dbContext, entry);

            if (internalEntry == null)
            {
                Object      entity      = CreateEntity(dbContext, entry);
                EntityEntry entityEntry = dbContext.Attach(entity);
                AddInstanceAnnotation(entry, entityEntry);

                IReadOnlyList <IProperty> keyProperties = _entityType.FindPrimaryKey().Properties;
                foreach (ODataProperty odataProperty in entry.Properties)
                {
                    IProperty property = _entityType.FindProperty(odataProperty.Name);
                    if (!keyProperties.Contains(property))
                    {
                        entityEntry.Property(property.Name).IsModified = true;
                    }
                }
            }
            else
            {
                foreach (ODataProperty odataProperty in entry.Properties)
                {
                    IProperty property = _entityType.FindProperty(odataProperty.Name);
                    Object    value    = OeEdmClrHelper.GetClrValue(property.ClrType, odataProperty.Value);
                    internalEntry.SetProperty(property, value, false);
                }
            }
        }
            public override void AttachEntity(Object dataContext, ODataResourceBase entry)
            {
                var context = (T)dataContext;
                InternalEntityEntry internalEntry = GetEntityEntry(context, entry);

                if (internalEntry == null)
                {
                    TEntity entity = CreateEntity(context, entry);
                    _getEntitySet(context).Attach(entity);
                    internalEntry = _getEntitySet(context).Attach(entity).GetInfrastructure();

                    IKey key = _entityType.FindPrimaryKey();
                    foreach (ODataProperty odataProperty in entry.Properties)
                    {
                        IProperty property = _entityType.FindProperty(odataProperty.Name);
                        if (!key.Properties.Contains(property))
                        {
                            internalEntry.SetPropertyModified(property);
                        }
                    }
                }
                else
                {
                    foreach (ODataProperty odataProperty in entry.Properties)
                    {
                        IProperty property = _entityType.FindProperty(odataProperty.Name);
                        Object    value    = OeEdmClrHelper.GetClrValue(property.ClrType, odataProperty.Value);
                        internalEntry.SetProperty(property, value);
                    }
                }
            }
示例#4
0
        private void Translate(OeNavigationSelectItem parentNavigationItem, ExpandedNavigationSelectItem item)
        {
            IEdmEntitySetBase entitySet = OeEdmClrHelper.GetEntitySet(_edmModel, item);

            OeNavigationSelectItemKind kind;

            if (_notSelected)
            {
                kind = OeNavigationSelectItemKind.NotSelected;
            }
            else if (item.SelectAndExpand.IsNextLink())
            {
                kind = OeNavigationSelectItemKind.NextLink;
            }
            else
            {
                kind = OeNavigationSelectItemKind.Normal;
            }

            var childNavigationSelectItem = new OeNavigationSelectItem(entitySet, parentNavigationItem, item, kind);

            childNavigationSelectItem = parentNavigationItem.AddOrGetNavigationItem(childNavigationSelectItem);
            if (childNavigationSelectItem.Kind == OeNavigationSelectItemKind.NextLink)
            {
                return;
            }

            foreach (SelectItem selectItemClause in item.SelectAndExpand.SelectedItems)
            {
                Translate(childNavigationSelectItem, selectItemClause);
            }
        }
示例#5
0
        public MethodCallExpression Build(Expression outer, Expression inner, ODataPath odataPath, OrderByClause orderBy, long?skip, long?top)
        {
            var segment = (NavigationPropertySegment)odataPath.LastSegment;
            IEdmNavigationProperty navigationProperty = segment.NavigationProperty;

            if (navigationProperty.ContainsTarget)
            {
                ModelBuilder.ManyToManyJoinDescription joinDescription = _edmModel.GetManyToManyJoinDescription(navigationProperty);
                IEdmEntitySet joinEntitySet = OeEdmClrHelper.GetEntitySet(_edmModel, joinDescription.JoinNavigationProperty);
                outer = OeEnumerableStub.CreateEnumerableStubExpression(joinDescription.JoinClassType, joinEntitySet);
                navigationProperty = joinDescription.TargetNavigationProperty;
            }

            Type outerType = OeExpressionHelper.GetCollectionItemType(outer.Type);
            ParameterExpression outerParameter = Expression.Parameter(outerType, outerType.Name);

            inner = new ReplaceParameterVisitor(outerParameter).Visit(inner); //replace $it
            Expression subquery = CreateWhereExpression(outerParameter, inner, navigationProperty);

            subquery = _expressionBuilder.ApplyOrderBy(subquery, orderBy);
            subquery = _expressionBuilder.ApplySkip(subquery, skip, odataPath);
            subquery = _expressionBuilder.ApplyTake(subquery, top, odataPath);

            Type       innerType            = OeExpressionHelper.GetCollectionItemType(inner.Type);
            MethodInfo selectManyMethdoInfo = OeMethodInfoHelper.GetSelectManyMethodInfo(outerType, innerType);

            return(Expression.Call(selectManyMethdoInfo, outer, Expression.Lambda(subquery, outerParameter)));
        }
示例#6
0
        public static async Task WriteCollectionAsync(IEdmModel edmModel, ODataUri odataUri, IAsyncEnumerator <Object> asyncEnumerator, Stream responseStream)
        {
            var importSegment = (OperationImportSegment)odataUri.Path.LastSegment;
            IEdmOperationImport operationImport = importSegment.OperationImports.Single();
            Type returnType = edmModel.GetClrType(operationImport.Operation.ReturnType.Definition);

            IODataRequestMessage requestMessage = new Infrastructure.OeInMemoryMessage(responseStream, null);

            using (ODataMessageWriter messageWriter = new ODataMessageWriter(requestMessage,
                                                                             new ODataMessageWriterSettings()
            {
                EnableMessageStreamDisposal = false, ODataUri = odataUri
            }, edmModel))
            {
                IEdmTypeReference     typeRef = OeEdmClrHelper.GetEdmTypeReference(edmModel, returnType);
                ODataCollectionWriter writer  = await messageWriter.CreateODataCollectionWriterAsync(typeRef).ConfigureAwait(false);

                await writer.WriteStartAsync(new ODataCollectionStart()).ConfigureAwait(false);

                while (await asyncEnumerator.MoveNextAsync().ConfigureAwait(false))
                {
                    Object value = asyncEnumerator.Current;
                    if (value != null && value.GetType().IsEnum)
                    {
                        value = value.ToString();
                    }

                    await writer.WriteItemAsync(value).ConfigureAwait(false);
                }

                await writer.WriteEndAsync().ConfigureAwait(false);
            }
        }
示例#7
0
        private static OeSkipTokenNameValue[] ParseJson(IEdmModel model, String skipToken, IEdmStructuralProperty[] keys)
        {
            var skipTokenNameValues = new OeSkipTokenNameValue[keys.Length];

            using (var stream = new MemoryStream(Encoding.UTF8.GetBytes(skipToken)))
            {
                IODataRequestMessage requestMessage = new OeInMemoryMessage(stream, null);
                using (ODataMessageReader messageReader = new ODataMessageReader(requestMessage, ReaderSettings, model))
                {
                    var operation = new EdmAction("", "", null);
                    foreach (IEdmStructuralProperty key in keys)
                    {
                        operation.AddParameter(GetPropertyName(key), key.Type);
                    }

                    ODataParameterReader reader = messageReader.CreateODataParameterReader(operation);
                    int i = 0;
                    while (reader.Read())
                    {
                        Object value = reader.Value;
                        if (value is ODataEnumValue enumValue)
                        {
                            value = OeEdmClrHelper.GetValue(model, enumValue);
                        }
                        skipTokenNameValues[i++] = new OeSkipTokenNameValue(reader.Name, value);
                    }
                }
            }
            return(skipTokenNameValues);
        }
        public MethodCallExpression Build(IEdmModel edmModel, Expression outerSource, Expression innerSource,
                                          IReadOnlyList <IEdmNavigationProperty> joinPath, IEdmNavigationProperty navigationProperty)
        {
            if (navigationProperty.ContainsTarget)
            {
                ModelBuilder.ManyToManyJoinDescription joinDescription = edmModel.GetManyToManyJoinDescription(navigationProperty);
                IEdmEntitySet joinEntitySet = OeEdmClrHelper.GetEntitySet(edmModel, joinDescription.JoinNavigationProperty);
                Expression    joinSource    = OeEnumerableStub.CreateEnumerableStubExpression(joinDescription.JoinClassType, joinEntitySet);

                outerSource = Build(outerSource, joinSource, joinPath, joinDescription.JoinNavigationProperty, false);
                AddJoinPath(joinPath, joinDescription.JoinNavigationProperty);

                var fixedJoinPath = new IEdmNavigationProperty[joinPath.Count + 1];
                for (int i = 0; i < joinPath.Count; i++)
                {
                    fixedJoinPath[i] = joinPath[i];
                }
                fixedJoinPath[fixedJoinPath.Length - 1] = joinDescription.JoinNavigationProperty;

                outerSource = Build(outerSource, innerSource, fixedJoinPath, joinDescription.TargetNavigationProperty, true);
                _joinPaths.RemoveAt(_joinPaths.Count - 1);
            }
            else
            {
                outerSource = Build(outerSource, innerSource, joinPath, navigationProperty, false);
            }

            AddJoinPath(joinPath, navigationProperty);
            return((MethodCallExpression)outerSource);
        }
        private MethodCallExpression?GetJoin(Expression outer, MemberExpression navigationProperty)
        {
            Type outerType = outer.Type;
            Type innerType = navigationProperty.Type;

            IEdmModel?edmModel = _edmModel.GetEdmModel(outerType);

            if (edmModel == null)
            {
                return(null);
            }

            Db.OeDataAdapter dataAdapter = edmModel.GetDataAdapter(edmModel.EntityContainer);

            Db.OeEntitySetAdapter?outerEntitySetAdapter = dataAdapter.EntitySetAdapters.Find(outerType);
            if (outerEntitySetAdapter == null)
            {
                throw new InvalidOperationException("OeEntitySetAdapter not found for type " + outerType.Name);
            }

            IEdmEntitySet          outerEntitySet        = OeEdmClrHelper.GetEntitySet(_edmModel, outerEntitySetAdapter.EntitySetName);
            IEdmNavigationProperty edmNavigationProperty = outerEntitySet.EntityType().NavigationProperties().Single(p => p.Name == navigationProperty.Member.Name);

            Db.OeEntitySetAdapter?innerEntitySetAdapter = dataAdapter.EntitySetAdapters.Find(innerType);
            if (innerEntitySetAdapter == null)
            {
                throw new InvalidOperationException("OeEntitySetAdapter not found for type " + innerType.Name);
            }

            IEdmEntitySet      entitySet   = edmModel.FindDeclaredEntitySet(innerEntitySetAdapter.EntitySetName);
            ConstantExpression innerSource = OeEnumerableStub.CreateEnumerableStubExpression(innerType, entitySet);

            return(GetJoin(outer, innerSource, edmNavigationProperty));
        }
示例#10
0
            public override void RemoveEntity(Object dataContext, ODataResourceBase entry)
            {
                var context = (T)dataContext;

                InitKey(context);

                ObjectContext objectContext = ((IObjectContextAdapter)context).ObjectContext;
                var           entity        = (TEntity)OeEdmClrHelper.CreateEntity(EntityType, entry);
                EntityKey     entityKey     = objectContext.CreateEntityKey(EntitySetName, entity);

                if (objectContext.ObjectStateManager.TryGetObjectStateEntry(entityKey, out ObjectStateEntry objectStateEntry))
                {
                    objectStateEntry.ChangeState(EntityState.Deleted);
                }
                else
                {
                    if (_isCascade && !_isSelfReference)
                    {
                        context.Entry(entity).State = EntityState.Deleted;
                    }
                    else
                    {
                        var keyValues = new Object[entityKey.EntityKeyValues.Length];
                        for (int i = 0; i < keyValues.Length; i++)
                        {
                            keyValues[i] = entityKey.EntityKeyValues[i].Value;
                        }

                        IDbSet <TEntity> dbSet = _getEntitySet(context);
                        context.Entry(dbSet.Find(keyValues)).State = EntityState.Deleted;
                    }
                }
            }
示例#11
0
        public override void AddEntity(Object dataContext, ODataResourceBase entry)
        {
            var entity = (TEntity)OeEdmClrHelper.CreateEntity(EntityType, entry);

            AddInstanceAnnotation(entry, entity);
            GetTable(dataContext).Insert(entity);
        }
        public static IEnumerable <KeyValuePair <String, Object> > ParseJson(IEdmModel model, String skipToken, IEnumerable <IEdmStructuralProperty> keys)
        {
            using (var stream = new MemoryStream(Encoding.UTF8.GetBytes(skipToken)))
            {
                IODataRequestMessage requestMessage = new OeInMemoryMessage(stream, null);
                using (ODataMessageReader messageReader = new ODataMessageReader(requestMessage, ReaderSettings, model))
                {
                    var operation = new EdmAction("", "", null);
                    foreach (IEdmStructuralProperty key in keys)
                    {
                        operation.AddParameter(GetPropertyName(key), key.Type);
                    }

                    ODataParameterReader reader = messageReader.CreateODataParameterReader(operation);
                    while (reader.Read())
                    {
                        Object value = reader.Value;
                        if (value is ODataEnumValue enumValue)
                        {
                            value = OeEdmClrHelper.GetValue(model, enumValue);
                        }
                        yield return(new KeyValuePair <String, Object>(reader.Name, value));
                    }
                }
            }
        }
示例#13
0
            public override void AttachEntity(Object dataContext, ODataResourceBase entry)
            {
                var           entity        = (TEntity)OeEdmClrHelper.CreateEntity(EntityType, entry);
                ObjectContext objectContext = ((IObjectContextAdapter)dataContext).ObjectContext;
                EntityKey     entityKey     = objectContext.CreateEntityKey(EntitySetName, entity);

                if (objectContext.ObjectStateManager.TryGetObjectStateEntry(entityKey, out ObjectStateEntry objectStateEntry))
                {
                    foreach (ODataProperty odataProperty in entry.Properties)
                    {
                        if (Array.Find(objectStateEntry.EntityKey.EntityKeyValues, k => k.Key == odataProperty.Name) == null)
                        {
                            int i = objectStateEntry.CurrentValues.GetOrdinal(odataProperty.Name);
                            objectStateEntry.CurrentValues.SetValue(i, odataProperty.Value);
                        }
                    }
                }
                else
                {
                    var context = (T)dataContext;
                    _getEntitySet(context).Attach(entity);
                    objectContext.ObjectStateManager.TryGetObjectStateEntry(entityKey, out objectStateEntry);

                    foreach (ODataProperty odataProperty in entry.Properties)
                    {
                        if (Array.Find(objectStateEntry.EntityKey.EntityKeyValues, k => k.Key == odataProperty.Name) == null)
                        {
                            objectStateEntry.SetModifiedProperty(odataProperty.Name);
                        }
                    }
                }
            }
示例#14
0
        private static ClrTableTypeEdmSet[] GetOrderedTableTypes(IEdmModel edmModel, OeEntitySetAdapterCollection entitySetAdapters)
        {
            var clrTypeEdmSetList = new List <ClrTableTypeEdmSet>();

            foreach (OeEntitySetAdapter entitySetAdapter in entitySetAdapters)
            {
                IEdmEntitySet entitySet = OeEdmClrHelper.GetEntitySet(edmModel, entitySetAdapter.EntitySetName);
                clrTypeEdmSetList.Add(new ClrTableTypeEdmSet(entitySetAdapter.EntityType, entitySet));
            }

            var orderedTableTypeList = new List <ClrTableTypeEdmSet>();

            while (clrTypeEdmSetList.Count > 0)
            {
                for (int i = 0; i < clrTypeEdmSetList.Count; i++)
                {
                    if (IsDependent(clrTypeEdmSetList[i], clrTypeEdmSetList, out PropertyInfo selfRefProperty))
                    {
                        Type linq2DbTableType = typeof(OeLinq2DbTable <>).MakeGenericType(clrTypeEdmSetList[i].ClrTableType);
                        if (selfRefProperty != null)
                        {
                            linq2DbTableType.GetProperty(nameof(OeLinq2DbTable <Object> .SelfRefProperty)).SetValue(null, selfRefProperty);
                        }

                        orderedTableTypeList.Add(clrTypeEdmSetList[i]);
                        clrTypeEdmSetList.RemoveAt(i);
                        break;
                    }
                }
            }
            return(orderedTableTypeList.ToArray());
        }
示例#15
0
        private Expression GetInnerSource(OeSelectItem navigationItem, ExpandedNavigationSelectItem item)
        {
            Type         clrEntityType         = _visitor.EdmModel.GetClrType(navigationItem.EdmProperty.DeclaringType);
            PropertyInfo navigationClrProperty = OeEdmClrHelper.GetPropertyIgnoreCase(clrEntityType, navigationItem.EdmProperty);

            Type itemType = OeExpressionHelper.GetCollectionItemType(navigationClrProperty.PropertyType);

            if (itemType == null)
            {
                itemType = navigationClrProperty.PropertyType;
            }

            var visitor           = new OeQueryNodeVisitor(_visitor, Expression.Parameter(itemType));
            var expressionBuilder = new OeExpressionBuilder(_joinBuilder, visitor);

            Expression innerSource = Expression.Constant(null, typeof(IEnumerable <>).MakeGenericType(itemType));

            innerSource = expressionBuilder.ApplyFilter(innerSource, item.FilterOption);
            if (item.SkipOption != null || item.TopOption != null)
            {
                Expression source = Expression.Constant(null, typeof(IEnumerable <>).MakeGenericType(navigationClrProperty.DeclaringType));
                innerSource = OeCrossApplyBuilder.Build(source, innerSource, item, navigationItem.Path, expressionBuilder);
            }

            return(innerSource);
        }
示例#16
0
        private MethodCallExpression CreateSelectExpression(Expression source, OeJoinBuilder joinBuilder)
        {
            if (_navigationItem.HasNavigationItems)
            {
                return((MethodCallExpression)source);
            }

            if (_navigationItem.SelectItems.Count == 0)
            {
                return((MethodCallExpression)source);
            }

            var expressions = new List <Expression>(_navigationItem.SelectItems.Count);

            for (int i = 0; i < _navigationItem.SelectItems.Count; i++)
            {
                IEdmProperty edmProperty = _navigationItem.SelectItems[i].EdmProperty;
                PropertyInfo clrProperty = OeEdmClrHelper.GetPropertyIgnoreCase(_visitor.Parameter.Type, edmProperty);
                expressions.Add(Expression.MakeMemberAccess(_visitor.Parameter, clrProperty));
            }
            NewExpression newTupleExpression = OeExpressionHelper.CreateTupleExpression(expressions);

            LambdaExpression lambda           = Expression.Lambda(newTupleExpression, _visitor.Parameter);
            MethodInfo       selectMethodInfo = OeMethodInfoHelper.GetSelectMethodInfo(_visitor.Parameter.Type, newTupleExpression.Type);

            return(Expression.Call(selectMethodInfo, source, lambda));
        }
示例#17
0
        private Expression GetInnerSource(OeSelectItem navigationItem, ExpandedNavigationSelectItem item)
        {
            Type         clrEntityType         = _visitor.EdmModel.GetClrType(navigationItem.EdmProperty.DeclaringType);
            PropertyInfo navigationClrProperty = clrEntityType.GetPropertyIgnoreCase(navigationItem.EdmProperty);

            Type itemType = OeExpressionHelper.GetCollectionItemType(navigationClrProperty.PropertyType);

            if (itemType == null)
            {
                itemType = navigationClrProperty.PropertyType;
            }

            var visitor           = new OeQueryNodeVisitor(_visitor, Expression.Parameter(itemType));
            var expressionBuilder = new OeExpressionBuilder(_joinBuilder, visitor);

            var navigationEdmProperty = (IEdmNavigationProperty)navigationItem.EdmProperty;

            if (navigationEdmProperty.ContainsTarget)
            {
                ModelBuilder.ManyToManyJoinDescription joinDescription = _visitor.EdmModel.GetManyToManyJoinDescription(navigationEdmProperty);
                navigationEdmProperty = joinDescription.TargetNavigationProperty;
            }
            IEdmEntitySet innerEntitySet = OeEdmClrHelper.GetEntitySet(_visitor.EdmModel, navigationEdmProperty);
            Expression    innerSource    = OeEnumerableStub.CreateEnumerableStubExpression(itemType, innerEntitySet);

            innerSource = expressionBuilder.ApplyFilter(innerSource, item.FilterOption);
            if (item.SkipOption != null || item.TopOption != null)
            {
                Expression source = OeEnumerableStub.CreateEnumerableStubExpression(navigationClrProperty.DeclaringType, (IEdmEntitySet)_navigationItem.EntitySet);
                innerSource = OeCrossApplyBuilder.Build(source, innerSource, item, navigationItem.Path, expressionBuilder);
            }

            return(innerSource);
        }
示例#18
0
        public async Task ExecuteResultAsync(ActionContext context)
        {
            var settings = new ODataMessageWriterSettings()
            {
                BaseUri = _odataUri.ServiceRoot,
                EnableMessageStreamDisposal = false,
                ODataUri    = _odataUri,
                Validations = ValidationKinds.ThrowIfTypeConflictsWithMetadata | ValidationKinds.ThrowOnDuplicatePropertyNames,
                Version     = ODataVersion.V4
            };

            var requestHeaders = OeRequestHeaders.Parse(context.HttpContext.Request.Headers["Accept"], context.HttpContext.Request.Headers["Prefer"]);

            _metadataLevel = requestHeaders.MetadataLevel;
            if (requestHeaders.MaxPageSize > 0 && PageSize == 0)
            {
                PageSize = requestHeaders.MaxPageSize;
            }

            IODataResponseMessage responseMessage = new OeInMemoryMessage(context.HttpContext.Response.Body, context.HttpContext.Request.ContentType);

            using (ODataMessageWriter messageWriter = new ODataMessageWriter(responseMessage, settings, _edmModel))
            {
                ODataUtils.SetHeadersForPayload(messageWriter, ODataPayloadKind.ResourceSet);

                IEdmEntitySet  edmEntitySet  = OeEdmClrHelper.GetEntitySet(_edmModel, typeof(T));
                IEdmEntityType edmEntityType = edmEntitySet.EntityType();
                ODataWriter    writer        = messageWriter.CreateODataResourceSetWriter(edmEntitySet, edmEntityType);
                await SerializeAsync(writer);
            }
        }
示例#19
0
        public static Db.OeBoundFunctionParameter CreateBoundFunctionParameter(OeQueryContext queryContext)
        {
            var expressionBuilder = new OeExpressionBuilder(queryContext.JoinBuilder);

            Type          sourceEntityType = queryContext.EntitySetAdapter.EntityType;
            IEdmEntitySet sourceEntitySet  = OeEdmClrHelper.GetEntitySet(queryContext.EdmModel, queryContext.EntitySetAdapter.EntitySetName);
            Expression    source           = OeEnumerableStub.CreateEnumerableStubExpression(sourceEntityType, sourceEntitySet);

            source = expressionBuilder.ApplyNavigation(source, queryContext.ParseNavigationSegments);

            IEdmEntitySet targetEntitySet = OeOperationHelper.GetEntitySet(queryContext.ODataUri.Path);

            if (sourceEntitySet != targetEntitySet)
            {
                queryContext.ODataUri.Path = new ODataPath(new EntitySetSegment(targetEntitySet));
            }

            expressionBuilder = new OeExpressionBuilder(queryContext.JoinBuilder);
            Type       targetEntityType = queryContext.EdmModel.GetClrType(targetEntitySet.EntityType());
            Expression target           = OeEnumerableStub.CreateEnumerableStubExpression(targetEntityType, targetEntitySet);

            target = expressionBuilder.ApplySelect(target, queryContext);

            var sourceQueryExpression = new OeQueryExpression(queryContext.EdmModel, sourceEntitySet, source);
            var targetQueryExpression = new OeQueryExpression(queryContext.EdmModel, targetEntitySet, target)
            {
                EntryFactory = expressionBuilder.CreateEntryFactory(targetEntitySet)
            };

            Type            boundFunctionParameterType = typeof(Db.OeBoundFunctionParameter <,>).MakeGenericType(new[] { sourceEntityType, targetEntityType });
            ConstructorInfo ctor = boundFunctionParameterType.GetConstructor(new[] { typeof(OeQueryExpression), typeof(OeQueryExpression) });

            return((Db.OeBoundFunctionParameter)ctor.Invoke(new Object[] { sourceQueryExpression, targetQueryExpression }));
        }
示例#20
0
            public override void AddEntity(Object dataContext, ODataResourceBase entry)
            {
                IDbSet <TEntity> dbSet = _getEntitySet((T)dataContext);
                var entity             = (TEntity)OeEdmClrHelper.CreateEntity(EntityType, entry);

                dbSet.Add(entity);
            }
示例#21
0
 private void BuildCompute(ComputeClause computeClause)
 {
     foreach (ComputeExpression computeExpression in computeClause.ComputedItems)
     {
         Expression        expression       = _visitor.TranslateNode(computeExpression.Expression);
         IEdmTypeReference edmTypeReference = OeEdmClrHelper.GetEdmTypeReference(_visitor.EdmModel, expression.Type);
         _navigationItem.AddSelectItem(new OeSelectItem(new ComputeProperty(computeExpression.Alias, edmTypeReference, expression), false));
     }
 }
示例#22
0
 private void BuildCompute(ComputeClause computeClause)
 {
     foreach (ComputeExpression computeExpression in computeClause.ComputedItems)
     {
         Expression        expression       = _visitor.TranslateNode(computeExpression.Expression);
         IEdmTypeReference edmTypeReference = OeEdmClrHelper.GetEdmTypeReference(_model, expression.Type);
         _selectItemInfos.Add(new SelectItemInfo(new ComputeProperty(computeExpression.Alias, edmTypeReference), expression));
     }
 }
示例#23
0
        public override IEnumerable <String> GetPrimaryKey(String tableName)
        {
            IEdmEntityType edmEntityType = OeEdmClrHelper.GetEntitySet(_edmModel, tableName).EntityType();

            foreach (IEdmStructuralProperty structuralProperty in edmEntityType.Key())
            {
                yield return(structuralProperty.Name);
            }
        }
示例#24
0
        private static void FillParameters(IEdmModel edmModel, List <KeyValuePair <String, Object> > parameters, Stream requestStream, IEdmOperation operation, String contentType)
        {
            if (!operation.Parameters.Any())
            {
                return;
            }

            IODataRequestMessage requestMessage = new Infrastructure.OeInMemoryMessage(requestStream, contentType);
            var settings = new ODataMessageReaderSettings()
            {
                EnableMessageStreamDisposal = false
            };

            using (var messageReader = new ODataMessageReader(requestMessage, settings, edmModel))
            {
                ODataParameterReader parameterReader = messageReader.CreateODataParameterReader(operation);
                while (parameterReader.Read())
                {
                    Object value;
                    switch (parameterReader.State)
                    {
                    case ODataParameterReaderState.Value:
                    {
                        value = OeEdmClrHelper.GetValue(edmModel, parameterReader.Value);
                        break;
                    }

                    case ODataParameterReaderState.Collection:
                    {
                        ODataCollectionReader collectionReader = parameterReader.CreateCollectionReader();
                        value = OeEdmClrHelper.GetValue(edmModel, ReadCollection(collectionReader));
                        break;
                    }

                    case ODataParameterReaderState.Resource:
                    {
                        ODataReader reader = parameterReader.CreateResourceReader();
                        value = OeEdmClrHelper.GetValue(edmModel, ReadResource(reader));
                        break;
                    }

                    case ODataParameterReaderState.ResourceSet:
                    {
                        ODataReader reader = parameterReader.CreateResourceSetReader();
                        value = OeEdmClrHelper.GetValue(edmModel, ReadResourceSet(reader));
                        break;
                    }

                    default:
                        continue;
                    }

                    parameters.Add(new KeyValuePair <String, Object>(parameterReader.Name, value));
                }
            }
        }
示例#25
0
        private OeEntryFactory CreateEntryFactory(OeExpressionBuilder expressionBuilder)
        {
            IEdmEntitySet entitySet = OeParseNavigationSegment.GetEntitySet(ParseNavigationSegments);

            if (entitySet == null)
            {
                entitySet = OeEdmClrHelper.GetEntitySet(EdmModel, EntitySetAdapter.EntitySetName);
            }
            return(expressionBuilder.CreateEntryFactory(entitySet));
        }
        public override Task <int> SaveChangesAsync(Object dataContext, CancellationToken cancellationToken)
        {
            foreach (InMemoryEntitySetAdapter entitySetAdapter in base.EntitySetAdapters)
            {
                if (!entitySetAdapter.IsDbQuery)
                {
                    foreach (PropertyInfo key in ModelBuilder.OeModelBuilderHelper.GetKeyProperties(entitySetAdapter.EntityType))
                    {
                        if (key.PropertyType == typeof(int))
                        {
                            foreach (Object entity in entitySetAdapter.GetSource(dataContext))
                            {
                                var id = (int)key.GetValue(entity);
                                if (id < 0)
                                {
                                    key.SetValue(entity, -id);
                                }
                            }
                        }
                    }

                    IEdmEntityType entityType = OeEdmClrHelper.GetEntitySet(_edmModel, entitySetAdapter.EntitySetName).EntityType();
                    foreach (IEdmNavigationProperty navigationProperty in entityType.NavigationProperties())
                    {
                        IEnumerable <IEdmStructuralProperty> edmProperties = navigationProperty.DependentProperties();
                        if (edmProperties != null)
                        {
                            foreach (IEdmStructuralProperty edmProperty in edmProperties)
                            {
                                if (edmProperty.DeclaringType != entityType)
                                {
                                    break;
                                }

                                PropertyInfo clrProperty = entitySetAdapter.EntityType.GetProperty(edmProperty.Name) !;
                                if (clrProperty.PropertyType == typeof(int) || clrProperty.PropertyType == typeof(int?))
                                {
                                    foreach (Object entity in entitySetAdapter.GetSource(dataContext))
                                    {
                                        var id = (int?)clrProperty.GetValue(entity);
                                        if (id < 0)
                                        {
                                            clrProperty.SetValue(entity, -id);
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            }

            return(base.SaveChangesAsync(dataContext, cancellationToken));
        }
示例#27
0
        public static IReadOnlyList <KeyValuePair <String, Object?> > GetParameters(IEdmModel edmModel, ODataPathSegment segment,
                                                                                    IDictionary <string, SingleValueNode> parameterAliasNodes, Stream?requestStream = null, String?contentType = null)
        {
            var parameters = new List <KeyValuePair <String, Object?> >();

            IEdmOperation operation;
            IEnumerable <OperationSegmentParameter> segmentParameters;

            if (segment is OperationSegment operationSegment)
            {
                segmentParameters = operationSegment.Parameters;
                operation         = operationSegment.Operations.Single();
            }
            else if (segment is OperationImportSegment operationImportSegment)
            {
                segmentParameters = operationImportSegment.Parameters;
                operation         = (EdmOperation)operationImportSegment.OperationImports.Single().Operation;
            }
            else
            {
                throw new InvalidOperationException("Not supported segment type " + segment.GetType().Name);
            }

            foreach (OperationSegmentParameter segmentParameter in segmentParameters)
            {
                Object?value;
                if (segmentParameter.Value is ConstantNode constantNode)
                {
                    value = OeEdmClrHelper.GetValue(edmModel, constantNode.Value);
                }
                else if (segmentParameter.Value is ConvertNode convertNode)
                {
                    value = OeEdmClrHelper.GetValue(edmModel, ((ConstantNode)convertNode.Source).Value);
                }
                else if (segmentParameter.Value is ParameterAliasNode parameterAliasNode)
                {
                    value = OeEdmClrHelper.GetValue(edmModel, ((ConstantNode)parameterAliasNodes[parameterAliasNode.Alias]).Value);
                }
                else
                {
                    value = OeEdmClrHelper.GetValue(edmModel, segmentParameter.Value);
                }

                parameters.Add(new KeyValuePair <String, Object?>(segmentParameter.Name, value));
            }

            if (parameters.Count == 0 && requestStream != null)
            {
                FillParameters(edmModel, parameters, requestStream, operation, contentType);
            }
            OrderParameters(operation.Parameters, parameters);

            return(parameters);
        }
示例#28
0
        private OeEntryFactory CreateEntryFactory(OeExpressionBuilder expressionBuilder, OePropertyAccessor[] skipTokenAccessors)
        {
            IEdmEntitySet?entitySet = OeParseNavigationSegment.GetEntitySet(ParseNavigationSegments);

            if (entitySet == null)
            {
                entitySet = OeEdmClrHelper.GetEntitySet(EdmModel, EntitySetAdapter.EntitySetName);
            }

            return(expressionBuilder.CreateEntryFactory(entitySet, skipTokenAccessors));
        }
示例#29
0
        private OeEntryFactory CreateEntryFactory(OeExpressionBuilder expressionBuilder)
        {
            IEdmEntitySet entitySet = EntitySet;

            if (expressionBuilder.EntityType != EntitySetAdapter.EntityType)
            {
                entitySet = OeEdmClrHelper.GetEntitySet(EdmModel, expressionBuilder.EntityType);
            }

            return(expressionBuilder.CreateEntryFactory(entitySet));
        }
        public EntitySetConfiguration <TEntityType> EntitySet <TEntityType>(String entitySetName) where TEntityType : class
        {
            IEdmEntitySet entitySet = OeEdmClrHelper.GetEntitySet(EdmModel, entitySetName);

            if (entitySet == null)
            {
                throw new InvalidOperationException("EntitySet " + entitySetName + " not found in EdmModel");
            }

            return(new EntitySetConfiguration <TEntityType>(this, entitySet));
        }