public CsdlSemanticsOperation(CsdlSemanticsSchema context, CsdlOperation operation)
: base(operation)
{
this.Context = context;
this.operation = operation;
this.fullName = EdmUtil.GetFullNameForSchemaElement(this.Context?.Namespace, this.operation?.Name);
}
public void ParseCsdlOperationForActionWithMembersWorksAsExpected()
{
string json = @"""Approval"": [
{
""$Kind"": ""Action"",
""$IsBound"": true,
""$Parameter"": [
{
""$Name"": ""binding"",
""$Type"": ""self.Order"",
""$Nullable"": true
}
]
}
]";
IList <CsdlOperation> operations = ParseCsdlSchemaElement(json, SchemaJsonParser.TryParseCsdlOperationOverload);
Assert.NotNull(operations);
CsdlOperation operation = Assert.Single(operations);
CsdlAction action = Assert.IsType <CsdlAction>(operation);
Assert.Equal("Approval", action.Name);
Assert.True(action.IsBound);
Assert.Null(action.EntitySetPath);
// Parameter
CsdlOperationParameter parameter = Assert.Single(action.Parameters);
Assert.Equal("binding", parameter.Name);
Assert.False(parameter.IsOptional);
Assert.Null(parameter.DefaultValue);
CsdlNamedTypeReference namedType = Assert.IsType <CsdlNamedTypeReference>(parameter.Type);
Assert.True(namedType.IsNullable);
Assert.Equal("self.Order", namedType.FullName);
// ReturnType
Assert.Null(action.Return);
}
internal static CsdlSchema Schema(
string namespaceName,
string alias = null,
Version version = null,
CsdlStructuredType[] csdlStructuredTypes = default(CsdlStructuredType[]),
CsdlEnumType[] csdlEnumTypes = default(CsdlEnumType[]),
CsdlOperation[] csdlOperations = default(CsdlOperation[]),
CsdlTerm[] csdlTerms = default(CsdlTerm[]),
CsdlEntityContainer[] csdlEntityContainers = default(CsdlEntityContainer[]),
CsdlAnnotations[] csdlAnnotations = default(CsdlAnnotations[]),
CsdlTypeDefinition[] csdlTypeDefinitions = default(CsdlTypeDefinition[]),
CsdlLocation location = null)
{
if (csdlStructuredTypes == null)
{
csdlStructuredTypes = new CsdlStructuredType[] { };
}
if (csdlEnumTypes == null)
{
csdlEnumTypes = new CsdlEnumType[] { };
}
if (csdlOperations == null)
{
csdlOperations = new CsdlOperation[] { };
}
if (csdlTerms == null)
{
csdlTerms = new CsdlTerm[] { };
}
if (csdlEntityContainers == null)
{
csdlEntityContainers = new CsdlEntityContainer[] { };
}
if (csdlAnnotations == null)
{
csdlAnnotations = new CsdlAnnotations[] { };
}
if (csdlTypeDefinitions == null)
{
csdlTypeDefinitions = new CsdlTypeDefinition[] { };
}
var csdlSchema = new CsdlSchema(
namespaceName,
alias,
version,
csdlStructuredTypes,
csdlEnumTypes,
csdlOperations,
csdlTerms,
csdlEntityContainers,
csdlAnnotations,
csdlTypeDefinitions,
location /*location*/);
return(csdlSchema);
}
public CsdlSemanticsOperation(CsdlSemanticsSchema context, CsdlOperation operation)
: base(operation)
{
this.Context = context;
this.operation = operation;
}
public void ParseCsdlOperationForFunctionWithMembersWorksAsExpected()
{
string json = @"""CreatedEntities"": [
{
""$Kind"": ""Function"",
""$Parameter"": [
{
""$Name"": ""before"",
""$Type"": ""Edm.DateTimeOffset"",
""$Nullable"": true,
""$Precision"": 10
},
{
""$Name"": ""after"",
""$Type"": ""Edm.DateTimeOffset"",
""$Precision"": 9
}
],
""$ReturnType"": {
""$Collection"": true,
""$Type"": ""Edm.EntityType"",
""$Nullable"": true
},
""$IsComposable"": true
}
]";
IList <CsdlOperation> operations = ParseCsdlSchemaElement(json, SchemaJsonParser.TryParseCsdlOperationOverload);
Assert.NotNull(operations);
CsdlOperation operation = Assert.Single(operations);
CsdlFunction function = Assert.IsType <CsdlFunction>(operation);
Assert.Equal("CreatedEntities", function.Name);
Assert.False(function.IsBound);
Assert.True(function.IsComposable);
Assert.Null(function.EntitySetPath);
// Parameter
Assert.Equal(2, function.Parameters.Count());
CsdlOperationParameter parameter = function.Parameters.First(c => c.Name == "before");
Assert.False(parameter.IsOptional);
Assert.Null(parameter.DefaultValue);
CsdlTemporalTypeReference temporalType = Assert.IsType <CsdlTemporalTypeReference>(parameter.Type);
Assert.Equal(EdmPrimitiveTypeKind.DateTimeOffset, temporalType.Kind);
Assert.True(temporalType.IsNullable);
Assert.Equal(10, temporalType.Precision.Value);
parameter = function.Parameters.First(c => c.Name == "after");
Assert.False(parameter.IsOptional);
Assert.Null(parameter.DefaultValue);
temporalType = Assert.IsType <CsdlTemporalTypeReference>(parameter.Type);
Assert.Equal(EdmPrimitiveTypeKind.DateTimeOffset, temporalType.Kind);
Assert.False(temporalType.IsNullable);
Assert.Equal(9, temporalType.Precision.Value);
// ReturnType
Assert.NotNull(function.Return);
CsdlExpressionTypeReference expTypeRef = Assert.IsType <CsdlExpressionTypeReference>(operation.Return.ReturnType);
Assert.True(expTypeRef.IsNullable);
CsdlNamedTypeReference namedType = Assert.IsType <CsdlNamedTypeReference>(Assert.IsType <CsdlCollectionType>(expTypeRef.TypeExpression).ElementType);
Assert.True(namedType.IsNullable); // derived from collection
Assert.Equal("Edm.EntityType", namedType.FullName);
}
