Beispiel #1
0
        /// <summary>
        /// Override the default method, adding generation of root queries that call designated service operations
        /// </summary>
        /// <param name="entityModelSchema">Entity Model Schema</param>
        /// <param name="queryTypeLibrary">Query Type Library</param>
        protected override void BuildRootQueriesAndTypes(EntityModelSchema entityModelSchema, QueryTypeLibrary queryTypeLibrary)
        {
            base.BuildRootQueriesAndTypes(entityModelSchema, queryTypeLibrary);

            // For each service operation marked as root, add a root query that calls the operation
            var rootServiceOperationQueries = new List <QueryExpression>();

            foreach (var serviceOperation in entityModelSchema.Functions.Where(f => f.Annotations.OfType <FunctionBodyAnnotation>().Any(a => a.IsRoot)))
            {
                QueryExpression bodyExpression = serviceOperation.Annotations.OfType <FunctionBodyAnnotation>().Single().FunctionBody;
                ExceptionUtilities.CheckObjectNotNull(bodyExpression, "Root level function has null body expression");

                QueryType rootQueryType = queryTypeLibrary.GetDefaultQueryType(serviceOperation.ReturnType);
                var       rootQuery     = new QueryCustomFunctionCallExpression(rootQueryType, serviceOperation, bodyExpression, true, false);
                rootServiceOperationQueries.Add(rootQuery);

                QueryStructuralType structuralType = rootQueryType as QueryStructuralType;
                if (structuralType == null)
                {
                    QueryCollectionType collectionType = rootQueryType as QueryCollectionType;
                    if (collectionType != null)
                    {
                        structuralType = collectionType.ElementType as QueryStructuralType;
                    }
                }

                ExceptionUtilities.CheckObjectNotNull(structuralType, "Root level service op query must return structural type");
                this.RootDataTypes.Add(serviceOperation.Name, structuralType);
            }

            this.RootQueries = this.RootQueries.Concat(rootServiceOperationQueries);
        }
Beispiel #2
0
        /// <summary>
        /// Creates structural data services for the entity model.
        /// </summary>
        /// <param name="modelSchema">Entity model schema.</param>
        /// <returns>
        /// An <see cref="IEntityModelConceptualDataServices"/>.
        /// </returns>
        public IEntityModelConceptualDataServices CreateConceptualDataServices(EntityModelSchema modelSchema)
        {
            ExceptionUtilities.CheckArgumentNotNull(modelSchema, "modelSchema");
            ExceptionUtilities.CheckAllRequiredDependencies(this);

            try
            {
                this.structuralGenerators = new ConceptualDataServices();

                foreach (ComplexType complexType in modelSchema.ComplexTypes)
                {
                    this.GetOrCreateAndRegisterStructuralDataGeneratorForComplexType(complexType);
                }

                foreach (EntityContainer entityContainer in modelSchema.EntityContainers)
                {
                    foreach (var entitySet in entityContainer.EntitySets)
                    {
                        this.CreateAndRegisterStructuralDataGeneratorsForEntitySet(entitySet);
                    }
                }

                return(this.structuralGenerators);
            }
            finally
            {
                this.structuralGenerators = null;
            }
        }
Beispiel #3
0
        private static void ResolveDataGenerationHints(EntityModelSchema model, DependencyInjectionContainer container)
        {
            var entityModelHintsResolver = container.Resolve <IEntityModelDataGenerationHintsResolver>();
            var primitiveResolver        = container.Resolve <IPrimitiveDataTypeToDataGenerationHintsResolver>();

            entityModelHintsResolver.ResolveDataGenerationHints(model, primitiveResolver);
        }
Beispiel #4
0
 /// <summary>
 /// Improve the model if goals not yet met
 /// </summary>
 /// <param name="model">model to improve</param>
 public override void Improve(EntityModelSchema model)
 {
     while (model.EntityTypes.Count() < this.MinNumberOfEntities)
     {
         model.Add(new EntityType());
     }
 }
Beispiel #5
0
        /// <summary>
        /// Generates POCO entities based on the supplied model
        /// </summary>
        /// <param name="model">Model to generate classes from</param>
        /// <returns>Generated code files</returns>
        public IEnumerable <FileContents <string> > GenerateEntityClasses(EntityModelSchema model)
        {
            ExceptionUtilities.CheckArgumentNotNull(model, "model");
            PocoAnnotator.Annotate(model, this.PocoOption);
            List <FileContents <string> > results = new List <FileContents <string> >();

            foreach (var ns in model.EntityTypes.Select(e => e.NamespaceName).Concat(model.EnumTypes.Select(e => e.NamespaceName)).Concat(model.ComplexTypes.Select(e => e.NamespaceName)).Distinct())
            {
                var           codeUnit      = new CodeCompileUnit();
                CodeNamespace codeNamespace = codeUnit.AddNamespace(ns);
                codeNamespace.ImportNamespace("System.Collections.Generic");

                foreach (var type in model.ComplexTypes.Where(e => e.NamespaceName == ns))
                {
                    codeNamespace.Types.Add(this.BuildType(type));
                }

                foreach (var type in model.EntityTypes.Where(e => e.NamespaceName == ns))
                {
                    codeNamespace.Types.Add(this.BuildType(type));
                }

                foreach (var type in model.EnumTypes.Where(e => e.NamespaceName == ns))
                {
                    codeNamespace.Types.Add(this.BuildType(type));
                }

                string code = this.GenerateCodeFromCompileUnit(codeUnit);
                results.Add(new FileContents <string>(ns + this.language.FileExtension, code));
            }

            return(results);
        }
Beispiel #6
0
        /// <summary>
        /// Parses a single csdl/ssdl file.
        /// </summary>
        /// <param name="model">the entity model schema which the csdl/ssdl file parses to</param>
        /// <param name="schemaElement">the top level schema element in the csdl/ssdl file</param>
        protected virtual void ParseSingleXsdl(EntityModelSchema model, XElement schemaElement)
        {
            this.AssertXsdlElement(schemaElement, "Schema");

            this.SetupNamespaceAndAliases(schemaElement);

            foreach (var entityContainerElement in schemaElement.Elements().Where(el => this.IsXsdlElement(el, "EntityContainer")))
            {
                model.Add(this.ParseEntityContainer(entityContainerElement));
            }

            foreach (var entityTypeElement in schemaElement.Elements().Where(el => this.IsXsdlElement(el, "EntityType")))
            {
                model.Add(this.ParseEntityType(entityTypeElement));
            }

            foreach (var associationTypeElement in schemaElement.Elements().Where(el => this.IsXsdlElement(el, "Association")))
            {
                model.Add(this.ParseAssociation(associationTypeElement));
            }

            foreach (var functionElement in schemaElement.Elements().Where(el => this.IsXsdlElement(el, "Function")))
            {
                model.Add(this.ParseFunction(functionElement));
            }
        }
Beispiel #7
0
        /// <summary>
        /// Generates a query resolver to resolve entity sets to IQueryable
        /// </summary>
        /// <param name="model">The conceptual schema for the workspace</param>
        /// <returns>a Query resolver to resolver entity sets to IQueryable</returns>
        public override IODataQueryProvider CreateQueryProvider(EntityModelSchema model)
        {
            var queryProvider = new ClrBasedQueryProvider(this.Workspace.ObjectLayerAssembly, model, this.Evaluator, this.Repository);

            queryProvider.IsNullPropagationRequired = NullPropagationRequired;
            return(queryProvider);
        }
Beispiel #8
0
        private void AddIncrementIntegerPropertyActions(EntityModelSchema model, EntitySet entitySet, string propertyName)
        {
            var entityType = entitySet.EntityType;

            model.Add(
                new Function(entityType.NamespaceName, "ReturnBindingEntity" + entityType.Name)
            {
                ReturnType = DataTypes.EntityType.WithDefinition(entityType),
                Parameters =
                {
                    new FunctionParameter("bindingEntity", DataTypes.EntityType.WithDefinition(entityType)),
                },
                Annotations =
                {
                    new ServiceOperationAnnotation()
                    {
                        IsAction = true
                    },
                    new IncrementIntegerPropertyValueActionAnnotation()
                    {
                        IntegerProperty = propertyName
                    }
                }
            });
        }
Beispiel #9
0
 /// <summary>
 /// Performs the fixup for all items that have Name and Namespace.
 /// </summary>
 /// <param name="model">Model to perform fixup on.</param>
 public void Fixup(EntityModelSchema model)
 {
     foreach (INamedItem item in this.GetAllNamedItems(model))
     {
         this.FixupNamedItem(item);
     }
 }
        /// <summary>
        /// Improve the model if goal not yet met
        /// </summary>
        /// <param name="model">Model to improve</param>
        public override void Improve(EntityModelSchema model)
        {
            foreach (var et in model.EntityTypes)
            {
                var existingComplexProperties = et.Properties.Where(p => p.PropertyType is ComplexDataType).ToList();

                if (existingComplexProperties.Count >= this.MinNumberOfComplexPropertiesPerEntity)
                {
                    continue;
                }

                int numOfComplexPropertiesPerEntity = this.MinNumberOfComplexPropertiesPerEntity;
                if (this.RandomNumberGenerator != null)
                {
                    numOfComplexPropertiesPerEntity = this.RandomNumberGenerator.NextFromRange(this.MinNumberOfComplexPropertiesPerEntity, this.MaxNumberOfComplexPropertiesPerEntity);
                }

                int remaining = numOfComplexPropertiesPerEntity - existingComplexProperties.Count;

                for (int i = 0; i < remaining; ++i)
                {
                    et.Properties.Add(new MemberProperty()
                    {
                        PropertyType = DataTypes.ComplexType,
                    });
                }
            }
        }
        /// <summary>
        /// Remove concurrency tokens defined on complex types and properties
        /// </summary>
        /// <param name="model">The model to fix up</param>
        public void Fixup(EntityModelSchema model)
        {
            foreach (var ct in model.ComplexTypes)
            {
                foreach (var property in ct.Properties)
                {
                    // ToList is to avoid modifying the collection during enumeration
                    foreach (var annotation in property.Annotations.OfType <ConcurrencyTokenAnnotation>().ToList())
                    {
                        property.Annotations.Remove(annotation);
                    }
                }
            }

            foreach (var et in model.EntityTypes)
            {
                foreach (var property in et.AllProperties.Where(p => p.PropertyType is ComplexDataType))
                {
                    // ToList is to avoid modifying the collection during enumeration
                    foreach (var annotation in property.Annotations.OfType <ConcurrencyTokenAnnotation>().ToList())
                    {
                        property.Annotations.Remove(annotation);
                    }
                }
            }
        }
        /// <summary>
        /// Generates an assembly that contains the object layer types for the given EntityModelSchema
        /// </summary>
        /// <param name="workspace">test workspace under construction</param>
        /// <param name="schema">The schema under test</param>
        /// <returns>An assembly that contains the object layer types for the given EntityModelSchema</returns>
        private Assembly GenerateObjectLayer(ODataTestWorkspace workspace, EntityModelSchema schema)
        {
            CodeCompileUnit objectLayerCompileUnit = new CodeCompileUnit();

            this.ObjectLayerCodeGenerator.GenerateObjectLayer(objectLayerCompileUnit, schema);
            string objectLayerCode;

            using (var writer = new StringWriter(CultureInfo.InvariantCulture))
            {
                this.Language.CreateCodeGenerator().GenerateCodeFromCompileUnit(objectLayerCompileUnit, writer, null);
                objectLayerCode = writer.ToString();
            }

            string outputFilePath = Guid.NewGuid().ToString();

#if SILVERLIGHT
            outputFilePath = String.Format("{0}Assembly.dll", outputFilePath);
            return(typeof(DefaultNamespace.Phone).Assembly);
#else
            outputFilePath = outputFilePath + ".dll";
            this.Language.CompileAssemblyFromSource(outputFilePath, new[] { objectLayerCode }, referenceAssemblies);
            var assembly = AssemblyHelpers.LoadAssembly(outputFilePath, referenceAssemblies);
            return(assembly);
#endif
        }
        /// <summary>
        /// Improve the model if goal not yet met
        /// </summary>
        /// <param name="model">Model to improve</param>
        public override void Improve(EntityModelSchema model)
        {
            foreach (var et in model.EntityTypes
                     .Where(c => c.BaseType == null)
                     .Where(c => c.AllKeyProperties.Count() < this.MinNumberOfKeysPerEntities))
            {
                int numOfKeyPropertiesNeeded = this.MinNumberOfKeysPerEntities;
                if (this.MinNumberOfKeysPerEntities != this.MaxNumberOfKeysPerEntities)
                {
                    numOfKeyPropertiesNeeded = this.Random.NextFromRange(this.MinNumberOfKeysPerEntities, this.MaxNumberOfKeysPerEntities);
                }

                // Consume the existing properties...
                foreach (MemberProperty mp in et.Properties.Where(p => p.IsPrimaryKey == false).SkipWhile(q => q.PropertyType is ComplexDataType))
                {
                    if (et.AllKeyProperties.Count() < numOfKeyPropertiesNeeded)
                    {
                        mp.IsPrimaryKey = true;
                    }
                    else
                    {
                        break;
                    }
                }

                // Create new properties and make them key...
                while (et.AllKeyProperties.Count() < numOfKeyPropertiesNeeded)
                {
                    et.Properties.Add(new MemberProperty()
                    {
                        IsPrimaryKey = true
                    });
                }
            }
        }
Beispiel #14
0
        /// <summary>
        /// Adds the EntitySet information to an action or validates that it has an entitySet Path
        /// </summary>
        /// <param name="model">The model to fix up</param>
        public void Fixup(EntityModelSchema model)
        {
            foreach (Function f in model.Functions.Where(f => f.IsAction() && f.ReturnType != null))
            {
                var serviceOperationAnnotation = f.Annotations.OfType <ServiceOperationAnnotation>().Single();

                // If someone has set the entitySetPath or the entitySet name then we don't need to update anything
                if (serviceOperationAnnotation.EntitySetPath != null || serviceOperationAnnotation.EntitySetName != null)
                {
                    continue;
                }

                EntityDataType entityDataType     = f.ReturnType as EntityDataType;
                var            collectionDataType = f.ReturnType as CollectionDataType;
                if (collectionDataType != null)
                {
                    entityDataType = collectionDataType.ElementDataType as EntityDataType;
                }

                if (entityDataType != null)
                {
                    var possibleMatch = model.EntityContainers.Single().EntitySets.Where(es => entityDataType.Definition.IsKindOf(es.EntityType)).ToList();
                    ExceptionUtilities.Assert(possibleMatch.Count == 1, string.Format(CultureInfo.InvariantCulture, "Cannot resolve function '{0}' to one EntitySet, possible matches were '{1}'", f.Name, string.Join(",", possibleMatch.Select(es => es.Name))));
                    serviceOperationAnnotation.EntitySetName = possibleMatch.Single().Name;
                }
            }
        }
Beispiel #15
0
        private Dictionary <string, IList <object> > GroupModelItemsIntoNamespaces(EntityModelSchema model)
        {
            var namespace2Items = new Dictionary <string, IList <object> >();

            this.GroupIntoNamespaces(model.EntityTypes.Cast <INamedItem>(), namespace2Items);
            this.GroupIntoNamespaces(model.ComplexTypes.Cast <INamedItem>(), namespace2Items);
            this.GroupIntoNamespaces(model.Associations.Cast <INamedItem>(), namespace2Items);
            this.GroupIntoNamespaces(model.Functions.Cast <INamedItem>(), namespace2Items);
            this.GroupIntoNamespaces(model.EnumTypes.Cast <INamedItem>(), namespace2Items);

            string containerNamespace = this.ContainerDefaultNamespace;

            if (namespace2Items.Keys.Count > 0)
            {
                containerNamespace = namespace2Items.Keys.First();
            }
            else
            {
                namespace2Items[containerNamespace] = new List <object>();
            }

            foreach (EntityContainer container in model.EntityContainers)
            {
                namespace2Items[containerNamespace].Add(container);
            }

            return(namespace2Items);
        }
Beispiel #16
0
        /// <summary>
        /// Creates an <see cref="AssociationType"/> between the <paramref name="from"/> and <paramref name="to"/>
        /// entity types. It uses computed names for the association and its ends.
        /// </summary>
        /// <param name="from">The entity type the association starts on.</param>
        /// <param name="to">The entity type the association goes to.</param>
        /// <param name="isSingletonRelationship">true if the navigation property is of singleton cardinality; false for a cardinality many. Default is false.</param>
        /// <returns>A new <see cref="AssociationType"/> between the <paramref name="from"/> and <paramref name="to"/> entity types.</returns>
        public static AssociationType AssociationType(this EntityModelSchema model, EntityType from, EntityType to, bool isSingletonRelationship)
        {
            ExceptionUtilities.CheckArgumentNotNull(model, "model");
            ExceptionUtilities.CheckArgumentNotNull(from, "from");
            ExceptionUtilities.CheckArgumentNotNull(to, "to");

            string associationTypeName = from.Name + "_" + to.Name;

            int index = 0;

            while (model.Associations.Where(a => a.Name == associationTypeName).Count() > 0)
            {
                index++;
                associationTypeName = from.Name + "_" + to.Name + index;
            }

            // create the association type
            AssociationType associationType = new AssociationType(associationTypeName)
            {
                new AssociationEnd("From" + from.Name, from, EndMultiplicity.ZeroOne),
                new AssociationEnd("To" + to.Name, to, isSingletonRelationship ? EndMultiplicity.One : EndMultiplicity.Many),
            };

            model.Add(associationType);
            return(associationType);
        }
 private bool NeedsAnnotationNamespace(EntityModelSchema schema)
 {
     return(schema.EntityTypes.Cast <NamedStructuralType>()
            .Concat(schema.ComplexTypes.Cast <NamedStructuralType>())
            .SelectMany(e => e.Properties)
            .Any(p => p.Annotations.OfType <StoreGeneratedPatternAnnotation>().Any()));
 }
Beispiel #18
0
        /// <summary>
        /// Converts a model from Taupo term into Edm term
        /// </summary>
        /// <param name="taupoModel">The input model in Taupo term</param>
        /// <returns>The output model in Edm term</returns>
        public IEdmModel ConvertToEdmModel(EntityModelSchema taupoModel)
        {
            IEnumerable <XElement> csdlElements = this.GenerateCsdlElements(taupoModel);
            IEdmModel resultEdmModel            = this.GetParserResult(csdlElements);

            return(resultEdmModel);
        }
Beispiel #19
0
 /// <summary>
 /// Initializes a new instance of the ClrBasedQueryProvider type
 /// </summary>
 /// <param name="clrTypesAssembly">The assembly which contains the clr types for resource types</param>
 /// <param name="modelSchema">The schema for the model under test</param>
 /// <param name="evaluator">The evaluator to evaluate queries created after resolution</param>
 /// <param name="repository">The query repository to find root queries in</param>
 public ClrBasedQueryProvider(Assembly clrTypesAssembly, EntityModelSchema modelSchema, IQueryExpressionEvaluator evaluator, QueryRepository repository)
 {
     this.clrTypesAssembly = clrTypesAssembly;
     this.modelSchema      = modelSchema;
     this.evaluator        = evaluator;
     this.queryRepository  = repository;
 }
        /// <summary>
        /// Runs the given query against the OdataLib's uri translator and compares the results against an inmemorycontext
        /// </summary>
        /// <param name="expression">The query expression to run against the Uri parser</param>
        public void Verify(QueryExpression expression)
        {
            // 1. test : take the expression and construct the OData URI
            // /Customers?$top=1
            string queryFragment = null;

            queryFragment = this.UriQueryVisitor.ComputeUri(expression);

            Uri serviceBaseUri = new Uri("http://localhost:9000/");

            // http://localhost:9000/Customers?$top=1
            Uri queryUri = new Uri(serviceBaseUri, queryFragment);

            this.Logger.WriteLine(LogLevel.Info, "Running Uri :{0}", queryUri.OriginalString);

            EntityModelSchema schema = Workspace.ConceptualModel;

            // Generate an EDM model based on the EntityModelSchema to use in the UriParser
            IEdmModel model = this.DataServiceProviderFactory.CreateMetadataProvider(schema);

            // Generate an IDSQP based on the EntityModelSchema to use in the Expression Translator
            var queryResolver = this.DataServiceProviderFactory.CreateQueryProvider(schema);

            // 2. product : take the URI , run it through the parser and get the Linq expression
            ODataUriParser parser = new ODataUriParser(model, serviceBaseUri, queryUri);
            var            query  = parser.ParseUri();
            var            result = query.Path;

            // Get the expected Results
            QueryValue expectedResults = null;

            expectedResults = this.Evaluator.Evaluate(expression);
        }
Beispiel #21
0
        private GenericTypeLookupGraph BuildGenericTypeResolutionGraph(EntityModelSchema model)
        {
            var graph = new GenericTypeLookupGraph();

            foreach (var unmappedBaseType in model.EntityTypes.Where(e => (e.Annotations.OfType <ObjectLayerOnlyAnnotation>().Any() || e.Annotations.OfType <GenericTypeAnnotation>().Any()) && e.BaseType == null))
            {
                var genericTypeAnnotation = unmappedBaseType.Annotations.OfType <GenericTypeAnnotation>().FirstOrDefault();
                if (genericTypeAnnotation == null)
                {
                    continue;
                }

                int count = genericTypeAnnotation.TypeParameters.Count;
                for (int i = 0; i < count; ++i)
                {
                    var lookups           = new Dictionary <EntityType, GenericArgument>();
                    var typeParameterName = genericTypeAnnotation.TypeParameters[i];
                    graph.Add(new GenericTypeParameter(unmappedBaseType, typeParameterName), lookups);

                    this.WalkChildren(graph, model, unmappedBaseType, typeParameterName, lookups);
                }
            }

            return(graph);
        }
        private void ApplyEntityTypeCollectionTypes(EntityModelSchema model)
        {
            foreach (var entityType in model.EntityTypes)
            {
                foreach (var property in entityType.Properties.Where(p => p.PropertyType is CollectionDataType))
                {
                    if (!property.Annotations.OfType <CollectionContractTypeAnnotation>().Any())
                    {
                        property.Annotations.Add(this.CreateContractTypeAnnotation());
                    }

                    if (!property.Annotations.OfType <CollectionInstanceTypeAnnotation>().Any())
                    {
                        property.Annotations.Add(this.CreateInstanceTypeAnnotation());
                    }
                }

                foreach (var navigation in entityType.NavigationProperties.Where(p => p.ToAssociationEnd.Multiplicity == EndMultiplicity.Many))
                {
                    if (!navigation.Annotations.OfType <CollectionContractTypeAnnotation>().Any())
                    {
                        navigation.Annotations.Add(this.CreateContractTypeAnnotation());
                    }

                    if (!navigation.Annotations.OfType <CollectionInstanceTypeAnnotation>().Any())
                    {
                        navigation.Annotations.Add(this.CreateInstanceTypeAnnotation());
                    }
                }
            }
        }
        /// <summary>
        /// Compares the two models to each other and throws an exception when there is an erro
        /// </summary>
        /// <param name="expectedTestEntityModel">EntityModelSchema to compare y to</param>
        /// <param name="actualEntityModelSchema">EntityModelSchema to compare x to</param>
        /// <returns>List of errors</returns>
        public ICollection <string> Compare(EntityModelSchema expectedTestEntityModel, EntityModelSchema actualEntityModelSchema)
        {
            this.errors = new List <string>();
            foreach (ComplexType complexType in expectedTestEntityModel.ComplexTypes)
            {
                List <ComplexType> complexTypes = actualEntityModelSchema.ComplexTypes.Where(ct => ct.FullName == complexType.FullName).ToList();
                if (!this.WriteErrorIfFalse(complexTypes.Count == 1, "Cannot find complexType '{0}'", complexType.Name))
                {
                    ComplexType ycomplexType = complexTypes.Single();
                    this.CompareComplexType(complexType, ycomplexType);
                }
            }

            foreach (EntityType expectedEntityType in expectedTestEntityModel.EntityTypes)
            {
                List <EntityType> entityTypes = actualEntityModelSchema.EntityTypes.Where(et => et.FullName == expectedEntityType.FullName).ToList();
                if (!this.WriteErrorIfFalse(entityTypes.Count == 1, "Cannot find entityType '{0}'", expectedEntityType.Name))
                {
                    EntityType actualEntityType = entityTypes.Single();
                    this.CompareEntityTypes(expectedEntityType, actualEntityType);
                }
            }

            foreach (EntityContainer expectedEntityContainer in expectedTestEntityModel.EntityContainers)
            {
                List <EntityContainer> entityContainers = actualEntityModelSchema.EntityContainers.Where(ec => ec.Name == expectedEntityContainer.Name).ToList();
                if (!this.WriteErrorIfFalse(entityContainers.Count == 1, "Cannot find entityContainer '{0}'", expectedEntityContainer.Name))
                {
                    EntityContainer actualEntityContainer = entityContainers.Single();
                    this.CompareEntityContainer(expectedEntityContainer, actualEntityContainer);
                }
            }

            return(this.errors);
        }
        public void ConvertFunction_with_overloads()
        {
            var taupoModel = new EntityModelSchema()
            {
                new Function("NS1", "MyFunction")
                {
                    new FunctionParameter("Param1", EdmDataTypes.Int32, FunctionParameterMode.InOut),
                    new FunctionParameter("Param2", EdmDataTypes.Int32, FunctionParameterMode.Out)
                },
                new Function("NS1", "MyFunction")
                {
                    new FunctionParameter("Param", EdmDataTypes.Int16),
                },
            };

            IEdmModel result = this.converter.ConvertToEdmModel(taupoModel);

            Assert.AreEqual(2, result.SchemaElements.Count());
            Assert.AreEqual(2, result.SchemaElements.OfType <IEdmOperation>().Count());

            IEdmOperation operation = result.SchemaElements.OfType <IEdmOperation>().ElementAt(0);

            Assert.AreEqual("NS1.MyFunction", operation.FullName());
            Assert.AreEqual(2, operation.Parameters.Count());
            Assert.AreEqual("Param1", operation.Parameters.ElementAt(0).Name);
            Assert.AreEqual("Param2", operation.Parameters.ElementAt(1).Name);

            operation = result.SchemaElements.OfType <IEdmOperation>().ElementAt(1);
            Assert.AreEqual("NS1.MyFunction", operation.FullName());
            Assert.AreEqual(1, operation.Parameters.Count());
            Assert.AreEqual("Param", operation.Parameters.ElementAt(0).Name);
        }
Beispiel #25
0
        /// <summary>
        /// Add default EntityContainer to the given EntitySchemaModel
        ///   For each base entity type, add an EntitySet
        ///   For each association, add an AssociationSet, between two possible EntitySets
        /// </summary>
        /// <param name="model">the given EntitySchemaModel</param>
        public void Fixup(EntityModelSchema model)
        {
            EntityContainer container = model.EntityContainers.FirstOrDefault();

            if (container == null)
            {
                container = new EntityContainer(this.DefaultContainerName);
                model.Add(container);
            }

            foreach (EntityType entity in model.EntityTypes.Where(e => e.BaseType == null && !container.EntitySets.Any(set => set.EntityType == e)))
            {
                if (!entity.Annotations.OfType <FixupNoSetAnnotation>().Any())
                {
                    container.Add(new EntitySet(entity.Name, entity));
                }
            }

            foreach (AssociationType association in model.Associations.Where(assoc => !container.AssociationSets.Any(assocSet => assocSet.AssociationType == assoc)))
            {
                if (!association.Annotations.OfType <FixupNoSetAnnotation>().Any())
                {
                    container.Add(new AssociationSet(association.Name, association)
                    {
                        Ends =
                        {
                            new AssociationSetEnd(association.Ends[0], container.EntitySets.First(es => association.Ends[0].EntityType.IsKindOf(es.EntityType))),
                            new AssociationSetEnd(association.Ends[1], container.EntitySets.First(es => association.Ends[1].EntityType.IsKindOf(es.EntityType))),
                        }
                    });
                }
            }
        }
Beispiel #26
0
        /// <summary>
        /// Visits a model
        /// </summary>
        /// <param name="model">model to visit</param>
        public void Visit(EntityModelSchema model)
        {
            foreach (var entity in model.EntityTypes)
            {
                this.VisitEntityType(entity);
            }

            foreach (var complex in model.ComplexTypes)
            {
                this.VisitComplexType(complex);
            }

            foreach (var association in model.Associations)
            {
                this.VisitAssociationType(association);
            }

            foreach (var container in model.EntityContainers)
            {
                this.VisitEntityContainer(container);
            }

            foreach (var function in model.Functions)
            {
                this.VisitFunction(function);
            }

            foreach (var enumType in model.EnumTypes)
            {
                this.VisitEnumType(enumType);
            }
        }
Beispiel #27
0
 /// <summary>
 /// Remove named streams and corresponding features in model for EF provider
 /// </summary>
 /// <param name="model">The model to fix up</param>
 public void Fixup(EntityModelSchema model)
 {
     foreach (var entityType in model.EntityTypes)
     {
         entityType.Properties.RemoveAll(p => p.IsStream());
     }
 }
Beispiel #28
0
 /// <summary>
 /// Generates the top-level namespace declarations.
 /// </summary>
 /// <param name="model">The entity schema model.</param>
 /// <returns>
 /// Sequence of top-level namespace declaration attributes.
 /// </returns>
 protected virtual IEnumerable <XAttribute> GenerateNamespaceDeclarations(EntityModelSchema model)
 {
     if (this.GenerateTaupoAnnotations)
     {
         yield return(new XAttribute(XNamespace.Xmlns + "taupo", EdmConstants.TaupoAnnotationsNamespace.NamespaceName));
     }
 }
Beispiel #29
0
        /// <summary>
        /// Annotates the model based on the POCO Generation options.
        /// </summary>
        /// <param name="model">The EntityModelSchema that has to be annotated</param>
        /// <param name="option">The POCOGeneration option for model annotation</param>
        public static void Annotate(EntityModelSchema model, PocoOption option)
        {
            ExceptionUtilities.CheckArgumentNotNull(model, "model");

            switch (option)
            {
            case PocoOption.None:
                break;

            case PocoOption.Pure:
                CustomizeModelForPurePocoGeneration(model);
                break;

            case PocoOption.NavigationPropertiesVirtual:
                CustomizeModelForPocoGenerationWithNavigationPropertiesVirtual(model);
                break;

            case PocoOption.AllPropertiesVirtual:
                CustomizeModelForPocoGenerationWithAllPropertiesVirtual(model);
                break;

            default:
                throw new TaupoArgumentException(string.Format(CultureInfo.InvariantCulture, "Invalid Poco option '{0}' specified. Use any of the allowed Poco option values such as '{1}', '{2}', '{3}' or '{4}' instead!", option, PocoOption.None, PocoOption.Pure, PocoOption.NavigationPropertiesVirtual, PocoOption.AllPropertiesVirtual));
            }
        }
        private void ResolveNavigationProperty(EntityModelSchema model, NavigationProperty nav)
        {
            nav.Association = this.ResolveAssociationTypeReference(model, nav.Association);

            nav.FromAssociationEnd = this.ResolveAssociationEndReference(nav.Association, nav.FromAssociationEnd);
            nav.ToAssociationEnd   = this.ResolveAssociationEndReference(nav.Association, nav.ToAssociationEnd);
        }