public Task ExtendModelAsync(
ModelContext context,
CancellationToken cancellationToken)
{
var model = context.Model;
var entityContainer = model.EntityContainer as EdmEntityContainer;
foreach (ActionMethodInfo actionInfo in this.ActionInfos)
{
var returnTypeReference = ConventionalActionProvider.GetReturnTypeReference(actionInfo.Method.ReturnType);
var action = new EdmAction(entityContainer.Namespace, actionInfo.ActionName, returnTypeReference);
foreach (ParameterInfo parameter in actionInfo.Method.GetParameters())
{
EdmOperationParameter actionParam = new EdmOperationParameter(
action,
parameter.Name,
ConventionalActionProvider.GetTypeReference(parameter.ParameterType));
action.AddParameter(actionParam);
}
model.AddElement(action);
if (!action.IsBound)
{
EdmActionImport actionImport = new EdmActionImport(entityContainer, action.Name, action);
entityContainer.AddElement(actionImport);
}
}
return(Task.FromResult <object>(null));
}
private static void BuildOperationParameters(EdmOperation operation, MethodInfo method, IEdmModel model)
{
foreach (var parameter in method.GetParameters())
{
var parameterTypeReference = parameter.ParameterType.GetTypeReference(model);
var operationParam = new EdmOperationParameter(operation, parameter.Name, parameterTypeReference);
operation.AddParameter(operationParam);
}
}
private static void AddOperationParameters(EdmOperation operation, OperationConfiguration operationConfiguration, Dictionary <Type, IEdmType> edmTypeMap)
{
foreach (ParameterConfiguration parameter in operationConfiguration.Parameters)
{
bool isParameterNullable = parameter.Nullable;
IEdmTypeReference parameterTypeReference = GetEdmTypeReference(edmTypeMap, parameter.TypeConfiguration, nullable: isParameterNullable);
IEdmOperationParameter operationParameter = new EdmOperationParameter(operation, parameter.Name, parameterTypeReference);
operation.AddParameter(operationParameter);
}
}
private static void AddProcedureParameters(EdmOperation operation, ProcedureConfiguration procedure, Dictionary <Type, IEdmType> edmTypeMap)
{
foreach (ParameterConfiguration parameter in procedure.Parameters)
{
bool isParameterOptional = parameter.OptionalParameter;
IEdmTypeReference parameterTypeReference = GetEdmTypeReference(edmTypeMap, parameter.TypeConfiguration, nullable: isParameterOptional);
IEdmOperationParameter operationParameter = new EdmOperationParameter(operation, parameter.Name, parameterTypeReference);
operation.AddParameter(operationParameter);
}
}
private static void AddProcedureParameters(EdmOperation operation, ProcedureConfiguration procedure, Dictionary <Type, IEdmType> edmTypeMap)
{
foreach (ParameterConfiguration parameter in procedure.Parameters)
{
// TODO: http://aspnetwebstack.codeplex.com/workitem/417
bool isParameterOptional = EdmLibHelpers.IsNullable(parameter.TypeConfiguration.ClrType);
IEdmTypeReference parameterTypeReference = GetEdmTypeReference(edmTypeMap, parameter.TypeConfiguration, nullable: isParameterOptional);
IEdmOperationParameter operationParameter = new EdmOperationParameter(operation, parameter.Name, parameterTypeReference);
operation.AddParameter(operationParameter);
}
}
private static void BuildOperationParameters(EdmOperation operation, MethodInfo method, IEdmModel model)
{
foreach (ParameterInfo parameter in method.GetParameters())
{
var parameterTypeReference = parameter.ParameterType.GetTypeReference(model);
var operationParam = new EdmOperationParameter(
operation,
parameter.Name,
parameterTypeReference);
operation.AddParameter(operationParam);
}
}
public void ShouldWriteOptionalParameters()
{
string expected =
"<?xml version=\"1.0\" encoding=\"utf-16\"?>" +
"<edmx:Edmx Version=\"4.0\" xmlns:edmx=\"http://docs.oasis-open.org/odata/ns/edmx\">" +
"<edmx:DataServices>" +
"<Schema Namespace=\"test\" xmlns=\"http://docs.oasis-open.org/odata/ns/edm\">" +
"<Function Name=\"TestFunction\">" +
"<Parameter Name=\"requiredParam\" Type=\"Edm.String\" Nullable=\"false\" />" +
"<Parameter Name=\"optionalParam\" Type=\"Edm.String\" Nullable=\"false\">" +
"<Annotation Term=\"Org.OData.Core.V1.OptionalParameter\" />" +
"</Parameter>" +
"<Parameter Name=\"optionalParamWithDefault\" Type=\"Edm.String\" Nullable=\"false\">" +
"<Annotation Term=\"Org.OData.Core.V1.OptionalParameter\">" +
"<Record>" +
"<PropertyValue Property=\"DefaultValue\" String=\"Smith\" />" +
"</Record>" +
"</Annotation>" +
"</Parameter>" +
"<ReturnType Type=\"Edm.String\" Nullable=\"false\" />" +
"</Function>" +
"<EntityContainer Name=\"Default\">" +
"<FunctionImport Name=\"TestFunction\" Function=\"test.TestFunction\" />" +
"</EntityContainer>" +
"</Schema>" +
"</edmx:DataServices>" +
"</edmx:Edmx>";
var stringTypeReference = new EdmStringTypeReference(EdmCoreModel.Instance.GetPrimitiveType(EdmPrimitiveTypeKind.String), false);
var model = new EdmModel();
var function = new EdmFunction("test", "TestFunction", stringTypeReference);
var requiredParam = new EdmOperationParameter(function, "requiredParam", stringTypeReference);
var optionalParam = new EdmOptionalParameter(function, "optionalParam", stringTypeReference, null);
var optionalParamWithDefault = new EdmOptionalParameter(function, "optionalParamWithDefault", stringTypeReference, "Smith");
function.AddParameter(requiredParam);
function.AddParameter(optionalParam);
function.AddParameter(optionalParamWithDefault);
model.AddElement(function);
model.AddEntityContainer("test", "Default").AddFunctionImport("TestFunction", function);
string csdlStr = GetCsdl(model, CsdlTarget.OData);
Assert.Equal(expected, csdlStr);
}
public static EdmModel AnnotationWithValueModel()
{
EdmModel model = new EdmModel();
EdmOperation simpleOperation = new EdmFunction("DefaultNamespace", "SimpleFunction", EdmCoreModel.Instance.GetString(true));
EdmOperationParameter simpleOperationId = new EdmOperationParameter(simpleOperation, "Id", EdmCoreModel.Instance.GetInt32(true));
simpleOperation.AddParameter(simpleOperationId);
model.AddElement(simpleOperation);
XElement annotationElement =
new XElement("{http://foo}Annotation",
"Value 1.0"
);
var annotation = new EdmStringConstant(EdmCoreModel.Instance.GetString(false), annotationElement.ToString());
annotation.SetIsSerializedAsElement(model, true);
model.SetAnnotationValue(simpleOperationId, "http://foo", "Annotation", annotation);
return(model);
}
public static EdmModel OperationImportParameterWithAnnotationModel()
{
EdmModel model = new EdmModel();
EdmEntityContainer container = new EdmEntityContainer("Default", "Container");
EdmAction simpleOperationAction = new EdmAction("Default", "SimpleFunction", EdmCoreModel.Instance.GetInt32(false));
EdmOperationParameter simpleOperationName = new EdmOperationParameter(simpleOperationAction, "Name", EdmCoreModel.Instance.GetString(true));
simpleOperationAction.AddParameter(simpleOperationName);
model.AddElement(simpleOperationAction);
EdmOperationImport simpleOperation = new EdmActionImport(container, "SimpleFunction", simpleOperationAction);
container.AddElement(simpleOperation);
model.AddElement(container);
var annotationElement =
new XElement("{http://foo}Annotation", 1);
var annotation = new EdmStringConstant(EdmCoreModel.Instance.GetString(false), annotationElement.ToString());
annotation.SetIsSerializedAsElement(model, true);
model.SetAnnotationValue(simpleOperationName, "http://foo", "Annotation", annotation);
return(model);
}
private static void AddOperationParameters(EdmOperation operation, OperationConfiguration operationConfiguration, Dictionary <Type, IEdmType> edmTypeMap)
{
foreach (ParameterConfiguration parameter in operationConfiguration.Parameters)
{
bool isParameterNullable = parameter.Nullable;
IEdmTypeReference parameterTypeReference = GetEdmTypeReference(edmTypeMap, parameter.TypeConfiguration, nullable: isParameterNullable);
if (parameter.IsOptional)
{
if (parameter.DefaultValue != null)
{
operation.AddOptionalParameter(parameter.Name, parameterTypeReference, parameter.DefaultValue);
}
else
{
operation.AddOptionalParameter(parameter.Name, parameterTypeReference);
}
}
else
{
IEdmOperationParameter operationParameter = new EdmOperationParameter(operation, parameter.Name, parameterTypeReference);
operation.AddParameter(operationParameter);
}
}
}
/// <summary>
/// Constructor.
/// </summary>
/// <param name="model">The model this instance belongs to.</param>
/// <param name="operation">The resource operation underlying this function import.</param>
/// <param name="namespaceName">The namespace of the operation.</param>
/// <remarks>This constructor assumes that the entity set for this service operation has already be created.</remarks>
protected internal MetadataProviderEdmOperation(MetadataProviderEdmModel model, OperationWrapper operation, string namespaceName)
{
Debug.Assert(model != null, "model != null");
Debug.Assert(operation != null, "operation != null");
this.model = model;
this.ServiceOperation = operation;
this.Namespace = namespaceName;
if (operation.Kind == OperationKind.Action)
{
this.isBound = this.ServiceOperation.BindingParameter != null;
}
else
{
Debug.Assert(operation.Kind == OperationKind.ServiceOperation, "serviceOperation.Kind == OperationKind.ServiceOperation");
Debug.Assert(operation.OperationParameterBindingKind == OperationParameterBindingKind.Never, "operation.OperationParameterBindingKind == OperationParameterBindingKind.Never");
this.isBound = DefaultIsBindable;
}
// EntitySetPath=<path string>
ResourceSetPathExpression resultSetPathExpression = operation.ResultSetPathExpression;
this.entitySetPath = resultSetPathExpression == null ? null : resultSetPathExpression.PathExpression;
#if DEBUG
ResourceType returnType = operation.ReturnType;
ResourceSetWrapper resultSet = operation.ResourceSet;
Debug.Assert(
returnType == null || returnType.ResourceTypeKind == ResourceTypeKind.EntityCollection || returnType.ResourceTypeKind == ResourceTypeKind.EntityType || (resultSet == null && resultSetPathExpression == null),
"resultSet and resultSetPathExpression must be both null when the return type is not an entity type or an entity collection type.");
Debug.Assert(
(returnType == null || returnType.ResourceTypeKind != ResourceTypeKind.EntityCollection && returnType.ResourceTypeKind != ResourceTypeKind.EntityType) || (resultSet != null || resultSetPathExpression != null),
"One of resultSet or resultSetPathExpression must be set when the return type is either an entity type or an entity collection type.");
Debug.Assert(resultSet == null || resultSetPathExpression == null, "resultSet and resultSetPathExpression cannot be both set.");
#endif
string mimeType = operation.MimeType;
if (!string.IsNullOrEmpty(mimeType))
{
model.SetMimeType(this, mimeType);
}
switch (this.ServiceOperation.OperationParameterBindingKind)
{
case OperationParameterBindingKind.Always:
break;
default:
Debug.Assert(
this.ServiceOperation.OperationParameterBindingKind == OperationParameterBindingKind.Sometimes ||
this.ServiceOperation.OperationParameterBindingKind == OperationParameterBindingKind.Never,
"this.ServiceOperation.OperationParameterBindingKind == OperationParameterBindingKind.Sometimes || this.ServiceOperation.OperationParameterBindingKind == OperationParameterBindingKind.Never");
break;
}
ReadOnlyCollection <OperationParameter> operationParameters = operation.Parameters;
if (operationParameters != null && operationParameters.Count > 0)
{
List <IEdmOperationParameter> list = new List <IEdmOperationParameter>(operationParameters.Count);
foreach (OperationParameter parameter in operationParameters)
{
IEdmTypeReference parameterType = this.model.EnsureTypeReference(parameter.ParameterType, /*annotations*/ null);
EdmOperationParameter edmParameter = new EdmOperationParameter(this, parameter.Name, parameterType);
list.Add(edmParameter);
}
this.parameters = new ReadOnlyCollection <IEdmOperationParameter>(list);
}
this.ReturnType = this.CreateReturnTypeReference();
}
