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