private void ApplyProcedureConventions(ProcedureConfiguration procedure)
{
foreach (IProcedureConvention convention in _conventions.OfType <IProcedureConvention>())
{
convention.Apply(procedure, this);
}
}
/// <summary>
/// Remove the procedure from the model
/// </summary>
/// <param name="procedure">The procedure to be removed</param>
/// <returns><see>true</see> if the procedure is present in the model and <see>false</see> otherwise.</returns>
public virtual bool RemoveProcedure(ProcedureConfiguration procedure)
{
if (procedure == null)
{
throw Error.ArgumentNull("procedure");
}
return(_procedures.Remove(procedure));
}
public void CanRemoveProcedure()
{
// Arrange
// Act
ODataModelBuilder builder = new ODataModelBuilder();
ActionConfiguration action = new ActionConfiguration(builder, "Format");
ProcedureConfiguration procedure = builder.Procedures.SingleOrDefault();
bool removed = builder.RemoveProcedure(procedure);
// Assert
Assert.True(removed);
Assert.Equal(0, builder.Procedures.Count());
}
public void CanCreateTransientAction()
{
ODataModelBuilder builder = new ODataModelBuilder();
EntityTypeConfiguration <Customer> customer = builder.Entity <Customer>();
customer.TransientAction("Reward");
ProcedureConfiguration action = builder.Procedures.SingleOrDefault();
Assert.NotNull(action);
Assert.True(action.IsBindable);
Assert.False(action.IsAlwaysBindable);
}
public void AttemptToRemoveNonExistantEntityReturnsFalse()
{
// Arrange
ODataModelBuilder builder = new ODataModelBuilder();
ODataModelBuilder builder2 = new ODataModelBuilder();
ProcedureConfiguration toRemove = builder2.Action("ToRemove");
// Act
bool removedByName = builder.RemoveProcedure("ToRemove");
bool removed = builder.RemoveProcedure(toRemove);
//Assert
Assert.False(removedByName);
Assert.False(removed);
}
/// <summary>
/// Adds a procedure to the model.
/// </summary>
public virtual void AddProcedure(ProcedureConfiguration procedure)
{
_procedures.Add(procedure);
}
private static IEdmExpression GetEdmEntitySetExpression(Dictionary<string, EdmEntitySet> entitySets, ProcedureConfiguration procedure)
{
if (procedure.EntitySet != null)
{
if (entitySets.ContainsKey(procedure.EntitySet.Name))
{
EdmEntitySet entitySet = entitySets[procedure.EntitySet.Name];
return new EdmEntitySetReferenceExpression(entitySet);
}
else
{
throw Error.InvalidOperation(SRResources.EntitySetNotFoundForName, procedure.EntitySet.Name);
}
}
else if (procedure.EntitySetPath != null)
{
return new EdmPathExpression(procedure.EntitySetPath);
}
return null;
}
private static void AddProcedure(
this IEdmModel model,
ProcedureConfiguration procedure,
EdmEntityContainer container,
Dictionary<Type, IEdmStructuredType> edmTypeMap,
Dictionary<string, EdmEntitySet> edmEntitySetMap,
bool isAction)
{
IEdmTypeReference returnReference = GetEdmTypeReference(edmTypeMap, procedure.ReturnType, nullable: true);
IEdmExpression expression = GetEdmEntitySetExpression(edmEntitySetMap, procedure);
IEdmPathExpression pathExpression = procedure.EntitySetPath != null
? new EdmPathExpression(procedure.EntitySetPath)
: null;
EdmOperation operation;
EdmOperationImport operationImport;
if (isAction)
{
EdmAction action = new EdmAction(
container.Namespace, procedure.Name, returnReference, procedure.IsBindable, pathExpression);
operation = action;
operationImport = new EdmActionImport(container, procedure.Name, action, expression);
}
else
{
EdmFunction function = new EdmFunction(
container.Namespace,
procedure.Name,
returnReference,
procedure.IsBindable,
pathExpression,
procedure.IsComposable);
operation = function;
operationImport = new EdmFunctionImport(
container, procedure.Name, function, expression, includeInServiceDocument: true);
}
AddProcedureParameters(operation, procedure, edmTypeMap);
if (procedure.IsBindable)
{
model.SetIsAlwaysBindable(operation, procedure.IsAlwaysBindable);
AddProcedureLinkBuilder(model, operation, procedure);
ValidateProcedureEntitySetPath(model, operationImport, procedure);
}
EdmModel edmModel = model as EdmModel;
if (edmModel != null)
{
edmModel.AddElement(operation);
}
container.AddElement(operationImport);
}
private static void ValidateProcedureEntitySetPath(IEdmModel model, IEdmOperationImport operationImport, ProcedureConfiguration procedure)
{
IEdmOperationParameter procedureParameter;
IEnumerable<IEdmNavigationProperty> navPath;
IEnumerable<EdmError> edmErrors;
if (procedure.EntitySetPath != null && !operationImport.TryGetRelativeEntitySetPath(model, out procedureParameter, out navPath, out edmErrors))
{
throw Error.InvalidOperation(SRResources.ProcedureHasInvalidEntitySetPath, String.Join("/", procedure.EntitySetPath.ToArray()), procedure.FullName);
}
}
private static void AddProcedureLinkBuilder(IEdmModel model, IEdmOperation operation, ProcedureConfiguration procedure)
{
if (procedure.BindingParameter.TypeConfiguration.Kind == EdmTypeKind.Entity)
{
ActionConfiguration actionConfiguration = procedure as ActionConfiguration;
IEdmAction action = operation as IEdmAction;
FunctionConfiguration functionConfiguration = procedure as FunctionConfiguration;
IEdmFunction function = operation as IEdmFunction;
if (actionConfiguration != null && actionConfiguration.GetActionLink() != null && action != null)
{
model.SetActionLinkBuilder(
action,
new ActionLinkBuilder(actionConfiguration.GetActionLink(), actionConfiguration.FollowsConventions));
}
else if (functionConfiguration != null && functionConfiguration.GetFunctionLink() != null && function != null)
{
model.SetFunctionLinkBuilder(
function,
new FunctionLinkBuilder(functionConfiguration.GetFunctionLink(), functionConfiguration.FollowsConventions));
}
}
}
private static void AddProcedureParameters(EdmOperation operation, ProcedureConfiguration procedure, Dictionary<Type, IEdmStructuredType> 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);
}
}
