public void GetEdmModel_SetsNullableIffParameterTypeIsNullable() { // Arrange ODataModelBuilder builder = new ODataModelBuilder(); EntityTypeConfiguration <Movie> movie = builder.EntitySet <Movie>("Movies").EntityType; var actionBuilder = movie.Action("Watch"); actionBuilder.Parameter <int>("int"); actionBuilder.Parameter <Nullable <int> >("nullableOfInt"); actionBuilder.Parameter <DateTime>("dateTime"); actionBuilder.Parameter <string>("string"); // Act IEdmModel model = builder.GetEdmModel(); //Assert IEdmEntityContainer container = model.SchemaElements.OfType <IEdmEntityContainer>().SingleOrDefault(); IEdmFunctionImport action = container.FindFunctionImports("Watch").Single(); Assert.False(action.FindParameter("int").Type.IsNullable); Assert.True(action.FindParameter("nullableOfInt").Type.IsNullable); Assert.False(action.FindParameter("dateTime").Type.IsNullable); Assert.True(action.FindParameter("string").Type.IsNullable); }
private static bool TryParseFunctionParameters <TParam>(ICollection <FunctionParameterToken> splitParameters, ODataUriParserConfiguration configuration, IEdmFunctionImport functionImport, Func <string, object, TParam> createParameter, out ICollection <TParam> parsedParameters) { Debug.Assert(splitParameters != null, "splitParameters != null"); Debug.Assert(createParameter != null, "createParameter != null"); Debug.Assert(configuration != null, "configuration != null"); Debug.Assert(functionImport != null, "functionImport != null"); parsedParameters = new List <TParam>(splitParameters.Count); foreach (var splitParameter in splitParameters) { TParam parameter; IEdmTypeReference expectedType = null; IEdmFunctionParameter edmFunctionParameter = null; try { edmFunctionParameter = functionImport.FindParameter(splitParameter.ParameterName); } catch (InvalidOperationException ex) { // this can throw an exception if there are multiple parameters with the same name.. // catch that exception and throw something more sane. throw new ODataException(ODataErrorStrings.FunctionCallParser_DuplicateParameterName, ex); } Debug.Assert(edmFunctionParameter != null, "At this point we should know that the parameter names match the given function import."); expectedType = edmFunctionParameter.Type; if (!TryCreateParameter(splitParameter, configuration, expectedType, o => createParameter(splitParameter.ParameterName, o), out parameter)) { return(false); } parsedParameters.Add(parameter); } return(true); }
private IEdmVocabularyAnnotatable ComputeTarget() { if (this.targetContext != null) { return(this.targetContext); } else { Debug.Assert(this.annotationsContext != null, "Annotation must either have a target context or annotations context"); string target = this.annotationsContext.Annotations.Target; string[] targetSegments = target.Split('/'); int targetSegmentsCount = targetSegments.Count(); IEdmEntityContainer container; if (targetSegmentsCount == 1) { string elementName = targetSegments[0]; IEdmSchemaType type = this.schema.FindType(elementName); if (type != null) { return(type); } IEdmValueTerm term = this.schema.FindValueTerm(elementName); if (term != null) { return(term); } IEdmFunction function = this.FindParameterizedFunction(elementName, this.Schema.FindFunctions, this.CreateAmbiguousFunction); if (function != null) { return(function); } container = this.schema.FindEntityContainer(elementName); if (container != null) { return(container); } return(new UnresolvedType(this.Schema.UnresolvedName(targetSegments[0]), this.Location)); } if (targetSegmentsCount == 2) { container = this.schema.FindEntityContainer(targetSegments[0]); if (container != null) { IEdmEntityContainerElement containerElement = container.FindEntitySet(targetSegments[1]); if (containerElement != null) { return(containerElement); } IEdmFunctionImport functionImport = this.FindParameterizedFunction(targetSegments[1], container.FindFunctionImports, this.CreateAmbiguousFunctionImport); if (functionImport != null) { return(functionImport); } return(new UnresolvedEntitySet(targetSegments[1], container, this.Location)); } IEdmStructuredType type = this.schema.FindType(targetSegments[0]) as IEdmStructuredType; if (type != null) { IEdmProperty property = type.FindProperty(targetSegments[1]); if (property != null) { return(property); } return(new UnresolvedProperty(type, targetSegments[1], this.Location)); } IEdmFunction function = this.FindParameterizedFunction(targetSegments[0], this.Schema.FindFunctions, this.CreateAmbiguousFunction); if (function != null) { IEdmFunctionParameter parameter = function.FindParameter(targetSegments[1]); if (parameter != null) { return(parameter); } return(new UnresolvedParameter(function, targetSegments[1], this.Location)); } return(new UnresolvedProperty(new UnresolvedEntityType(this.Schema.UnresolvedName(targetSegments[0]), this.Location), targetSegments[1], this.Location)); } if (targetSegmentsCount == 3) { container = this.Model.FindEntityContainer(targetSegments[0]); if (container != null) { IEdmFunctionImport functionImport = this.FindParameterizedFunction(targetSegments[1], container.FindFunctionImports, this.CreateAmbiguousFunctionImport); if (functionImport != null) { IEdmFunctionParameter parameter = functionImport.FindParameter(targetSegments[2]); if (parameter != null) { return(parameter); } return(new UnresolvedParameter(functionImport, targetSegments[1], this.Location)); } } } return(new BadElement(new EdmError[] { new EdmError(this.Location, EdmErrorCode.ImpossibleAnnotationsTarget, Edm.Strings.CsdlSemantics_ImpossibleAnnotationsTarget(target)) })); } }
private IEdmVocabularyAnnotatable ComputeTarget() { IEdmEntityContainer edmEntityContainer; if (this.targetContext == null) { string target = this.annotationsContext.Annotations.Target; char[] chrArray = new char[1]; chrArray[0] = '/'; string[] strArrays = target.Split(chrArray); int num = strArrays.Count <string>(); if (num != 1) { if (num != 2) { if (num == 3) { edmEntityContainer = this.Model.FindEntityContainer(strArrays[0]); if (edmEntityContainer != null) { IEdmEntityContainer edmEntityContainer1 = edmEntityContainer; IEdmFunctionImport edmFunctionImport = this.FindParameterizedFunction <IEdmFunctionImport>(strArrays[1], new Func <string, IEnumerable <IEdmFunctionImport> >(edmEntityContainer1.FindFunctionImports), new Func <IEnumerable <IEdmFunctionImport>, IEdmFunctionImport>(this.CreateAmbiguousFunctionImport)); if (edmFunctionImport != null) { IEdmFunctionParameter edmFunctionParameter = edmFunctionImport.FindParameter(strArrays[2]); if (edmFunctionParameter == null) { return(new UnresolvedParameter(edmFunctionImport, strArrays[1], base.Location)); } else { return(edmFunctionParameter); } } } } EdmError[] edmError = new EdmError[1]; edmError[0] = new EdmError(base.Location, EdmErrorCode.ImpossibleAnnotationsTarget, Strings.CsdlSemantics_ImpossibleAnnotationsTarget(target)); return(new BadElement(edmError)); } else { edmEntityContainer = this.schema.FindEntityContainer(strArrays[0]); if (edmEntityContainer == null) { IEdmStructuredType edmStructuredType = this.schema.FindType(strArrays[0]) as IEdmStructuredType; if (edmStructuredType == null) { IEdmFunction edmFunction = this.FindParameterizedFunction <IEdmFunction>(strArrays[0], new Func <string, IEnumerable <IEdmFunction> >(this.Schema.FindFunctions), new Func <IEnumerable <IEdmFunction>, IEdmFunction>(this.CreateAmbiguousFunction)); if (edmFunction == null) { return(new UnresolvedProperty(new UnresolvedEntityType(this.Schema.UnresolvedName(strArrays[0]), base.Location), strArrays[1], base.Location)); } else { IEdmFunctionParameter edmFunctionParameter1 = edmFunction.FindParameter(strArrays[1]); if (edmFunctionParameter1 == null) { return(new UnresolvedParameter(edmFunction, strArrays[1], base.Location)); } else { return(edmFunctionParameter1); } } } else { IEdmProperty edmProperty = edmStructuredType.FindProperty(strArrays[1]); if (edmProperty == null) { return(new UnresolvedProperty(edmStructuredType, strArrays[1], base.Location)); } else { return(edmProperty); } } } else { IEdmEntityContainerElement edmEntityContainerElement = edmEntityContainer.FindEntitySet(strArrays[1]); if (edmEntityContainerElement == null) { IEdmEntityContainer edmEntityContainer2 = edmEntityContainer; IEdmFunctionImport edmFunctionImport1 = this.FindParameterizedFunction <IEdmFunctionImport>(strArrays[1], new Func <string, IEnumerable <IEdmFunctionImport> >(edmEntityContainer2.FindFunctionImports), new Func <IEnumerable <IEdmFunctionImport>, IEdmFunctionImport>(this.CreateAmbiguousFunctionImport)); if (edmFunctionImport1 == null) { return(new UnresolvedEntitySet(strArrays[1], edmEntityContainer, base.Location)); } else { return(edmFunctionImport1); } } else { return(edmEntityContainerElement); } } } } else { string str = strArrays[0]; IEdmSchemaType edmSchemaType = this.schema.FindType(str); if (edmSchemaType == null) { IEdmValueTerm edmValueTerm = this.schema.FindValueTerm(str); if (edmValueTerm == null) { IEdmFunction edmFunction1 = this.FindParameterizedFunction <IEdmFunction>(str, new Func <string, IEnumerable <IEdmFunction> >(this.Schema.FindFunctions), new Func <IEnumerable <IEdmFunction>, IEdmFunction>(this.CreateAmbiguousFunction)); if (edmFunction1 == null) { edmEntityContainer = this.schema.FindEntityContainer(str); if (edmEntityContainer == null) { return(new UnresolvedType(this.Schema.UnresolvedName(strArrays[0]), base.Location)); } else { return(edmEntityContainer); } } else { return(edmFunction1); } } else { return(edmValueTerm); } } else { return(edmSchemaType); } } } else { return(this.targetContext); } }