internal static IEdmOperation[] CalculateBindableOperationsForType(IEdmType bindingType, IEdmModel model, EdmTypeResolver edmTypeResolver) { Debug.Assert(model != null, "model != null"); Debug.Assert(edmTypeResolver != null, "edmTypeResolver != null"); List <IEdmOperation> operations = null; try { operations = model.FindBoundOperations(bindingType).ToList(); } catch (Exception exc) { if (!ExceptionUtils.IsCatchableExceptionType(exc)) { throw; } throw new ODataException(Strings.MetadataUtils_CalculateBindableOperationsForType(bindingType.FullTypeName()), exc); } List <IEdmOperation> operationsFound = new List <IEdmOperation>(); foreach (IEdmOperation operation in operations.EnsureOperationsBoundWithBindingParameter()) { IEdmOperationParameter bindingParameter = operation.Parameters.FirstOrDefault(); IEdmType resolvedBindingType = edmTypeResolver.GetParameterType(bindingParameter).Definition; if (resolvedBindingType.IsAssignableFrom(bindingType)) { operationsFound.Add(operation); } } return(operationsFound.ToArray()); }
public void CanCreateEdmModel_WithDateAndTimeOfDay_AsFunctionParameter(Type paramType, string expect) { // Arrange ODataModelBuilder builder = ODataModelBuilderMocks.GetModelBuilderMock <ODataModelBuilder>(); EntityTypeConfiguration <Movie> movie = builder.EntitySet <Movie>("Movies").EntityType; var functionBuilder = movie.Function("FunctionName").Returns <int>(); functionBuilder.Parameter(paramType, "p1"); MethodInfo method = typeof(OperationConfiguration).GetMethod("CollectionParameter", BindingFlags.Instance | BindingFlags.Public); method.MakeGenericMethod(paramType).Invoke(functionBuilder, new[] { "p2" }); // Act IEdmModel model = builder.GetEdmModel(); //Assert IEdmOperation function = Assert.Single(model.SchemaElements.OfType <IEdmFunction>()); Assert.Equal("FunctionName", function.Name); IEdmOperationParameter parameter = function.FindParameter("p1"); Assert.Equal(expect, parameter.Type.FullName()); Assert.Equal(TypeHelper.IsNullable(paramType), parameter.Type.IsNullable); parameter = function.FindParameter("p2"); Assert.Equal("Collection(" + expect + ")", parameter.Type.FullName()); Assert.Equal(TypeHelper.IsNullable(paramType), parameter.Type.IsNullable); }
/// <summary> /// Gets the parameter value. /// </summary> /// <param name="parameterName">The name of the parameter.</param> /// <returns> The value of the parameter. </returns> public object GetParameterValue(string parameterName) { if (String.IsNullOrEmpty(parameterName)) { throw Error.ArgumentNullOrEmpty("parameterName"); } string paramValue; if (Values.TryGetValue(parameterName, out paramValue)) { IEdmOperationParameter edmParam = Function.FindParameter(parameterName); if (edmParam != null) { IEdmTypeReference edmType = edmParam.Type; if (edmParam.Type.IsCollection()) { IEdmCollectionTypeReference collectionTypeReference = edmParam.Type.AsCollection(); edmType = collectionTypeReference.ElementType(); } // for entity or collection of entity, return the string literal from Uri. if (edmType.Definition.TypeKind == EdmTypeKind.Entity) { return(paramValue); } return(ODataUriUtils.ConvertFromUriLiteral(paramValue, ODataVersion.V4, _edmModel, edmParam.Type)); } } throw Error.Argument("parameterName", SRResources.FunctionParameterNotFound, parameterName); }
public static bool IsBoundTo(IEdmFunction function, IEdmType type) { Contract.Assert(function != null); Contract.Assert(type != null); // The binding parameter is the first parameter by convention IEdmOperationParameter bindingParameter = function.Parameters.FirstOrDefault(); if (bindingParameter == null) { return(false); } IEdmType fromType; if (bindingParameter.Type.Definition.TypeKind == EdmTypeKind.Collection) { fromType = ((IEdmCollectionType)bindingParameter.Type.Definition).ElementType.Definition; } else { fromType = bindingParameter.Type.Definition; } return(fromType == type); }
/// <summary> /// Resolve an operation parameter's name with case insensitive enabled /// </summary> /// <param name="operation">The operation.</param> /// <param name="identifier">Name for the parameter.</param> /// <returns>The resolved operation parameter.</returns> internal static IEdmOperationParameter ResolveOperationParameterNameCaseInsensitive(IEdmOperation operation, string identifier) { // first look for a case-sensitive match var list = operation.Parameters.Where(parameter => string.Equals(identifier, parameter.Name, StringComparison.Ordinal)); if (!list.Any()) { // if no case sensitive, try case-insensitive list = operation.Parameters.Where(parameter => string.Equals(identifier, parameter.Name, StringComparison.OrdinalIgnoreCase)); } IEdmOperationParameter resolvedOperationParameter = null; foreach (var parameter in list) { if (resolvedOperationParameter == null) { resolvedOperationParameter = parameter; } else { throw new ODataException(Strings.UriParserMetadata_MultipleMatchingParametersFound(identifier)); } } return(resolvedOperationParameter); }
internal ClassProperty(IServiceProvider services, IEdmOperationParameter parameter, IModelTypeBuilder typeBuilder) { Contract.Requires(services != null); Contract.Requires(parameter != null); Contract.Requires(typeBuilder != null); Name = parameter.Name; var context = new TypeSubstitutionContext(services, typeBuilder); if (parameter.Type.IsCollection()) { var collectionType = parameter.Type.AsCollection(); var elementType = collectionType.ElementType().Definition.GetClrType(services.GetRequiredService <IEdmModel>()); var substitutedType = elementType.SubstituteIfNecessary(context); Type = typeof(IEnumerable <>).MakeGenericType(substitutedType); } else { var parameterType = parameter.Type.Definition.GetClrType(services.GetRequiredService <IEdmModel>()); Type = parameterType.SubstituteIfNecessary(context); } Attributes = AttributesFromOperationParameter(parameter); }
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); }
private void VerifyFindParameterMethod(XElement sourceCsdl, IEdmModel testModel) { var csdlNamespace = EdmLibCsdlContentGenerator.GetCsdlFullNamespace(this.EdmVersion); Assert.AreEqual(csdlNamespace, sourceCsdl.Name.Namespace, "The source CSDL's namespace should match the target EDM version of the test cases."); var namespaceValue = sourceCsdl.Attribute("Namespace").Value; var schemaElementTypes = new string[] { "Parameter" }; foreach (var schemaElementType in schemaElementTypes) { Console.WriteLine("Test CSDL:\n\r{0}", sourceCsdl.ToString()); foreach (var parameterElement in sourceCsdl.Descendants().Elements(XName.Get(schemaElementType, csdlNamespace.NamespaceName))) { IEdmOperationParameter parameterFound = null; var paramterName = parameterElement.Attribute("Name").Value; Assert.IsTrue(new string[] { "Function", "Action" }.Any(n => n == parameterElement.Parent.Name.LocalName), "<Parameter> is used in {0}", parameterElement.Parent.Name.LocalName); IEdmOperation elementFound; var schemaElementName = string.Format("{0}.{1}", namespaceValue, parameterElement.Parent.Attribute("Name").Value); elementFound = testModel.FindOperations(schemaElementName).Where(n => n.FindParameter(paramterName) != null).FirstOrDefault(); parameterFound = elementFound.FindParameter(paramterName); Assert.IsNotNull(parameterFound, "Faild to FindParameter for the parameter : {0}", paramterName); Assert.AreEqual(parameterFound.Name, paramterName, "FindParameter returns a wrong parameter for {0}", parameterElement.Attribute("Name").Value); } } }
/// <summary> /// Resolve operation's parameters. /// </summary> /// <param name="operation">Current operation for parameters.</param> /// <param name="input">A dictionary the parameter list.</param> /// <returns>A dictionary containing resolved parameters.</returns> public virtual IDictionary <IEdmOperationParameter, SingleValueNode> ResolveOperationParameters(IEdmOperation operation, IDictionary <string, SingleValueNode> input) { Dictionary <IEdmOperationParameter, SingleValueNode> result = new Dictionary <IEdmOperationParameter, SingleValueNode>(EqualityComparer <IEdmOperationParameter> .Default); foreach (var item in input) { IEdmOperationParameter functionParameter = null; if (EnableCaseInsensitive) { functionParameter = ResolveOpearationParameterNameCaseInsensitive(operation, item.Key); } else { functionParameter = operation.FindParameter(item.Key); } // ensure parameter name existis if (functionParameter == null) { throw new ODataException(Strings.ODataParameterWriterCore_ParameterNameNotFoundInOperation(item.Key, operation.Name)); } result.Add(functionParameter, item.Value); } return(result); }
private static ICollection <FunctionParameterToken> HandleComplexOrCollectionParameterValueIfExists(IEdmModel model, IEdmOperation operation, ICollection <FunctionParameterToken> parameterTokens, bool enableCaseInsensitive, bool enableUriTemplateParsing = false) { ICollection <FunctionParameterToken> partiallyParsedParametersWithComplexOrCollection = new Collection <FunctionParameterToken>(); foreach (FunctionParameterToken paraToken in parameterTokens) { FunctionParameterToken funcParaToken; IEdmOperationParameter functionParameter = operation.FindParameter(paraToken.ParameterName); if (enableCaseInsensitive && functionParameter == null) { functionParameter = ODataUriResolver.ResolveOpearationParameterNameCaseInsensitive(operation, paraToken.ParameterName); // The functionParameter can not be null here, else this method won't be called. funcParaToken = new FunctionParameterToken(functionParameter.Name, paraToken.ValueToken); } else { funcParaToken = paraToken; } FunctionParameterAliasToken aliasToken = funcParaToken.ValueToken as FunctionParameterAliasToken; if (aliasToken != null) { aliasToken.ExpectedParameterType = functionParameter.Type; } LiteralToken valueToken = funcParaToken.ValueToken as LiteralToken; string valueStr = null; if (valueToken != null && (valueStr = valueToken.Value as string) != null && !string.IsNullOrEmpty(valueToken.OriginalText)) { var lexer = new ExpressionLexer(valueToken.OriginalText, true /*moveToFirstToken*/, false /*useSemicolonDelimiter*/, true /*parsingFunctionParameters*/); if (lexer.CurrentToken.Kind == ExpressionTokenKind.BracketedExpression) { object result; UriTemplateExpression expression; if (enableUriTemplateParsing && UriTemplateParser.TryParseLiteral(lexer.CurrentToken.Text, functionParameter.Type, out expression)) { result = expression; } else { // ExpressionTokenKind.BracketedExpression means text like [{\"Street\":\"NE 24th St.\",\"City\":\"Redmond\"},{\"Street\":\"Pine St.\",\"City\":\"Seattle\"}] // so now try convert it into complex or collection type value: result = ODataUriUtils.ConvertFromUriLiteral(valueStr, ODataVersion.V4, model, functionParameter.Type); } LiteralToken newValueToken = new LiteralToken(result, valueToken.OriginalText); FunctionParameterToken newFuncParaToken = new FunctionParameterToken(funcParaToken.ParameterName, newValueToken); partiallyParsedParametersWithComplexOrCollection.Add(newFuncParaToken); continue; } } partiallyParsedParametersWithComplexOrCollection.Add(funcParaToken); } return(partiallyParsedParametersWithComplexOrCollection); }
private static IEdmCollectionTypeReference GetCollectionParameterType(IEdmAction action, ODataParameterReader reader, out string parameterName) { IEdmOperationParameter parameter = GetParameter(action, reader, out parameterName); IEdmCollectionTypeReference collectionType = parameter.Type as IEdmCollectionTypeReference; Contract.Assert(collectionType != null); return(collectionType); }
public static IList <OperationSegmentParameter> Match(ODataTemplateTranslateContext context, IEdmFunction function, IDictionary <string, string> parameterMappings) { Contract.Assert(context != null); Contract.Assert(function != null); Contract.Assert(parameterMappings != null); RouteValueDictionary routeValues = context.RouteValues; IList <OperationSegmentParameter> parameters = new List <OperationSegmentParameter>(); foreach (var parameter in parameterMappings) { string parameterName = parameter.Key; string parameterTemp = parameter.Value; IEdmOperationParameter edmParameter = function.Parameters.FirstOrDefault(p => p.Name == parameterName); Contract.Assert(edmParameter != null); // For a parameter mapping like: minSalary={min} // and a request like: ~/MyFunction(minSalary=2) // the routeValue includes the [min=2], so we should use the mapping name to retrieve the value. if (routeValues.TryGetValue(parameterTemp, out object rawValue)) { string strValue = rawValue as string; strValue = context.GetParameterAliasOrSelf(strValue); // for resource or collection resource, this method will return "ODataResourceValue, ..." we should support it. if (edmParameter.Type.IsResourceOrCollectionResource()) { // For FromODataUri string prefixName = ODataParameterValue.ParameterValuePrefix + parameterTemp; routeValues[prefixName] = new ODataParameterValue(strValue, edmParameter.Type); parameters.Add(new OperationSegmentParameter(parameterName, strValue)); } else { object newValue = ODataUriUtils.ConvertFromUriLiteral(strValue, ODataVersion.V4, context.Model, edmParameter.Type); // for without FromODataUri, so update it, for example, remove the single quote for string value. routeValues[parameterTemp] = newValue; // For FromODataUri string prefixName = ODataParameterValue.ParameterValuePrefix + parameterTemp; routeValues[prefixName] = new ODataParameterValue(newValue, edmParameter.Type); parameters.Add(new OperationSegmentParameter(parameterName, newValue)); } } else { return(null); } } return(parameters); }
public void ConvertFunction() { var taupoModel = new EntityModelSchema() { new Function("NS1", "Function1") { ReturnType = EdmDataTypes.Int32, Parameters = { new FunctionParameter("Param1", EdmDataTypes.Int32, FunctionParameterMode.InOut), new FunctionParameter("Param2", EdmDataTypes.Int32, FunctionParameterMode.Out) { new AttributeAnnotation() { Content = new XAttribute(this.annotationNamespace + "foo1","bar1") }, }, }, Annotations = { new AttributeAnnotation() { Content = new XAttribute(this.annotationNamespace + "foo2", "bar2") }, }, }, }; IEdmModel result = this.converter.ConvertToEdmModel(taupoModel); Assert.AreEqual(1, result.SchemaElements.Count()); Assert.AreEqual(1, result.SchemaElements.OfType <IEdmOperation>().Count()); IEdmOperation operation = result.SchemaElements.OfType <IEdmOperation>().First(); Assert.AreEqual("NS1.Function1", operation.FullName()); Assert.AreEqual("Edm.Int32", operation.ReturnType.FullName()); Assert.AreEqual(2, operation.Parameters.Count()); IEdmOperationParameter p1 = operation.Parameters.ElementAt(0); Assert.AreEqual("Param1", p1.Name); IEdmOperationParameter p2 = operation.Parameters.ElementAt(1); Assert.AreEqual("Param2", p2.Name); Assert.AreEqual(1, result.DirectValueAnnotations(p2).Count()); Assert.AreEqual("bogus", result.DirectValueAnnotations(p2).First().NamespaceUri); Assert.AreEqual("foo1", result.DirectValueAnnotations(p2).First().Name); Assert.AreEqual("bar1", (((IEdmDirectValueAnnotation)result.DirectValueAnnotations(p2).First()).Value as IEdmStringValue).Value); Assert.AreEqual(1, result.DirectValueAnnotations(operation).Count()); Assert.AreEqual("bogus", result.DirectValueAnnotations(operation).First().NamespaceUri); Assert.AreEqual("foo2", result.DirectValueAnnotations(operation).First().Name); Assert.AreEqual("bar2", (((IEdmDirectValueAnnotation)result.DirectValueAnnotations(operation).First()).Value as IEdmStringValue).Value); }
internal ClassProperty(IEnumerable <Assembly> assemblies, IEdmOperationParameter parameter) { Contract.Requires(assemblies != null); Contract.Requires(parameter != null); Name = parameter.Name; Type = parameter.Type.Definition.GetClrType(assemblies); Attributes = AttributesFromOperationParameter(parameter); }
/// <summary> /// Reads Parameter names and values provided by a client in a POST request to invoke a particular Action. /// </summary> /// <param name="messageReader">Reader used to read all OData payloads (entries, feeds, metadata documents, service documents, etc.).</param> /// <param name="action">Represents an EDM operation.</param> /// <param name="readContext"> /// Encapsulates the state and settings that get passed to System.Web.OData.Formatter.Deserialization.ODataDeserializer from the System.Web.OData.Formatter.ODataMediaTypeFormatter. /// </param> /// <returns>ActionPayload holds the Parameter names and values provided by a client in a POST request to invoke a particular Action.</returns> private ODataActionParameters ReadParams(ODataMessageReader messageReader, IEdmOperation action, ODataDeserializerContext readContext) { // Create the correct resource type; ODataActionParameters payload = new ODataActionParameters(); try { ODataParameterReader reader = messageReader.CreateODataParameterReader(action); while (reader.Read()) { string parameterName = null; IEdmOperationParameter parameter = null; switch (reader.State) { case ODataParameterReaderState.Value: parameterName = reader.Name; parameter = action.Parameters.SingleOrDefault(p => p.Name == parameterName); // ODataLib protects against this but asserting just in case. Contract.Assert(parameter != null, String.Format(CultureInfo.InvariantCulture, "Parameter '{0}' not found.", parameterName)); if (parameter.Type.IsPrimitive()) { payload[parameterName] = reader.Value; } else { ODataEdmTypeDeserializer deserializer = DefaultODataDeserializerProvider.Instance.GetEdmTypeDeserializer(parameter.Type); payload[parameterName] = deserializer.ReadInline(reader.Value, parameter.Type, readContext); } break; case ODataParameterReaderState.Collection: parameterName = reader.Name; parameter = action.Parameters.SingleOrDefault(p => p.Name == parameterName); // ODataLib protects against this but asserting just in case. Contract.Assert(parameter != null, String.Format(CultureInfo.InvariantCulture, "Parameter '{0}' not found.", parameterName)); IEdmCollectionTypeReference collectionType = parameter.Type as IEdmCollectionTypeReference; Contract.Assert(collectionType != null); ODataCollectionValue value = ReadCollection(reader.CreateCollectionReader()); ODataCollectionDeserializer collectionDeserializer = DefaultODataDeserializerProvider.Instance.GetEdmTypeDeserializer(collectionType) as ODataCollectionDeserializer; payload[parameterName] = collectionDeserializer.ReadInline(value, collectionType, readContext); break; default: break; } } } catch (Exception exception) { DynamicLogger.Instance.WriteLoggerLogError("ReadParams", exception); throw; } return(payload); }
private static IEdmOperationParameter GetParameter(IEdmAction action, ODataParameterReader reader, out string parameterName) { string paramName = parameterName = reader.Name; IEdmOperationParameter parameter = action.Parameters.SingleOrDefault(p => p.Name == paramName); // ODataLib protects against this but asserting just in case. Contract.Assert(parameter != null, String.Format(CultureInfo.InvariantCulture, "Parameter '{0}' not found.", parameterName)); return(parameter); }
internal void WriteOperationParameterElementHeader(IEdmOperationParameter parameter, bool inlineType) { this.xmlWriter.WriteStartElement(CsdlConstants.Element_Parameter); this.WriteRequiredAttribute(CsdlConstants.Attribute_Name, parameter.Name, EdmValueWriter.StringAsXml); if (inlineType) { this.WriteRequiredAttribute(CsdlConstants.Attribute_Type, parameter.Type, this.TypeReferenceAsXml); } }
public static IEdmTypeReference GetOperationType(this IEdmOperationParameter edmOperationParameter) { Contract.Requires(edmOperationParameter != null); Contract.Ensures(Contract.Result <IEdmTypeReference>() != null); var result = edmOperationParameter.Type; Contract.Assume(result != null); return(result); }
/// <summary> /// Initializes a new instance of the <see cref="EdmNavigationSourceGenerator" /> class. /// </summary> /// <param name="model">The Edm model.</param> /// <param name="settings">The Open Api writer settings.</param> public EdmNavigationSourceGenerator(IEdmModel model, OpenApiWriterSettings settings) : base(model, settings) { _boundOperations = new Dictionary <IEdmTypeReference, IEdmOperation>(); foreach (var edmOperation in model.SchemaElements.OfType <IEdmOperation>().Where(e => e.IsBound)) { IEdmOperationParameter bindingParameter = edmOperation.Parameters.First(); _boundOperations.Add(bindingParameter.Type, edmOperation); } }
private static void ValidateNoError(IEdmModel model, IEdmOperation operation) { IEnumerable <EdmError> errorsFound = null; IEdmOperationParameter operationParameter = null; IEnumerable <IEdmNavigationProperty> navigationProperties = null; IEdmEntityType entityType = null; operation.TryGetRelativeEntitySetPath(model, out operationParameter, out navigationProperties, out entityType, out errorsFound); errorsFound.Should().HaveCount(0); }
internal static string FullyQualifiedName(IEdmVocabularyAnnotatable element) { IEdmSchemaElement schemaElement = element as IEdmSchemaElement; if (schemaElement != null) { IEdmOperation operation = schemaElement as IEdmOperation; if (operation != null) { return(ParameterizedName(operation)); } else { return(schemaElement.FullName()); } } else { IEdmEntityContainerElement containerElement = element as IEdmEntityContainerElement; if (containerElement != null) { return(containerElement.Container.FullName() + "/" + containerElement.Name); } else { IEdmProperty property = element as IEdmProperty; if (property != null) { IEdmSchemaType declaringSchemaType = property.DeclaringType as IEdmSchemaType; if (declaringSchemaType != null) { string propertyOwnerName = FullyQualifiedName(declaringSchemaType); if (propertyOwnerName != null) { return(propertyOwnerName + "/" + property.Name); } } } else { IEdmOperationParameter parameter = element as IEdmOperationParameter; if (parameter != null) { string parameterOwnerName = FullyQualifiedName(parameter.DeclaringOperation); if (parameterOwnerName != null) { return(parameterOwnerName + "/" + parameter.Name); } } } } } return(null); }
private FunctionParameter ConvertToTaupoFunctionParameter(IEdmOperationParameter edmOperationParameter) { var taupoFunctionParameter = new FunctionParameter() { Name = edmOperationParameter.Name, DataType = this.ConvertToTaupoDataType(edmOperationParameter.Type), Mode = FunctionParameterMode.In }; this.ConvertAnnotationsIntoTaupo(edmOperationParameter, taupoFunctionParameter); return(taupoFunctionParameter); }
/// <summary> /// Returns the type reference of the parameter in question. /// </summary> /// <param name="parameterName">Name of the parameter in question.</param> /// <returns>Returns the type reference of the parameter in question.</returns> protected internal IEdmTypeReference GetParameterTypeReference(string parameterName) { Debug.Assert(!string.IsNullOrEmpty(parameterName), "!string.IsNullOrEmpty(parameterName)"); IEdmOperationParameter parameter = this.Operation.FindParameter(parameterName); if (parameter == null) { throw new ODataException(Strings.ODataParameterReaderCore_ParameterNameNotInMetadata(parameterName, this.Operation.Name)); } return(this.inputContext.EdmTypeResolver.GetParameterType(parameter)); }
private static void ReadResource(IEdmAction action, ODataParameterReader reader, ODataDeserializerContext readContext, ODataDeserializerProvider deserializerProvider, Dictionary <string, object> payload) { string parameterName; IEdmOperationParameter parameter = GetParameter(action, reader, out parameterName); Contract.Assert(parameter.Type.IsStructured()); object item = reader.CreateResourceReader().ReadResourceOrResourceSet(); ODataResourceDeserializer resourceDeserializer = (ODataResourceDeserializer)deserializerProvider.GetEdmTypeDeserializer(parameter.Type); payload[parameterName] = resourceDeserializer.ReadInline(item, parameter.Type, readContext); }
/// <summary> /// Retrieve all bounding <see cref="IEdmOperation"/>. /// </summary> private void RetrieveBoundOperationPaths(OpenApiConvertSettings convertSettings) { foreach (var edmOperation in _model.GetAllElements().OfType <IEdmOperation>().Where(e => e.IsBound)) { if (!CanFilter(edmOperation)) { continue; } IEdmOperationParameter bindingParameter = edmOperation.Parameters.First(); IEdmTypeReference bindingType = bindingParameter.Type; bool isCollection = bindingType.IsCollection(); if (isCollection) { bindingType = bindingType.AsCollection().ElementType(); } if (!bindingType.IsEntity()) { continue; } var firstEntityType = bindingType.AsEntity().EntityDefinition(); bool filter(IEdmNavigationSource z) => z.EntityType() != firstEntityType && z.EntityType().FindAllBaseTypes().Contains(firstEntityType); var allEntitiesForOperation = new IEdmEntityType[] { firstEntityType } .Union(_model.EntityContainer.EntitySets() .Where(filter).Select(x => x.EntityType())) //Search all EntitySets .Union(_model.EntityContainer.Singletons() .Where(filter).Select(x => x.EntityType())) //Search all singletons .Distinct() .ToList(); foreach (var bindingEntityType in allEntitiesForOperation) { // 1. Search for corresponding navigation source path AppendBoundOperationOnNavigationSourcePath(edmOperation, isCollection, bindingEntityType, convertSettings); // 2. Search for generated navigation property AppendBoundOperationOnNavigationPropertyPath(edmOperation, isCollection, bindingEntityType); // 3. Search for derived AppendBoundOperationOnDerived(edmOperation, isCollection, bindingEntityType, convertSettings); // 4. Search for derived generated navigation property AppendBoundOperationOnDerivedNavigationPropertyPath(edmOperation, isCollection, bindingEntityType, convertSettings); } } }
/// <summary> /// Adds a parameter /// </summary> /// <param name="parameter">The parameter to add</param> public void Add(IEdmOperationParameter parameter) { if (parameter.DeclaringOperation == null) { StubEdmOperationParameter stubEdmOperationParameter = parameter as StubEdmOperationParameter; if (stubEdmOperationParameter != null) { stubEdmOperationParameter.DeclaringOperation = this; } } this.parameters.Add(parameter); }
/// <summary> /// Adds a parameter /// </summary> /// <param name="parameter">The parameter to add</param> public void Add(IEdmOperationParameter parameter) { if (parameter.DeclaringOperation == null) { StubEdmOperationParameter stubEdmOperationParameter = parameter as StubEdmOperationParameter; if (stubEdmOperationParameter != null) { stubEdmOperationParameter.DeclaringOperation = this; } } this.parameters.Add(parameter); }
private static string GetFunctionParameterAssignmentPath(IEdmOperationParameter parameter) { Contract.Requires(parameter != null); switch (parameter.Type.Definition.TypeKind) { case EdmTypeKind.Enum: return(parameter.Name + "=" + parameter.Type.FullName() + "\'{" + parameter.Name + "}\',"); default: return(parameter.Name + "=" + "{" + parameter.Name + "},"); } }
private static void ValidateErrorInList(IEdmModel model, IEdmOperation operation, EdmErrorCode expectedErrorCode, string expectedError) { IEnumerable <EdmError> errorsFound = null; IEdmOperationParameter operationParameter = null; IEnumerable <IEdmNavigationProperty> navigationProperties = null; IEdmEntityType entityType = null; operation.TryGetRelativeEntitySetPath(model, out operationParameter, out navigationProperties, out entityType, out errorsFound); var error = errorsFound.SingleOrDefault(e => e.ErrorCode == expectedErrorCode); error.Should().NotBeNull(); error.ErrorMessage.Should().Be(expectedError); }
public static IEdmOperationParameter AssertHasParameter(this IEdmFunction function, IEdmModel model, string parameterName, Type parameterType, bool isNullable) { IEdmOperationParameter parameter = function.FindParameter(parameterName); Assert.NotNull(parameter); IEdmType edmType = model.GetEdmType(parameterType); Assert.Equal(edmType.FullTypeName(), parameter.Type.FullName()); Assert.Equal(isNullable, parameter.Type.IsNullable); return(parameter); }
private static void ValidateError(IEdmModel model, IEdmOperation operation, EdmErrorCode expectedErrorCode, string expectedError) { IEnumerable <EdmError> errorsFound = null; IEdmOperationParameter operationParameter = null; IEnumerable <IEdmNavigationProperty> navigationProperties = null; IEdmEntityType entityType = null; operation.TryGetRelativeEntitySetPath(model, out operationParameter, out navigationProperties, out entityType, out errorsFound); errorsFound.Should().HaveCount(1); var errorsFoundList = errorsFound.ToList(); errorsFoundList[0].ErrorCode.Should().Be(expectedErrorCode); errorsFoundList[0].ErrorMessage.Should().Be(expectedError); }
internal override IEdmTypeReference GetParameterType(IEdmOperationParameter operationParameter) { return operationParameter == null ? null : this.ResolveTypeReference(operationParameter.Type); }
/// <summary> /// Adds a parameter to this function (as the last parameter). /// </summary> /// <param name="parameter">The parameter being added.</param> public void AddParameter(IEdmOperationParameter parameter) { EdmUtil.CheckArgumentNull(parameter, "parameter"); this.parameters.Add(parameter); }
internal override IEdmTypeReference GetParameterType(IEdmOperationParameter operationParameter) { return operationParameter == null ? null : operationParameter.Type; }
private FunctionParameter ConvertToTaupoFunctionParameter(IEdmOperationParameter edmOperationParameter) { var taupoFunctionParameter = new FunctionParameter() { Name = edmOperationParameter.Name, DataType = this.ConvertToTaupoDataType(edmOperationParameter.Type), Mode = FunctionParameterMode.In }; this.ConvertAnnotationsIntoTaupo(edmOperationParameter, taupoFunctionParameter); return taupoFunctionParameter; }
/// <summary> /// Initializes a new instance of the <see cref="EdmParameterReferenceExpression"/> class. /// </summary> /// <param name="referencedParameter">Referenced parameter</param> public EdmParameterReferenceExpression(IEdmOperationParameter referencedParameter) { EdmUtil.CheckArgumentNull(referencedParameter, "referencedParameter"); this.referencedParameter = referencedParameter; }
/// <summary> /// Gets the function parameter type. /// </summary> /// <param name="operationParameter">The function parameter to get the type for.</param> /// <returns>The <see cref="IEdmTypeReference"/> representing the type on the function parameter; or null if no such type could be found.</returns> internal abstract IEdmTypeReference GetParameterType(IEdmOperationParameter operationParameter);
private async Task WriteOperationParameterAsync(ODataParameterWriter parameterWriter, IEdmOperationParameter operationParameter, string paramName, object paramValue) { switch (operationParameter.Type.Definition.TypeKind) { case EdmTypeKind.Primitive: case EdmTypeKind.Enum: case EdmTypeKind.Complex: await parameterWriter.WriteValueAsync(paramName, paramValue); break; case EdmTypeKind.Entity: var entryWriter = await parameterWriter.CreateEntryWriterAsync(paramName); var entry = CreateODataEntry(operationParameter.Type.Definition.FullTypeName(), paramValue.ToDictionary()); await entryWriter.WriteStartAsync(entry); await entryWriter.WriteEndAsync(); break; case EdmTypeKind.Collection: var collectionType = operationParameter.Type.Definition as IEdmCollectionType; var elementType = collectionType.ElementType; if (elementType.Definition.TypeKind == EdmTypeKind.Entity) { var feedWriter = await parameterWriter.CreateFeedWriterAsync(paramName); var feed = new ODataFeed(); await feedWriter.WriteStartAsync(feed); foreach (var item in paramValue as IEnumerable) { var feedEntry = CreateODataEntry(elementType.Definition.FullTypeName(), item.ToDictionary()); await feedWriter.WriteStartAsync(feedEntry); await feedWriter.WriteEndAsync(); } await feedWriter.WriteEndAsync(); } else { var collectionWriter = await parameterWriter.CreateCollectionWriterAsync(paramName); await collectionWriter.WriteStartAsync(new ODataCollectionStart()); foreach (var item in paramValue as IEnumerable) { await collectionWriter.WriteItemAsync(item); } await collectionWriter.WriteEndAsync(); } break; default: throw new NotSupportedException(string.Format("Unable to write action parameter of a type {0}", operationParameter.Type.Definition.TypeKind)); } }
internal void GetParameterStrings(bool isBound, bool isAction, IEdmOperationParameter[] parameters, out string parameterString, out string parameterTypes, out string parameterExpressionString, out string parameterValues, out bool useEntityReference) { parameterString = string.Empty; parameterExpressionString = string.Empty; parameterTypes = string.Empty; parameterValues = string.Empty; useEntityReference = false; var n = parameters.Count(); for (var i = isBound ? 1 : 0; i < n; ++i) { var param = parameters[i]; if (i == (isBound ? 1 : 0)) { parameterExpressionString += "\r\n "; } var typeName = Utils.GetClrTypeName(param.Type, Context.UseDataServiceCollection, this, Context, true, true, true); parameterString += typeName; parameterString += (" " + GetFixedName(param.Name)); parameterString += i == n - 1 ? string.Empty : ", "; parameterTypes += string.Format(TypeofFormatter, typeName) + ", "; parameterExpressionString += GetParameterExpressionString(param, typeName) + ", "; if (i != (isBound ? 1 : 0)) { parameterValues += ",\r\n "; } if (isAction) { parameterValues += string.Format(BodyOperationParameterConstructor, param.Name, GetFixedName(param.Name)); } else if (param.Type.IsEntity() || (param.Type.IsCollection() && param.Type.AsCollection().ElementType().IsEntity())) { useEntityReference = true; parameterValues += string.Format(UriEntityOperationParameterConstructor, param.Name, GetFixedName(param.Name), "useEntityReference"); } else { parameterValues += string.Format(UriOperationParameterConstructor, param.Name, GetFixedName(param.Name)); } } }
internal string GetParameterExpressionString(IEdmOperationParameter param, string typeName) { string clrTypeName; var edmType = param.Type.Definition; var edmPrimitiveType = edmType as IEdmPrimitiveType; if (edmPrimitiveType != null) { clrTypeName = Utils.GetClrTypeName(edmPrimitiveType, this); if (param.Type.IsNullable && !ClrReferenceTypes.Contains(edmPrimitiveType.PrimitiveKind)) { clrTypeName += "?"; } return string.Format(ConstantExpressionConstructorWithType, GetFixedName(param.Name), clrTypeName); } return string.Format(ConstantExpressionConstructorWithType, GetFixedName(param.Name), typeName); }