public void Apply(ProcedureConfiguration configuration, ODataModelBuilder model)
{
FunctionConfiguration function = configuration as FunctionConfiguration;
if (function == null || !function.IsBindable)
{
return;
}
// You only need to create links for bindable functions that bind to a single entity.
if (function.BindingParameter.TypeConfiguration.Kind == EdmTypeKind.Entity && function.GetFunctionLink() == null)
{
string bindingParamterType = function.BindingParameter.TypeConfiguration.FullName;
function.HasFunctionLink(entityContext =>
entityContext.GenerateFunctionLink(bindingParamterType, function.FullyQualifiedName, function.Parameters.Select(p => p.Name)),
followsConventions: true);
}
else if (function.BindingParameter.TypeConfiguration.Kind == EdmTypeKind.Collection && function.GetFeedFunctionLink() == null)
{
if (((CollectionTypeConfiguration)function.BindingParameter.TypeConfiguration).ElementType.Kind ==
EdmTypeKind.Entity)
{
string bindingParamterType = function.BindingParameter.TypeConfiguration.FullName;
function.HasFeedFunctionLink(
feedContext =>
feedContext.GenerateFunctionLink(bindingParamterType, function.FullyQualifiedName, function.Parameters.Select(p => p.Name)),
followsConventions: true);
}
}
}
public void Apply(ProcedureConfiguration configuration, ODataModelBuilder model)
{
FunctionConfiguration function = configuration as FunctionConfiguration;
if (function == null || !function.IsBindable)
{
return;
}
// You only need to create links for bindable functions that bind to a single entity.
if (function.BindingParameter.TypeConfiguration.Kind == EdmTypeKind.Entity && function.GetFunctionLink() == null)
{
string bindingParamterType = function.BindingParameter.TypeConfiguration.FullName;
function.HasFunctionLink(entityContext =>
entityContext.GenerateFunctionLink(bindingParamterType, function.FullyQualifiedName, function.Parameters.Select(p => p.Name)),
followsConventions: true);
}
else if (function.BindingParameter.TypeConfiguration.Kind == EdmTypeKind.Collection && function.GetFeedFunctionLink() == null)
{
if (((CollectionTypeConfiguration)function.BindingParameter.TypeConfiguration).ElementType.Kind ==
EdmTypeKind.Entity)
{
string bindingParamterType = function.BindingParameter.TypeConfiguration.FullName;
function.HasFeedFunctionLink(
feedContext =>
feedContext.GenerateFunctionLink(bindingParamterType, function.FullyQualifiedName, function.Parameters.Select(p => p.Name)),
followsConventions: true);
}
}
}
protected override void Setup(ProcedureConfiguration <School> configuration)
{
configuration.ProcedureName = "SomeSPName";
configuration.Input.Maps(v => v.SchoolId).Max(2).HasParameterName("Hamba");
configuration.Input.Maps(v => v.SchoolName).Required();
//configuration.Output<School>.Maps(v => v.SchoolName).Required();
}
protected override void Setup(ProcedureConfiguration <ResourceSummary> configuration)
{
configuration.ProcedureName = "InsertResourceSummaryDetails";
var SpReturn = configuration.CanReturnCollectionOf <ResourceSummary>();
SpReturn.Maps(v => v.EmployerDistrict).HasParameterName("EmployerDisctrict");
SpReturn.Maps(v => v.MobileNo).HasParameterName("ModileNo");
}
public void Apply(ProcedureConfiguration configuration, ODataModelBuilder model)
{
ActionConfiguration action = configuration as ActionConfiguration;
// You only need to create links for bindable actions that bind to a single entity.
if (action != null && action.IsBindable && action.BindingParameter.TypeConfiguration.Kind == EdmTypeKind.Entity && action.GetActionLink() == null)
{
action.HasActionLink(entityContext => GenerateActionLink(entityContext, action));
}
}
public void Apply(ProcedureConfiguration configuration, ODataModelBuilder model)
{
ActionConfiguration action = configuration as ActionConfiguration;
// You only need to create links for bindable actions that bind to a single entity.
if (action != null && action.IsBindable && action.BindingParameter.TypeConfiguration.Kind == EdmTypeKind.Entity && action.GetActionLink() == null)
{
action.HasActionLink(entityContext => GenerateActionLink(entityContext, action));
}
}
protected override void Setup(ProcedureConfiguration <ResourceSummary> configuration)
{
configuration.Mock = true;
configuration.ProcedureName = "InsertResourceSummary";
//configuration.ConnectionString = "Data Source=PIS03CDIVDISS33;Initial Catalog=PerformanceTestDb;Integrated Security=True;Connection Timeout=60;Min Pool Size=20; Max Pool Size=500;";
configuration.Input.Maps(v => v.PersonId).Out();
configuration.Input.Maps(v => v.PersonName).Required().MinLength(1).MaxLength(50);
configuration.Input.Maps(v => v.EmailAddress).Required().MaxLength(50);
configuration.Input.Maps(v => v.MobileNo).Required().MaxLength(50);
configuration.Input.Maps(v => v.Country).MaxLength(50);
}
public void Apply(ProcedureConfiguration configuration, ODataModelBuilder model)
{
ActionConfiguration action = configuration as ActionConfiguration;
// You only need to create links for bindable actions that bind to a single entity.
if (action != null && action.IsBindable && action.BindingParameter.TypeConfiguration.Kind == EdmTypeKind.Entity && action.GetActionLink() == null)
{
string bindingParamterType = action.BindingParameter.TypeConfiguration.FullName;
action.HasActionLink(entityContext => entityContext.GenerateActionLink(bindingParamterType, action.Name), followsConventions: true);
}
}
public void Apply(ProcedureConfiguration configuration, ODataModelBuilder model)
{
FunctionConfiguration function = configuration as FunctionConfiguration;
// You only need to create links for bindable functions that bind to a single entity.
if (function != null && function.IsBindable && function.BindingParameter.TypeConfiguration.Kind == EdmTypeKind.Entity && function.GetFunctionLink() == null)
{
string bindingParamterType = function.BindingParameter.TypeConfiguration.FullName;
function.HasFunctionLink(entityContext =>
entityContext.GenerateFunctionLink(bindingParamterType, function.Name, function.Parameters.Select(p => p.Name)),
followsConventions: true);
}
}
public void Apply(ProcedureConfiguration configuration, ODataModelBuilder model)
{
FunctionConfiguration function = configuration as FunctionConfiguration;
// You only need to create links for bindable functions that bind to a single entity.
if (function != null && function.IsBindable && function.BindingParameter.TypeConfiguration.Kind == EdmTypeKind.Entity && function.GetFunctionLink() == null)
{
string bindingParamterType = function.BindingParameter.TypeConfiguration.FullName;
function.HasFunctionLink(entityContext =>
entityContext.GenerateFunctionLink(bindingParamterType, function.Name, function.Parameters.Select(p => p.Name)),
followsConventions: true);
}
}
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);
}
}
protected override void Setup(ProcedureConfiguration <SpHelloWorldParams> configuration)
{
configuration.ConnectionString = "Data Source=.;Initial Catalog=SQLML;Integrated Security=True;";
configuration.Input.Maps(v => v.MyMessage).Out();
}
protected override void Setup(ProcedureConfiguration <SPSelectAdjustmentsParams> configuration)
{
configuration.ConnectionString = "Data Source=.;Initial Catalog=Steven_Singer_db;Integrated Security=True;";
configuration.ProcedureName = "SPSelectAdjustments";
configuration.CanReturnCollectionOf <Steven_Singer_ADJUSTMENTS>().Maps(v => v.SKU_NO).Email();
}
protected override void Setup(ProcedureConfiguration <AllTypeParams> configuration)
{
configuration.Mock = true;
configuration.Input.Maps(v => v.Id).Min(1);
configuration.Input.Maps(v => v.RowChanged).Out();
}
private static void AddProcedure(
this IEdmModel model,
ProcedureConfiguration procedure,
EdmEntityContainer container,
Dictionary<Type, IEdmType> edmTypeMap,
Dictionary<string, EdmEntitySet> edmEntitySetMap,
bool isAction)
{
IEdmTypeReference returnReference = GetEdmTypeReference(
edmTypeMap,
procedure.ReturnType,
procedure.ReturnType != null && EdmLibHelpers.IsNullable(procedure.ReturnType.ClrType));
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;
FunctionConfiguration functionConfig = (FunctionConfiguration)procedure;
operationImport = new EdmFunctionImport(
container, procedure.Name, function, expression, functionConfig.IncludeInServiceDocument);
}
AddProcedureParameters(operation, procedure, edmTypeMap);
if (procedure.IsBindable)
{
model.SetIsAlwaysBindable(operation, procedure.IsAlwaysBindable);
AddProcedureLinkBuilder(model, operation, procedure);
ValidateProcedureEntitySetPath(model, operationImport, procedure);
}
else
{
container.AddElement(operationImport);
}
EdmModel edmModel = model as EdmModel;
if (edmModel != null)
{
edmModel.AddElement(operation);
}
}
private static EdmOperationImport CreateActionImport(
ProcedureConfiguration procedure,
EdmEntityContainer container,
IEdmTypeReference returnReference,
IEdmExpression expression,
IEdmPathExpression pathExpression)
{
EdmAction operation = new EdmAction(
container.Namespace,
procedure.Name,
returnReference,
procedure.IsBindable,
pathExpression);
return new EdmActionImport(container, procedure.Name, operation, expression);
}
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));
}
}
}
public override void AddProcedure(ProcedureConfiguration procedure)
{
procedure.Namespace = Namespace;
base.AddProcedure(procedure);
}
protected override void Setup(ProcedureConfiguration <Resource> configuration)
{
configuration.ProcedureName = "InsertResourceSummary2";
//configuration.ConnectionString = "Data Source=PIS03CDIVDISS33;Initial Catalog=PerformanceTestDb;Integrated Security=True;";
}
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), procedure.FullyQualifiedName);
}
}
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 IEdmExpression GetEdmEntitySetExpression(IDictionary<string, EdmNavigationSource> navigationSources, ProcedureConfiguration procedure)
{
if (procedure.NavigationSource != null)
{
EdmNavigationSource navigationSource;
if (navigationSources.TryGetValue(procedure.NavigationSource.Name, out navigationSource))
{
EdmEntitySet entitySet = navigationSource as EdmEntitySet;
if (entitySet != null)
{
return new EdmEntitySetReferenceExpression(entitySet);
}
}
else
{
throw Error.InvalidOperation(SRResources.EntitySetNotFoundForName, procedure.NavigationSource.Name);
}
}
else if (procedure.EntitySetPath != null)
{
return new EdmPathExpression(procedure.EntitySetPath);
}
return null;
}
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;
}
