/// <inheritdoc />
protected override bool IsOperationParameterMeet(IEdmOperation operation, ActionModel action)
{
Contract.Assert(operation != null);
Contract.Assert(operation.IsFunction());
Contract.Assert(action != null);
// we can allow the action has other parameters except the functio parameters.
foreach (var parameter in operation.Parameters.Skip(1))
{
// It seems we don't need to distinguish the optional parameter here
// It means whether it's optional parameter or not, the action descriptor should have such parameter defined.
// Meanwhile, the send request may or may not have such parameter value.
IEdmOptionalParameter optionalParameter = parameter as IEdmOptionalParameter;
if (optionalParameter != null)
{
continue;
}
if (!action.Parameters.Any(p => p.ParameterInfo.Name == parameter.Name))
{
return(false);
}
}
return(true);
}
private static void AssertOperationWithOptionalParameter(IEdmModel edmModel, string opertionName)
{
IEdmOperation primitiveFunc = Assert.Single(edmModel.FindDeclaredOperations(opertionName));
Assert.Equal(4, primitiveFunc.Parameters.Count());
// non-optional parameter
IEdmOperationParameter parameter = Assert.Single(primitiveFunc.Parameters.Where(e => e.Name == "minSalary"));
Assert.Equal("Edm.Double", parameter.Type.FullName());
Assert.False(parameter.Type.IsNullable);
// optional parameter without default value
parameter = Assert.Single(primitiveFunc.Parameters.Where(e => e.Name == "maxSalary"));
Assert.NotNull(parameter);
Assert.Equal("Edm.Double", parameter.Type.FullName());
IEdmOptionalParameter optionalParameterInfo = Assert.IsAssignableFrom <IEdmOptionalParameter>(parameter);
Assert.NotNull(optionalParameterInfo);
Assert.Null(optionalParameterInfo.DefaultValueString);
// optional parameter with default value
parameter = Assert.Single(primitiveFunc.Parameters.Where(e => e.Name == "aveSalary"));
Assert.NotNull(parameter);
Assert.Equal("Edm.Double", parameter.Type.FullName());
optionalParameterInfo = Assert.IsAssignableFrom <IEdmOptionalParameter>(parameter);
Assert.NotNull(optionalParameterInfo);
Assert.Equal("8.9", optionalParameterInfo.DefaultValueString);
}
/// <summary>
/// Verify and build the function parameters
/// </summary>
/// <param name="function">The Edm function.</param>
/// <param name="parameters">The input parameter template mapping.</param>
/// <returns>The build function parameter mapping.</returns>
public static IDictionary <string, string> VerifyAndBuildParameterMappings(this IEdmFunction function, IDictionary <string, string> parameters)
{
if (function == null)
{
throw Error.ArgumentNull(nameof(function));
}
if (parameters == null)
{
throw Error.ArgumentNull(nameof(parameters));
}
Dictionary <string, string> parameterMappings = new Dictionary <string, string>();
int skip = function.IsBound ? 1 : 0;
ISet <string> funcParameters = new HashSet <string>();
foreach (var parameter in function.Parameters.Skip(skip))
{
funcParameters.Add(parameter.Name);
IEdmOptionalParameter optionalParameter = parameter as IEdmOptionalParameter;
if (optionalParameter != null)
{
// skip verification for optional parameter
continue;
}
// for required parameter, it should be in the parameter template mapping.
if (!parameters.ContainsKey(parameter.Name))
{
throw new ODataException(Error.Format(SRResources.MissingRequiredParameterInOperation, parameter.Name, function.FullName()));
}
}
foreach (var parameter in parameters)
{
if (!funcParameters.Contains(parameter.Key))
{
throw new ODataException(Error.Format(SRResources.CannotFindParameterInOperation, parameter.Key, function.FullName()));
}
string templateName = parameter.Value;
if (templateName == null || !templateName.IsValidTemplateLiteral())
{
throw new ODataException(Error.Format(SRResources.ParameterTemplateMustBeInCurlyBraces, parameter.Value, function.FullName()));
}
templateName = templateName.Substring(1, templateName.Length - 2).Trim();
if (string.IsNullOrEmpty(templateName))
{
throw new ODataException(Error.Format(SRResources.EmptyParameterAlias, parameter.Key, function.FullName()));
}
parameterMappings[parameter.Key] = templateName;
}
return(parameterMappings);
}
public void GetEdmModel_SetsOptionalParameter()
{
// Arrange
ODataModelBuilder builder = ODataModelBuilderMocks.GetModelBuilderMock <ODataModelBuilder>();
EntityTypeConfiguration <Movie> movie = builder.EntitySet <Movie>("Movies").EntityType;
var functionBuilder = movie.Function("Watch");
functionBuilder.Parameter <int>("int").HasDefaultValue("42");
functionBuilder.Parameter <Nullable <int> >("nullableOfInt").HasDefaultValue("null");
functionBuilder.Parameter <string>("string").Optional();
functionBuilder.Parameter <decimal>("decimal");
functionBuilder.Parameter <double>("double").Required();
functionBuilder.Returns <int>();
// Act
IEdmModel model = builder.GetEdmModel();
//Assert
var function = Assert.Single(model.SchemaElements.OfType <IEdmFunction>());
// int
var parameter = function.FindParameter("int");
Assert.NotNull(parameter);
IEdmOptionalParameter optionalParameter = Assert.IsType <EdmOptionalParameter>(parameter);
Assert.Equal("42", optionalParameter.DefaultValueString);
// int?
parameter = function.FindParameter("nullableOfInt");
Assert.NotNull(parameter);
optionalParameter = Assert.IsType <EdmOptionalParameter>(parameter);
Assert.Equal("null", optionalParameter.DefaultValueString);
// string
parameter = function.FindParameter("string");
Assert.NotNull(parameter);
optionalParameter = Assert.IsType <EdmOptionalParameter>(parameter);
Assert.Null(optionalParameter.DefaultValueString);
// decimal & double
foreach (var name in new[] { "decimal", "double" })
{
parameter = function.FindParameter(name);
Assert.NotNull(parameter);
Assert.IsNotType <EdmOptionalParameter>(parameter);
IEdmOperationParameter operationParameter = Assert.IsType <EdmOperationParameter>(parameter);
}
}
public void ParsingOptionalParametersShouldSucceed()
{
string csdl =
"<edmx:Edmx xmlns:edmx=\"http://docs.oasis-open.org/odata/ns/edmx\" Version=\"4.0\">" +
"<edmx:DataServices>" +
"<Schema xmlns=\"http://docs.oasis-open.org/odata/ns/edm\" Namespace=\"test\">" +
"<Function Name=\"TestFunction\">" +
"<Parameter Name = \"requiredParam\" Type=\"Edm.String\"/>" +
"<Parameter Name = \"optionalParam\" Type=\"Edm.String\">" +
"<Annotation Term=\"Org.OData.Core.V1.OptionalParameter\"/>" +
"</Parameter>" +
"<Parameter Name = \"optionalParamWithDefault\" Type=\"Edm.String\">" +
"<Annotation Term=\"Org.OData.Core.V1.OptionalParameter\">" +
"<Record>" +
"<PropertyValue Property=\"DefaultValue\" String=\"Smith\"/>" +
"</Record>" +
"</Annotation>" +
"</Parameter>" +
"<ReturnType Type=\"Edm.Boolean\"/>" +
"</Function>" +
"<EntityContainer Name=\"Default\">" +
"<FunctionImport Name=\"TestFunction\" Function=\"test.TestFunction\"/>" +
"</EntityContainer>" +
"</Schema>" +
"</edmx:DataServices>" +
"</edmx:Edmx>";
var model = CsdlReader.Parse(XElement.Parse(csdl).CreateReader());
var function = model.FindDeclaredOperations("test.TestFunction").FirstOrDefault();
Assert.NotNull(function);
var requiredParam = function.Parameters.Where(p => p.Name == "requiredParam").FirstOrDefault();
Assert.NotNull(requiredParam);
Assert.Null(requiredParam as IEdmOptionalParameter);
IEdmOptionalParameter optionalParam = function.Parameters.Where(p => p.Name == "optionalParam").FirstOrDefault() as IEdmOptionalParameter;
Assert.NotNull(optionalParam);
Assert.True(String.IsNullOrEmpty(optionalParam.DefaultValueString));
IEdmOptionalParameter optionalParamWithDefault = function.Parameters.Where(p => p.Name == "optionalParamWithDefault").FirstOrDefault() as IEdmOptionalParameter;
Assert.NotNull(optionalParamWithDefault);
Assert.Equal(optionalParamWithDefault.DefaultValueString, "Smith");
}
/// <summary>
/// Splits the parameters into parts, one is the required parameters, the other is optional parameters.
/// </summary>
/// <param name="edmFunction">The input function.</param>
/// <returns></returns>
private static (IList <IEdmOperationParameter>, IList <IEdmOptionalParameter>) SplitParameters(IEdmFunction edmFunction)
{
IList <IEdmOperationParameter> fixes = new List <IEdmOperationParameter>();
IList <IEdmOptionalParameter> optionals = new List <IEdmOptionalParameter>();
int skip = edmFunction.IsBound ? 1 : 0;
foreach (var parameter in edmFunction.Parameters.Skip(skip))
{
IEdmOptionalParameter optional = parameter as IEdmOptionalParameter;
if (optional != null)
{
optionals.Add(optional);
}
else
{
fixes.Add(parameter);
}
}
return(fixes, optionals);
}
internal override void WriteOperationParameterEndElement(IEdmOperationParameter parameter)
{
IEdmOptionalParameter optionalParameter = parameter as IEdmOptionalParameter;
if (optionalParameter != null && !(optionalParameter.VocabularyAnnotations(this.Model).Any(a => a.Term == CoreVocabularyModel.OptionalParameterTerm)))
{
string defaultValue = optionalParameter.DefaultValueString;
EdmRecordExpression optionalValue = new EdmRecordExpression();
this.WriteVocabularyAnnotationElementHeader(new EdmVocabularyAnnotation(parameter, CoreVocabularyModel.OptionalParameterTerm, optionalValue), false);
if (!String.IsNullOrEmpty(defaultValue))
{
EdmPropertyConstructor property = new EdmPropertyConstructor(CsdlConstants.Attribute_DefaultValue, new EdmStringConstant(defaultValue));
this.WriteRecordExpressionElementHeader(optionalValue);
this.WritePropertyValueElementHeader(property, true);
this.WriteEndElement();
this.WriteEndElement();
}
this.WriteEndElement();
}
this.WriteEndElement();
}
public void Add(IEdmOptionalParameter parameter)
{
_optionalParameters.Add(parameter);
}
