/// <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);
}
