/// <summary> /// Constructor for creating a referenced model, is private and only called by the above constructor. /// </summary> /// <param name="referencedCsdlModel">The referenced raw CsdlModel.</param> /// <param name="annotationsManager">The IEdmDirectValueAnnotationsManager.</param> /// <param name="mainCsdlSemanticsModel">The CsdlSemanticsModel that will reference this new CsdlSemanticsModel. </param> /// <param name="includeDefaultVocabularies">A value indicating enable/disable the built-in vocabulary supporting.</param> private CsdlSemanticsModel(CsdlModel referencedCsdlModel, IEdmDirectValueAnnotationsManager annotationsManager, CsdlSemanticsModel mainCsdlSemanticsModel, bool includeDefaultVocabularies) : base(Enumerable.Empty <IEdmModel>(), annotationsManager, includeDefaultVocabularies) { this.mainEdmModel = mainCsdlSemanticsModel; Debug.Assert(referencedCsdlModel.ParentModelReferences.Any(), "referencedCsdlModel.ParentModelReferences.Any()"); this.astModel = referencedCsdlModel; this.SetEdmReferences(BuildEdmReferences(referencedCsdlModel.CurrentModelReferences)); foreach (var tmp in referencedCsdlModel.ParentModelReferences.SelectMany(s => s.Includes)) { string includeNs = tmp.Namespace; if (!referencedCsdlModel.Schemata.Any(s => s.Namespace == includeNs)) { // edmx:include must be an existing namespace // TODO: REF throw exception: should include a namespace that exists in referenced model. } } foreach (var tmp in referencedCsdlModel.CurrentModelReferences.SelectMany(s => s.Includes)) { // in any referenced model, alias may point to a further referenced model, now make alias available: this.SetNamespaceAlias(tmp.Namespace, tmp.Alias); } foreach (var schema in referencedCsdlModel.Schemata) { this.AddSchemaIfReferenced(schema, referencedCsdlModel.ParentModelReferences); } }
public CsdlSemanticsEntitySetTests() { var referentialConstraints = new List <CsdlReferentialConstraint>(); var csdlNavigation = new CsdlNavigationProperty("Navigation", null, null, null, false, null, referentialConstraints, null, null); this.csdlEntityType = new CsdlEntityType("EntityType", null, false, false, false, null, Enumerable.Empty <CsdlProperty>(), new[] { csdlNavigation }, null, null); var goodBinding = new CsdlNavigationPropertyBinding("Navigation", "EntitySet", null, new CsdlLocation(1, 1)); this.csdlEntitySet = new CsdlEntitySet("EntitySet", "FQ.NS.EntityType", new[] { goodBinding }, null, null); this.csdlContainer = new CsdlEntityContainer("Container", null, new[] { this.csdlEntitySet }, Enumerable.Empty <CsdlSingleton>(), Enumerable.Empty <CsdlOperationImport>(), null, null); var derivedCsdlNavigation = new CsdlNavigationProperty("DerivedNavigation", null, null, null, false, null, referentialConstraints, null, null); var derivedCsdlEntityType = new CsdlEntityType("DerivedEntityType", "FQ.NS.EntityType", false, false, false, null, Enumerable.Empty <CsdlProperty>(), new[] { derivedCsdlNavigation }, null, null); var unrelatedCsdlEntityType = new CsdlEntityType("UnrelatedEntityType", null, false, false, false, null, Enumerable.Empty <CsdlProperty>(), Enumerable.Empty <CsdlNavigationProperty>(), null, null); var csdlSchema = new CsdlSchema("FQ.NS", null, null, new[] { this.csdlEntityType, derivedCsdlEntityType, unrelatedCsdlEntityType }, Enumerable.Empty <CsdlEnumType>(), Enumerable.Empty <CsdlOperation>(), Enumerable.Empty <CsdlTerm>(), Enumerable.Empty <CsdlEntityContainer>(), Enumerable.Empty <CsdlAnnotations>(), Enumerable.Empty <CsdlTypeDefinition>(), null, null); var csdlModel = new CsdlModel(); csdlModel.AddSchema(csdlSchema); var semanticModel = new CsdlSemanticsModel(csdlModel, new EdmDirectValueAnnotationsManager(), Enumerable.Empty <IEdmModel>()); this.semanticSchema = new CsdlSemanticsSchema(semanticModel, csdlSchema); this.semanticContainer = new CsdlSemanticsEntityContainer(this.semanticSchema, this.csdlContainer); this.semanticEntityType = semanticModel.FindType("FQ.NS.EntityType") as CsdlSemanticsEntityTypeDefinition; this.semanticEntityType.Should().NotBeNull(); this.navigationProperty = this.semanticEntityType.FindProperty("Navigation") as CsdlSemanticsNavigationProperty; this.navigationProperty.Should().NotBeNull(); }
public void TryGetEntitySetWithBoundCsdlSemanticOperationParameterShouldReturnTrueAndHaveNoErrors() { var csdlEntityType = new CsdlEntityType("EntityType", null, false, false, false, null, Enumerable.Empty <CsdlProperty>(), Enumerable.Empty <CsdlNavigationProperty>(), null, null); var csdlSchema = CsdlBuilder.Schema("FQ.NS", csdlStructuredTypes: new[] { csdlEntityType }); var csdlModel = new CsdlModel(); csdlModel.AddSchema(csdlSchema); var semanticModel = new CsdlSemanticsModel(csdlModel, new EdmDirectValueAnnotationsManager(), Enumerable.Empty <IEdmModel>()); var semanticSchema = new CsdlSemanticsSchema(semanticModel, csdlSchema); var testLocation = new CsdlLocation(1, 3); var action = new CsdlAction( "Checkout", new CsdlOperationParameter[] { new CsdlOperationParameter("entity", new CsdlNamedTypeReference("FQ.NS.EntityType", false, testLocation), null, testLocation) }, new CsdlNamedTypeReference("Edm.String", false, testLocation), true /*isBound*/, "entity", null /*documentation*/, testLocation); var semanticAction = new CsdlSemanticsAction(semanticSchema, action); IEdmOperationParameter edmParameter; IEnumerable <IEdmNavigationProperty> navigationProperties; IEdmEntityType entityType; IEnumerable <EdmError> errors; semanticAction.TryGetRelativeEntitySetPath(semanticSchema.Model, out edmParameter, out navigationProperties, out entityType, out errors).Should().BeTrue(); edmParameter.Name.Should().Be("entity"); navigationProperties.Should().BeEmpty(); entityType.FullName().Should().Be("FQ.NS.EntityType"); errors.Should().BeEmpty(); }
public void EnsureActionImportActionPropertyIsUnresolvedAction() { var actionImport = new CsdlActionImport("Action", "FQ.NS.Action", null /*entitySet*/, null /*documentation*/, testLocation); var csdlEntityContainer = CsdlBuilder.EntityContainer("Container", operationImports: new CsdlOperationImport[] { actionImport }); var schema = CsdlBuilder.Schema("FQ.NS", csdlEntityContainers: new CsdlEntityContainer[] { csdlEntityContainer }); var csdlModel = new CsdlModel(); csdlModel.AddSchema(schema); var semanticSchema = new CsdlSemanticsSchema(new CsdlSemanticsModel(csdlModel, new EdmDirectValueAnnotationsManager(), Enumerable.Empty <IEdmModel>()), schema); CsdlSemanticsEntityContainer container = new CsdlSemanticsEntityContainer(semanticSchema, csdlEntityContainer); var imports = container.OperationImports().ToList(); imports.Should().HaveCount(1); imports[0].Name.Should().Be("Action"); imports[0].Operation.GetType().Should().Be(typeof(UnresolvedAction)); var errors = imports[0].Operation.As <BadElement>().Errors.ToList(); errors.Should().HaveCount(1); errors.First().ErrorMessage.Should().Be(Strings.Bad_UnresolvedOperation("FQ.NS.Action")); imports[0].Container.Name.Should().Be("Container"); imports[0].Location().Should().Be(testLocation); imports[0].ContainerElementKind.Should().Be(EdmContainerElementKind.ActionImport); imports[0].EntitySet.Should().BeNull(); }
public void EnsureFunctionImportFunctionPropertyIsUnresolvedFunction() { var functionImport = new CsdlFunctionImport("GetStuff", "FQ.NS.GetStuff", null /*entitySet*/, true /*includeInServiceDocument*/, null /*documentation*/, testLocation); var csdlEntityContainer = CsdlBuilder.EntityContainer("Container", operationImports: new CsdlOperationImport[] { functionImport }); var schema = CsdlBuilder.Schema("FQ.NS", csdlEntityContainers: new CsdlEntityContainer[] { csdlEntityContainer }); var csdlModel = new CsdlModel(); csdlModel.AddSchema(schema); var semanticSchema = new CsdlSemanticsSchema(new CsdlSemanticsModel(csdlModel, new EdmDirectValueAnnotationsManager(), Enumerable.Empty <IEdmModel>()), schema); CsdlSemanticsEntityContainer container = new CsdlSemanticsEntityContainer(semanticSchema, csdlEntityContainer); var imports = container.OperationImports().ToList(); imports.Should().HaveCount(1); var csdlFunctionImport = (IEdmFunctionImport)imports[0]; csdlFunctionImport.Name.Should().Be("GetStuff"); csdlFunctionImport.Operation.GetType().Should().Be(typeof(UnresolvedFunction)); var errors = csdlFunctionImport.Operation.As <BadElement>().Errors.ToList(); errors.Should().HaveCount(1); errors.First().ErrorMessage.Should().Be(Strings.Bad_UnresolvedOperation("FQ.NS.GetStuff")); csdlFunctionImport.Container.Name.Should().Be("Container"); csdlFunctionImport.Location().Should().Be(testLocation); csdlFunctionImport.ContainerElementKind.Should().Be(EdmContainerElementKind.FunctionImport); csdlFunctionImport.EntitySet.Should().BeNull(); csdlFunctionImport.IncludeInServiceDocument.Should().BeTrue(); csdlFunctionImport.Function.IsComposable.Should().BeFalse(); }
public void EnsureFunctionImportFunctionPropertyIsUnresolvedFunction() { var functionImport = new CsdlFunctionImport("GetStuff", "FQ.NS.GetStuff", null /*entitySet*/, true /*includeInServiceDocument*/, testLocation); var csdlEntityContainer = CsdlBuilder.EntityContainer("Container", operationImports: new CsdlOperationImport[] { functionImport }); var schema = CsdlBuilder.Schema("FQ.NS", csdlEntityContainers: new CsdlEntityContainer[] { csdlEntityContainer }); var csdlModel = new CsdlModel(); csdlModel.AddSchema(schema); var semanticSchema = new CsdlSemanticsSchema(new CsdlSemanticsModel(csdlModel, new EdmDirectValueAnnotationsManager(), Enumerable.Empty <IEdmModel>()), schema); CsdlSemanticsEntityContainer container = new CsdlSemanticsEntityContainer(semanticSchema, csdlEntityContainer); var imports = container.OperationImports().ToList(); var csdlFunctionImport = Assert.Single(imports) as IEdmFunctionImport; Assert.Equal("GetStuff", csdlFunctionImport.Name); Assert.IsType <UnresolvedFunction>(csdlFunctionImport.Operation); var errors = (csdlFunctionImport.Operation as BadElement).Errors.ToList(); var error = Assert.Single(errors); Assert.Equal(Strings.Bad_UnresolvedOperation("FQ.NS.GetStuff"), error.ErrorMessage); Assert.Equal("Container", csdlFunctionImport.Container.Name); Assert.Equal(testLocation, csdlFunctionImport.Location()); Assert.Equal(EdmContainerElementKind.FunctionImport, csdlFunctionImport.ContainerElementKind); Assert.Null(csdlFunctionImport.EntitySet); Assert.True(csdlFunctionImport.IncludeInServiceDocument); Assert.False(csdlFunctionImport.Function.IsComposable); }
public void EnsureActionImportActionPropertyIsUnresolvedAction() { var actionImport = new CsdlActionImport("Action", "FQ.NS.Action", null /*entitySet*/, testLocation); var csdlEntityContainer = CsdlBuilder.EntityContainer("Container", operationImports: new CsdlOperationImport[] { actionImport }); var schema = CsdlBuilder.Schema("FQ.NS", csdlEntityContainers: new CsdlEntityContainer[] { csdlEntityContainer }); var csdlModel = new CsdlModel(); csdlModel.AddSchema(schema); var semanticSchema = new CsdlSemanticsSchema(new CsdlSemanticsModel(csdlModel, new EdmDirectValueAnnotationsManager(), Enumerable.Empty <IEdmModel>()), schema); CsdlSemanticsEntityContainer container = new CsdlSemanticsEntityContainer(semanticSchema, csdlEntityContainer); var imports = container.OperationImports().ToList(); Assert.Single(imports); Assert.Equal("Action", imports[0].Name); Assert.IsType <UnresolvedAction>(imports[0].Operation); var errors = (imports[0].Operation as BadElement).Errors.ToList(); var error = Assert.Single(errors); Assert.Equal(Strings.Bad_UnresolvedOperation("FQ.NS.Action"), error.ErrorMessage); Assert.Equal("Container", imports[0].Container.Name); Assert.Equal(testLocation, imports[0].Location()); Assert.Equal(EdmContainerElementKind.ActionImport, imports[0].ContainerElementKind); Assert.Null(imports[0].EntitySet); }
public CsdlSemanticsNavigationPropertyTests() { var constraints = new[] { new CsdlReferentialConstraint("FK", "ID", null) }; this.collectionProperty = new CsdlNavigationProperty("Collection", "Collection(FQ.NS.EntityType)", null, "Reference", false, null, constraints, null); this.referenceProperty = new CsdlNavigationProperty("Reference", "FQ.NS.EntityType", false, null, false, null, Enumerable.Empty <CsdlReferentialConstraint>(), null); var navigationWithoutPartner = new CsdlNavigationProperty("WithoutPartner", "FQ.NS.EntityType", false, null, false, null, Enumerable.Empty <CsdlReferentialConstraint>(), null); var idProperty = new CsdlProperty("ID", new CsdlNamedTypeReference("Edm.Int32", false, null), null, null); var fkProperty = new CsdlProperty("FK", new CsdlNamedTypeReference("Edm.Int32", false, null), null, null); this.csdlEntityType = new CsdlEntityType("EntityType", null, false, false, false, new CsdlKey(new[] { new CsdlPropertyReference("ID", null) }, null), new[] { idProperty, fkProperty }, new[] { collectionProperty, referenceProperty, navigationWithoutPartner }, null); var csdlSchema = new CsdlSchema("FQ.NS", null, null, new[] { this.csdlEntityType }, Enumerable.Empty <CsdlEnumType>(), Enumerable.Empty <CsdlOperation>(), Enumerable.Empty <CsdlTerm>(), Enumerable.Empty <CsdlEntityContainer>(), Enumerable.Empty <CsdlAnnotations>(), Enumerable.Empty <CsdlTypeDefinition>(), null); var csdlModel = new CsdlModel(); csdlModel.AddSchema(csdlSchema); var semanticModel = new CsdlSemanticsModel(csdlModel, new EdmDirectValueAnnotationsManager(), Enumerable.Empty <IEdmModel>()); this.semanticEntityType = semanticModel.FindType("FQ.NS.EntityType") as CsdlSemanticsEntityTypeDefinition; this.semanticEntityType.Should().NotBeNull(); this.semanticCollectionNavigation = this.semanticEntityType.FindProperty("Collection") as CsdlSemanticsNavigationProperty; this.semanticReferenceNavigation = this.semanticEntityType.FindProperty("Reference") as CsdlSemanticsNavigationProperty; this.semanticNavigationWithoutPartner = this.semanticEntityType.FindProperty("WithoutPartner") as CsdlSemanticsNavigationProperty; this.semanticCollectionNavigation.Should().NotBeNull(); this.semanticReferenceNavigation.Should().NotBeNull(); this.semanticNavigationWithoutPartner.Should().NotBeNull(); }
/// <summary> /// Constructor /// </summary> /// <param name="astModel">The raw CsdlModel.</param> /// <param name="annotationsManager">The IEdmDirectValueAnnotationsManager.</param> /// <param name="referencedModels">The IEdmModels to be referenced. if any element or namespce is not supposed to be include, you should have removed it before passing to this constructor.</param> public CsdlSemanticsModel(CsdlModel astModel, IEdmDirectValueAnnotationsManager annotationsManager, IEnumerable <IEdmModel> referencedModels) : base(referencedModels, annotationsManager) { this.astModel = astModel; this.SetEdmReferences(astModel.CurrentModelReferences); foreach (CsdlSchema schema in this.astModel.Schemata) { this.AddSchema(schema); } }
/// <summary> /// Constructor /// </summary> /// <param name="astModel">The raw CsdlModel.</param> /// <param name="annotationsManager">The IEdmDirectValueAnnotationsManager.</param> /// <param name="referencedModels">The IEdmModels to be referenced. if any element or namespace is not supposed to be include, you should have removed it before passing to this constructor.</param> /// <param name="includeDefaultVocabularies">A value indicating enable/disable the built-in vocabulary supporting.</param> public CsdlSemanticsModel(CsdlModel astModel, IEdmDirectValueAnnotationsManager annotationsManager, IEnumerable <IEdmModel> referencedModels, bool includeDefaultVocabularies = true) : base(referencedModels, annotationsManager, includeDefaultVocabularies) { this.astModel = astModel; this.SetEdmReferences(BuildEdmReferences(astModel.CurrentModelReferences)); foreach (CsdlSchema schema in this.astModel.Schemata) { this.AddSchema(schema); } }
public void ParseValidVersionStringWorksAsExpected(string version) { string json = @"{""$Version"":""" + version + @"""}"; Utf8JsonReader jsonReader = GetJsonReader(json); JsonParserContext context = new JsonParserContext(); CsdlModel csdlModel = CsdlJsonParser.ParseCsdlDocument(ref jsonReader, context); Assert.Equal(version == "4.0" ? EdmConstants.EdmVersion4 : EdmConstants.EdmVersion401, csdlModel.CsdlVersion); }
private static CsdlSemanticsSchema CreateCsdlSemanticsSchema(CsdlEntityContainer csdlEntityContainer, params CsdlOperation[] operations) { var csdlEntityType = new CsdlEntityType("EntityType", null, false, false, false, null, new Collection <CsdlProperty>(), new System.Collections.Generic.List <CsdlNavigationProperty>(), null, null); var schema = CsdlBuilder.Schema("FQ.NS", csdlOperations: operations, csdlEntityContainers: new CsdlEntityContainer[] { csdlEntityContainer }, csdlStructuredTypes: new CsdlStructuredType[] { csdlEntityType }); var csdlModel = new CsdlModel(); csdlModel.AddSchema(schema); var semanticSchema = new CsdlSemanticsSchema(new CsdlSemanticsModel(csdlModel, new EdmDirectValueAnnotationsManager(), Enumerable.Empty <IEdmModel>()), schema); return(semanticSchema); }
/// <summary> /// Load and parse the referenced model but ignored any further referenced model. /// </summary> /// <param name="csdlModel">The main CSDL model.</param> /// <param name="context">The parser context.</param> /// <returns>A list of CsdlModel (no semantics) of the referenced models.</returns> private static List <CsdlModel> LoadReferencedCsdl(CsdlModel csdlModel, JsonParserContext context) { List <CsdlModel> referencedAstModels = new List <CsdlModel>(); if (context.Settings.JsonSchemaReaderFactory == null) { // don't try to load CSDL-JSON doc, but this.edmReferences's namespace-alias need to be used later. return(referencedAstModels); } foreach (var edmReference in csdlModel.CurrentModelReferences) { // If nothing included, why does it exist? if (!edmReference.Includes.Any() && !edmReference.IncludeAnnotations.Any()) { continue; } // Skip the built-in vocabulary annotation model if (edmReference.Uri != null && (edmReference.Uri.OriginalString.EndsWith("/Org.OData.Core.V1.json", StringComparison.Ordinal) || edmReference.Uri.OriginalString.EndsWith("/Org.OData.Capabilities.V1.json", StringComparison.Ordinal) || edmReference.Uri.OriginalString.EndsWith("/Org.OData.Authorization.V1.json", StringComparison.Ordinal) || edmReference.Uri.OriginalString.EndsWith("/Org.OData.Validation.V1.json", StringComparison.Ordinal) || edmReference.Uri.OriginalString.EndsWith("/Org.OData.Community.V1.json", StringComparison.Ordinal) || edmReference.Uri.OriginalString.EndsWith("/OData.Community.Keys.V1.json", StringComparison.Ordinal))) { continue; } Utf8JsonReader referencedJsonReader = context.Settings.JsonSchemaReaderFactory(edmReference.Uri, out bool skip); if (!skip) { string source = edmReference.Uri != null ? edmReference.Uri.OriginalString : null; CsdlJsonReaderSettings newSettings = context.Settings.Clone(); // set it to null to make sure stop the next level reference parsing. newSettings.JsonSchemaReaderFactory = null; JsonParserContext subContext = new JsonParserContext(newSettings, source); CsdlModel subCsdlModel = CsdlJsonParser.ParseCsdlDocument(ref referencedJsonReader, subContext); if (subCsdlModel != null && subContext.IsSucceeded()) { // Should we compare the referenced version with the main CSDL version and report error if mismatching? // So far, it's fine to ignore, because there may be scenarios where referenced schemas are at a different version. subCsdlModel.AddParentModelReferences(edmReference); referencedAstModels.Add(subCsdlModel); } context.AddRange(subContext.Errors); } } return(referencedAstModels); }
public CsdlSemanticsModel(CsdlModel astModel, EdmDirectValueAnnotationsManager annotationsManager, IEnumerable <IEdmModel> referencedModels) : base(referencedModels, annotationsManager) { this.schemata = new List <CsdlSemanticsSchema>(); this.outOfLineAnnotations = new Dictionary <string, List <CsdlSemanticsAnnotations> >(); this.wrappedAnnotations = new Dictionary <CsdlVocabularyAnnotationBase, CsdlSemanticsVocabularyAnnotation>(); this.associationDictionary = new Dictionary <string, IEdmAssociation>(); this.derivedTypeMappings = new Dictionary <string, List <IEdmStructuredType> >(); this.astModel = astModel; foreach (CsdlSchema schema in this.astModel.Schemata) { this.AddSchema(schema); } }
public CsdlSemanticsOperationTests() { this.csdlEntityType = new CsdlEntityType("EntityType", null, false, false, false, null, Enumerable.Empty <CsdlProperty>(), Enumerable.Empty <CsdlNavigationProperty>(), null); var csdlSchema = CsdlBuilder.Schema("FQ.NS", csdlStructuredTypes: new[] { this.csdlEntityType }); var csdlModel = new CsdlModel(); csdlModel.AddSchema(csdlSchema); var semanticModel = new CsdlSemanticsModel(csdlModel, new EdmDirectValueAnnotationsManager(), Enumerable.Empty <IEdmModel>()); this.semanticSchema = new CsdlSemanticsSchema(semanticModel, csdlSchema); this.testLocation = new CsdlLocation(1, 3); }
public static bool TryParse(IEnumerable <XmlReader> csdlReaders, out CsdlModel entityModel, out IEnumerable <EdmError> errors) { EdmUtil.CheckArgumentNull(csdlReaders, "csdlReaders"); CsdlParser parser = new CsdlParser(); int readerCount = 0; foreach (var inputReader in csdlReaders) { if (inputReader != null) { try { parser.AddReader(inputReader); } catch (XmlException e) { entityModel = null; errors = new EdmError[] { new EdmError(new CsdlLocation(e.LineNumber, e.LinePosition), EdmErrorCode.XmlError, e.Message) }; return(false); } } else { entityModel = null; errors = new EdmError[] { new EdmError(null, EdmErrorCode.NullXmlReader, Edm.Strings.CsdlParser_NullXmlReader) }; return(false); } readerCount++; } if (readerCount == 0) { entityModel = null; errors = new EdmError[] { new EdmError(null, EdmErrorCode.NoReadersProvided, Edm.Strings.CsdlParser_NoReadersProvided) }; return(false); } bool success = parser.GetResult(out entityModel, out errors); if (!success) { entityModel = null; } return(success); }
private bool TryParse(IEnumerable <IEdmModel> references, out IEdmModel model, out IEnumerable <EdmError> parsingErrors) { Version version = null; CsdlModel csdlModel = null; IEnumerable <EdmError> edmErrors = null; bool flag; try { this.ParseEdmxFile(out version); if (this.errors.Count != 0) { model = null; } else { if (!this.csdlParser.GetResult(out csdlModel, out edmErrors)) { this.errors.AddRange(edmErrors); model = null; } else { model = new CsdlSemanticsModel(csdlModel, new CsdlSemanticsDirectValueAnnotationsManager(), references); model.SetEdmxVersion(version); if (this.dataServiceVersion != null) { model.SetDataServiceVersion(this.dataServiceVersion); } if (this.maxDataServiceVersion != null) { model.SetMaxDataServiceVersion(this.maxDataServiceVersion); } } } parsingErrors = this.errors; return(this.errors.Count == 0); } catch (XmlException xmlException1) { XmlException xmlException = xmlException1; model = null; EdmError[] edmError = new EdmError[1]; edmError[0] = new EdmError(new CsdlLocation(xmlException.LineNumber, xmlException.LinePosition), EdmErrorCode.XmlError, xmlException.Message); parsingErrors = edmError; flag = false; } return(flag); }
public static bool TryParse(IEnumerable <XmlReader> readers, IEnumerable <IEdmModel> references, out IEdmModel model, out IEnumerable <EdmError> errors) { CsdlModel csdlModel = null; if (!CsdlParser.TryParse(readers, out csdlModel, out errors)) { model = null; return(false); } else { model = new CsdlSemanticsModel(csdlModel, new CsdlSemanticsDirectValueAnnotationsManager(), references); return(true); } }
/// <summary> /// Parse CSDL xml doc into CsdlModel, error messages are stored in this.errors. /// </summary> /// <param name="csdlVersion">The csdlVersion out.</param> /// <param name="csdlModel">The CsdlModel out.</param> /// <returns>True if succeeded.</returns> private bool TryParseCsdlFileToCsdlModel(out Version csdlVersion, out CsdlModel csdlModel) { csdlVersion = null; csdlModel = null; try { // Advance to root element if (this.reader.NodeType != XmlNodeType.Element) { while (this.reader.Read() && this.reader.NodeType != XmlNodeType.Element) { } } // There must be a root element for all current artifacts if (this.reader.EOF) { this.RaiseEmptyFile(); return(false); } if (this.reader.LocalName != CsdlConstants.Element_Edmx || !CsdlConstants.SupportedEdmxNamespaces.TryGetValue(this.reader.NamespaceURI, out csdlVersion)) { this.RaiseError(EdmErrorCode.UnexpectedXmlElement, Edm.Strings.XmlParser_UnexpectedRootElement(this.reader.Name, CsdlConstants.Element_Edmx)); return(false); } this.ParseEdmxElement(csdlVersion); IEnumerable <EdmError> err; if (!this.csdlParser.GetResult(out csdlModel, out err)) { this.errors.AddRange(err); if (this.HasIntolerableError()) { return(false); } } } catch (XmlException e) { this.errors.Add(new EdmError(new CsdlLocation(this.source, e.LineNumber, e.LinePosition), EdmErrorCode.XmlError, e.Message)); return(false); } csdlModel.AddCurrentModelReferences(this.edmReferences); return(true); }
/// <summary> /// Tries parsing the given CSDL-JSON artifact for an IEdmModel. /// </summary> /// <param name="reader">The given JSON reader containing the CSDL artifact.</param> /// <param name="settings">CSDL-JSON reader settings for current parser.</param> /// <param name="model">The model generated by parsing</param> /// <param name="errors">Errors reported while parsing.</param> /// <returns>Success of the parse operation.</returns> public static bool TryParse(ref Utf8JsonReader reader, CsdlJsonReaderSettings settings, out IEdmModel model, out IEnumerable <EdmError> errors) { EdmUtil.CheckArgumentNull(settings, nameof(settings)); model = null; JsonParserContext context = new JsonParserContext(settings, source: null); CsdlModel mainModel = CsdlJsonParser.ParseCsdlDocument(ref reader, context); if (mainModel != null && !context.HasIntolerableError()) { Debug.Assert(mainModel.CsdlVersion != null, "csdlVersion != null"); List <CsdlModel> referencedAstModels = LoadReferencedCsdl(mainModel, context); if (!context.HasIntolerableError()) { CsdlSemanticsModel tmp = new CsdlSemanticsModel(mainModel, new CsdlSemanticsDirectValueAnnotationsManager(), referencedAstModels, settings.IncludeDefaultVocabularies); // add more referenced IEdmModels in addition to the above loaded CsdlModels. if (settings.ReferencedModels != null) { tmp.AddToReferencedModels(settings.ReferencedModels); } model = tmp; model.SetEdmxVersion(mainModel.CsdlVersion); Version edmVersion; if (CsdlConstants.EdmxToEdmVersions.TryGetValue(mainModel.CsdlVersion, out edmVersion)) { model.SetEdmVersion(edmVersion); } } } errors = context.Errors; return(!context.HasIntolerableError()); }
/// <summary> /// Constroctur /// </summary> /// <param name="mainCsdlModel">The main raw CsdlModel.</param> /// <param name="annotationsManager">The IEdmDirectValueAnnotationsManager.</param> /// <param name="referencedCsdlModels">The referenced raw CsdlModels.</param> public CsdlSemanticsModel(CsdlModel mainCsdlModel, IEdmDirectValueAnnotationsManager annotationsManager, IEnumerable <CsdlModel> referencedCsdlModels) : base(Enumerable.Empty <IEdmModel>(), annotationsManager) { this.astModel = mainCsdlModel; this.SetEdmReferences(astModel.CurrentModelReferences); // 1. build semantics for referenced models foreach (var tmp in referencedCsdlModels) { this.AddReferencedModel(new CsdlSemanticsModel(tmp, this.DirectValueAnnotationsManager, this)); } // 2. build semantics for current model foreach (var include in mainCsdlModel.CurrentModelReferences.SelectMany(s => s.Includes)) { this.SetNamespaceAlias(include.Namespace, include.Alias); } foreach (CsdlSchema schema in this.astModel.Schemata) { this.AddSchema(schema); } }
/// <summary> /// Constructor for creating a referenced model, is private and only called by the above constructor. /// </summary> /// <param name="referencedCsdlModel">The referenced raw CsdlModel.</param> /// <param name="annotationsManager">The IEdmDirectValueAnnotationsManager.</param> /// <param name="mainCsdlSemanticsModel">The CsdlSemanticsModel that will reference this new CsdlSemanticsModel. </param> private CsdlSemanticsModel(CsdlModel referencedCsdlModel, IEdmDirectValueAnnotationsManager annotationsManager, CsdlSemanticsModel mainCsdlSemanticsModel) : base(Enumerable.Empty <IEdmModel>(), annotationsManager) { this.mainEdmModel = mainCsdlSemanticsModel; Debug.Assert(referencedCsdlModel.ParentModelReferences.Any(), "referencedCsdlModel.ParentModelReferences.Any()"); this.astModel = referencedCsdlModel; this.SetEdmReferences(referencedCsdlModel.CurrentModelReferences); foreach (var tmp in referencedCsdlModel.ParentModelReferences.SelectMany(s => s.Includes)) { string includeNs = tmp.Namespace; if (!referencedCsdlModel.Schemata.Any(s => s.Namespace == includeNs)) { // edmx:include must be an existing namespace // TODO: REF throw exception: should include a namespace that exists in referenced model. } } foreach (var tmp in referencedCsdlModel.CurrentModelReferences.SelectMany(s => s.Includes)) { // in any referenced model, alias may point to a further referenced model, now make alias available: this.SetNamespaceAlias(tmp.Namespace, tmp.Alias); } foreach (var schema in referencedCsdlModel.Schemata) { string schemaNamespace = schema.Namespace; IEdmInclude edmInclude = referencedCsdlModel.ParentModelReferences.SelectMany(s => s.Includes).FirstOrDefault(s => s.Namespace == schemaNamespace); if (edmInclude != null) { this.AddSchema(schema, false /*addAnnotations*/); } // TODO: REF add annotations } }
/// <summary> /// Parse CSDL-JSON doc into CsdlModel, error messages are stored in <see cref="JsonParserContext"/> /// </summary> /// <param name="jsonReader">The JSON reader.</param> /// <param name="context">The parser context.</param> /// <returns>Null or parsed <see cref="CsdlModel"/>.</returns> internal static CsdlModel ParseCsdlDocument(ref Utf8JsonReader jsonReader, JsonParserContext context) { Debug.Assert(context != null); JsonDocument jsonDocument = GetJsonDocument(ref jsonReader, context); if (jsonDocument == null) { return(null); } // make sure to dispose the JsonDocument. using (jsonDocument) { JsonElement rootElement = jsonDocument.RootElement; // A CSDL JSON document consists of a single JSON object. if (!rootElement.ValidateValueKind(JsonValueKind.Object, context)) { return(null); } // This document object MUST contain the member $Version. Version version = rootElement.ProcessRequiredProperty("$Version", context, ParseVersion); if (version == null) { return(null); } CsdlModel csdlModel = new CsdlModel { CsdlVersion = version }; IList <IEdmReference> references = null; rootElement.ParseAsObject(context, (propertyName, propertyValue) => { switch (propertyName) { case "$Version": // skip, because processed break; case "$EntityContainer": // The value of $EntityContainer is the namespace-qualified name of the entity container of that service. // So far, i don't know how to use it. So skip it. break; case "$Reference": // The document object MAY contain the member $Reference to reference other CSDL documents. references = ParseReferences(propertyValue, context); break; default: // CSDL document also MAY contain members for schemas. // Each schema's value is an object. if (propertyValue.ValueKind == JsonValueKind.Object) { CsdlSchema schema = SchemaJsonParser.ParseCsdlSchema(propertyName, csdlModel.CsdlVersion, propertyValue, context); if (schema != null) { csdlModel.AddSchema(schema); break; } } context.ReportError(EdmErrorCode.UnexpectedElement, Strings.CsdlJsonParser_UnexpectedJsonMember(context.Path, propertyValue.ValueKind)); break; } }); if (references != null) { csdlModel.AddCurrentModelReferences(references); } return(csdlModel); } }
public CsdlParser() { this.errorsList = new List <EdmError>(); this.result = new CsdlModel(); this.success = true; }
public static bool TryParse(IEnumerable <XmlReader> csdlReaders, out CsdlModel entityModel, out IEnumerable <EdmError> errors) { bool flag; EdmUtil.CheckArgumentNull <IEnumerable <XmlReader> >(csdlReaders, "csdlReaders"); CsdlParser csdlParser = new CsdlParser(); int num = 0; IEnumerator <XmlReader> enumerator = csdlReaders.GetEnumerator(); using (enumerator) { while (enumerator.MoveNext()) { XmlReader current = enumerator.Current; if (current == null) { entityModel = null; EdmError[] edmError = new EdmError[1]; edmError[0] = new EdmError(null, EdmErrorCode.NullXmlReader, Strings.CsdlParser_NullXmlReader); errors = edmError; flag = false; return(flag); } else { try { csdlParser.AddReader(current); } catch (XmlException xmlException1) { XmlException xmlException = xmlException1; entityModel = null; EdmError[] edmErrorArray = new EdmError[1]; edmErrorArray[0] = new EdmError(new CsdlLocation(xmlException.LineNumber, xmlException.LinePosition), EdmErrorCode.XmlError, xmlException.Message); errors = edmErrorArray; flag = false; return(flag); } num++; } } goto Label0; } return(flag); Label0: if (num != 0) { bool result = csdlParser.GetResult(out entityModel, out errors); if (!result) { entityModel = null; } return(result); } else { entityModel = null; EdmError[] edmError1 = new EdmError[1]; edmError1[0] = new EdmError(null, EdmErrorCode.NoReadersProvided, Strings.CsdlParser_NoReadersProvided); errors = edmError1; return(false); } }
public bool GetResult(out CsdlModel model, out IEnumerable <EdmError> errors) { model = this.result; errors = this.errorsList; return(this.success); }