public async override Task<HttpResponseMessage> ExecuteAsync(
HttpControllerContext controllerContext,
CancellationToken cancellationToken)
{
using (Session = Store.OpenAsyncSession())
{
var result = await base.ExecuteAsync(controllerContext, cancellationToken);
await Session.SaveChangesAsync();
return result;
}
}
public override Task <HttpResponseMessage> ExecuteAsync(HttpControllerContext controllerContext, CancellationToken cancellationToken)
{
return(base.ExecuteAsync(controllerContext, cancellationToken));
}
protected override void Initialize(HttpControllerContext controllerContext)
{
base.Initialize(controllerContext);
DomainManager = new StorageDomainManager <Comment>("MS_StorageConnectionString", "comments", Request);
}
public void Test_AuditApiActionFilter_InsertOnEnd()
{
// Mock out the context to run the action filter.
var request = new Mock <HttpRequestBase>();
//var request = new HttpRequest(null, "http://200.10.10.20:1010/api/values", null);
request.Setup(c => c.ContentType).Returns("application/json");
var stream = new MemoryStream();
var writer = new StreamWriter(stream);
writer.Write("{ Id: 'test' }");
writer.Flush();
stream.Position = 0;
request.Setup(c => c.InputStream).Returns(stream);
request.Setup(c => c.ContentLength).Returns(123);
var httpResponse = new Mock <HttpResponseBase>();
httpResponse.Setup(c => c.StatusCode).Returns(200);
var itemsDict = new Dictionary <object, object>();
var httpContext = new Mock <HttpContextBase>();
httpContext.SetupGet(c => c.Request).Returns(request.Object);
httpContext.SetupGet(c => c.Items).Returns(() => itemsDict);
httpContext.SetupGet(c => c.Response).Returns(() => httpResponse.Object);
var controllerContext = new HttpControllerContext()
{
ControllerDescriptor = new HttpControllerDescriptor()
{
ControllerName = "values"
},
Request = new HttpRequestMessage()
};
controllerContext.Request.Headers.Add("test-header", "header-value");
var actionDescriptor = new Mock <HttpActionDescriptor>();
actionDescriptor.Setup(c => c.ActionName).Returns("get");
var args = new Dictionary <string, object>()
{
{ "test1", "value1" }
};
var dataProvider = new Mock <AuditDataProvider>();
dataProvider.Setup(x => x.InsertEvent(It.IsAny <AuditEvent>())).Returns(Guid.NewGuid());
Audit.Core.Configuration.DataProvider = dataProvider.Object;
Audit.Core.Configuration.CreationPolicy = EventCreationPolicy.InsertOnEnd;
var filter = new AuditApiAttribute()
{
IncludeHeaders = true,
IncludeModelState = true,
IncludeResponseBody = true,
IncludeRequestBody = true,
EventTypeName = "TestEvent"
};
var actionContext = new HttpActionContext()
{
ActionDescriptor = actionDescriptor.Object,
ControllerContext = controllerContext,
};
var actionExecutingContext = new HttpActionContext(controllerContext, actionDescriptor.Object);
actionExecutingContext.ActionArguments.Add("test1", "value1");
var self = new TestClass()
{
Id = 1
};
actionExecutingContext.ActionArguments.Add("SelfReferencing", self);
Console.WriteLine(JsonConvert.SerializeObject(self, new JsonSerializerSettings
{
NullValueHandling = NullValueHandling.Ignore,
ReferenceLoopHandling = ReferenceLoopHandling.Ignore
}));
actionExecutingContext.Request.Properties.Add("MS_HttpContext", httpContext.Object);
filter.OnActionExecuting(actionExecutingContext);
var scopeFromController = AuditApiAttribute.GetCurrentScope(controllerContext.Request);
var actionFromController = scopeFromController.Event.GetWebApiAuditAction();
var actionExecutedContext = new HttpActionExecutedContext(actionContext, null);
actionExecutedContext.Response = new System.Net.Http.HttpResponseMessage()
{
StatusCode = HttpStatusCode.OK
};
filter.OnActionExecuted(actionExecutedContext);
var action = itemsDict["__private_AuditApiAction__"] as AuditApiAction;
var scope = itemsDict["__private_AuditApiScope__"] as AuditScope;
//Assert
dataProvider.Verify(p => p.InsertEvent(It.IsAny <AuditEvent>()), Times.Once);
dataProvider.Verify(p => p.ReplaceEvent(It.IsAny <object>(), It.IsAny <AuditEvent>()), Times.Never);
Assert.AreEqual(action, actionFromController);
Assert.AreEqual(scope, scopeFromController);
dataProvider.Verify(p => p.InsertEvent(It.IsAny <AuditEvent>()), Times.Once);
Assert.AreEqual("header-value", action.Headers["test-header"]);
Assert.AreEqual("get", action.ActionName);
Assert.AreEqual("value1", action.ActionParameters["test1"]);
Assert.AreEqual(123, ((dynamic)action.RequestBody).Length);
Assert.AreEqual("application/json", ((dynamic)action.RequestBody).Type);
}
protected override void Initialize(HttpControllerContext controllerContext)
{
base.Initialize(controllerContext); // very important!!!
Log.Rename("Api.ApCont");
}
public override Task <object> ExecuteAsync(HttpControllerContext controllerContext, IDictionary <string, object> arguments, CancellationToken cancellationToken)
{
throw new NotImplementedException();
}
protected override void Initialize(HttpControllerContext controlerContext)
{
base.Initialize(controlerContext);
GenerateStubs();
}
public ReflectedHttpActionDescriptorTest()
{
_context = ContextUtil.CreateControllerContext(instance: _controller);
_context.Configuration.IncludeErrorDetailPolicy = IncludeErrorDetailPolicy.Always;
}
private static bool IsRequestMethodGet(HttpControllerContext controllerContext)
{
return(controllerContext.Request.Method == HttpMethod.Get);
}
protected override async Task <HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken)
{
if (request == null)
{
throw Error.ArgumentNull("request");
}
ExceptionDispatchInfo exceptionInfo;
HttpControllerContext controllerContext = null;
try
{
HttpControllerDescriptor controllerDescriptor = ControllerSelector.SelectController(request);
if (controllerDescriptor == null)
{
return(request.CreateErrorResponse(
HttpStatusCode.NotFound,
Error.Format(SRResources.ResourceNotFound, request.RequestUri),
SRResources.NoControllerSelected));
}
IHttpController controller = controllerDescriptor.CreateController(request);
if (controller == null)
{
return(request.CreateErrorResponse(
HttpStatusCode.NotFound,
Error.Format(SRResources.ResourceNotFound, request.RequestUri),
SRResources.NoControllerCreated));
}
controllerContext = CreateControllerContext(request, controllerDescriptor, controller);
return(await controller.ExecuteAsync(controllerContext, cancellationToken));
}
catch (OperationCanceledException)
{
// Propogate the canceled task without calling exception loggers or handlers.
throw;
}
catch (HttpResponseException httpResponseException)
{
return(httpResponseException.Response);
}
catch (Exception exception)
{
exceptionInfo = ExceptionDispatchInfo.Capture(exception);
}
Debug.Assert(exceptionInfo.SourceException != null);
ExceptionContext exceptionContext = new ExceptionContext(
exceptionInfo.SourceException,
ExceptionCatchBlocks.HttpControllerDispatcher,
request)
{
ControllerContext = controllerContext,
};
await ExceptionLogger.LogAsync(exceptionContext, cancellationToken);
HttpResponseMessage response = await ExceptionHandler.HandleAsync(exceptionContext, cancellationToken);
if (response == null)
{
exceptionInfo.Throw();
}
return(response);
}
protected override void Initialize(HttpControllerContext controllerContext)
{
base.Initialize(controllerContext);
DomainManager = new EntityDomainManager <BepOrganization>(context, Request, Services);
}
protected override void Initialize(HttpControllerContext controllerContext)
{
base.Initialize(controllerContext);
this.context = new Apo_ChanContext();
}
public IHttpController Create(HttpControllerContext controllerContext, Type controllerType)
{
return((IHttpController)_container.Resolve(controllerType));
}
protected override void Initialize(HttpControllerContext controllerContext)
{
base.Initialize(controllerContext);
_context = new MobileServiceContext();
DomainManager = new EntityDomainManager <Account>(_context, Request);
}
protected override void Initialize(HttpControllerContext controllerContext)
{
base.Initialize(controllerContext);
db = new mpbdmContext <Guid>();
DomainManager = new EntityDomainManager <Contacts>(db, Request, Services, true);
}
protected override void Initialize(HttpControllerContext controllerContext)
{
base.Initialize(controllerContext);
this.BindRouteProperties();
}
protected override void Initialize(HttpControllerContext controllerContext)
{
base.Initialize(controllerContext);
DomainManager = new EntityDomainManager <Membership>(_context, Request, Services);
}
public void ExecuteAsync_InvokesAuthorizationFilters_ThenInvokesModelBinding_ThenInvokesActionFilters_ThenInvokesAction()
{
List <string> log = new List <string>();
Mock <ApiController> controllerMock = new Mock <ApiController>()
{
CallBase = true
};
var controllerContextMock = new Mock <HttpControllerContext>();
Mock <IActionValueBinder> binderMock = new Mock <IActionValueBinder>();
Mock <HttpActionBinding> actionBindingMock = new Mock <HttpActionBinding>();
actionBindingMock.Setup(b => b.ExecuteBindingAsync(It.IsAny <HttpActionContext>(), It.IsAny <CancellationToken>())).Returns(() => Task.Factory.StartNew(() => { log.Add("model binding"); }));
binderMock.Setup(b => b.GetBinding(It.IsAny <HttpActionDescriptor>())).Returns(actionBindingMock.Object);
HttpConfiguration configuration = new HttpConfiguration();
HttpControllerContext controllerContext = controllerContextMock.Object;
controllerContext.Configuration = configuration;
controllerContext.ControllerDescriptor = new HttpControllerDescriptor(configuration, "test", typeof(object));
var actionFilterMock = CreateActionFilterMock((ac, ct, cont) =>
{
log.Add("action filters");
return(cont());
});
var authFilterMock = CreateAuthorizationFilterMock((ac, ct, cont) =>
{
log.Add("auth filters");
return(cont());
});
var selectorMock = new Mock <IHttpActionSelector>();
Mock <HttpActionDescriptor> actionDescriptorMock = new Mock <HttpActionDescriptor>();
actionDescriptorMock.Setup(ad => ad.ActionBinding).Returns(actionBindingMock.Object);
actionDescriptorMock.Setup(ad => ad.GetFilterPipeline())
.Returns(new Collection <FilterInfo>(new List <FilterInfo>()
{
new FilterInfo(actionFilterMock.Object, FilterScope.Action), new FilterInfo(authFilterMock.Object, FilterScope.Action)
}));
selectorMock.Setup(s => s.SelectAction(controllerContext)).Returns(actionDescriptorMock.Object);
ApiController controller = controllerMock.Object;
var invokerMock = new Mock <IHttpActionInvoker>();
invokerMock.Setup(i => i.InvokeActionAsync(It.IsAny <HttpActionContext>(), It.IsAny <CancellationToken>()))
.Returns(() => Task.Factory.StartNew(() =>
{
log.Add("action");
return(new HttpResponseMessage());
}));
controllerContext.Configuration.Services.Replace(typeof(IHttpActionInvoker), invokerMock.Object);
controllerContext.Configuration.Services.Replace(typeof(IHttpActionSelector), selectorMock.Object);
controllerContext.Configuration.Services.Replace(typeof(IActionValueBinder), binderMock.Object);
var task = controller.ExecuteAsync(controllerContext, CancellationToken.None);
Assert.NotNull(task);
task.WaitUntilCompleted();
Assert.Equal(new string[] { "auth filters", "model binding", "action filters", "action" }, log.ToArray());
}
/// <inheritdoc/>
public override string SelectAction(ODataPath odataPath, HttpControllerContext controllerContext, ILookup <string, HttpActionDescriptor> actionMap)
{
if (odataPath == null)
{
throw Error.ArgumentNull("odataPath");
}
if (controllerContext == null)
{
throw Error.ArgumentNull("controllerContext");
}
if (actionMap == null)
{
throw Error.ArgumentNull("actionMap");
}
HttpMethod requestMethod = controllerContext.Request.Method;
IHttpRouteData routeData = controllerContext.RouteData;
if (!IsSupportedRequestMethod(requestMethod))
{
return(null);
}
if (odataPath.PathTemplate == "~/entityset/key/navigation/$ref" ||
odataPath.PathTemplate == "~/entityset/key/cast/navigation/$ref" ||
odataPath.PathTemplate == "~/singleton/navigation/$ref" ||
odataPath.PathTemplate == "~/singleton/cast/navigation/$ref")
{
NavigationPropertyLinkSegment navigationLinkSegment = (NavigationPropertyLinkSegment)odataPath.Segments.Last();
IEdmNavigationProperty navigationProperty = navigationLinkSegment.NavigationProperty;
IEdmEntityType declaringType = navigationProperty.DeclaringEntityType();
string refActionName = FindRefActionName(actionMap, navigationProperty, declaringType, requestMethod);
if (refActionName != null)
{
if (odataPath.PathTemplate.StartsWith("~/entityset/key", StringComparison.Ordinal))
{
controllerContext.AddKeyValueToRouteData((KeySegment)odataPath.Segments[1]);
}
routeData.Values[ODataRouteConstants.NavigationProperty] = navigationLinkSegment.NavigationProperty.Name;
return(refActionName);
}
}
else if ((requestMethod == HttpMethod.Delete) && (
odataPath.PathTemplate == "~/entityset/key/navigation/key/$ref" ||
odataPath.PathTemplate == "~/entityset/key/cast/navigation/key/$ref" ||
odataPath.PathTemplate == "~/singleton/navigation/key/$ref" ||
odataPath.PathTemplate == "~/singleton/cast/navigation/key/$ref"))
{
// the second key segment is the last segment in the path.
// So the previous of last segment is the navigation property link segment.
NavigationPropertyLinkSegment navigationLinkSegment = (NavigationPropertyLinkSegment)odataPath.Segments[odataPath.Segments.Count - 2];
IEdmNavigationProperty navigationProperty = navigationLinkSegment.NavigationProperty;
IEdmEntityType declaringType = navigationProperty.DeclaringEntityType();
string refActionName = FindRefActionName(actionMap, navigationProperty, declaringType, requestMethod);
if (refActionName != null)
{
if (odataPath.PathTemplate.StartsWith("~/entityset/key", StringComparison.Ordinal))
{
controllerContext.AddKeyValueToRouteData((KeySegment)odataPath.Segments[1]);
}
routeData.Values[ODataRouteConstants.NavigationProperty] = navigationLinkSegment.NavigationProperty.Name;
controllerContext.AddKeyValueToRouteData((KeySegment)odataPath.Segments.Last(e => e is KeySegment), ODataRouteConstants.RelatedKey);
return(refActionName);
}
}
return(null);
}
protected override void Initialize(HttpControllerContext controllerContext)
{
base.Initialize(controllerContext);
}
protected override void Initialize(HttpControllerContext controllerContext)
{
_ctx = new foreignShopEntities();
base.Initialize(controllerContext);
}
protected override void Initialize(HttpControllerContext controllerContext)
{
base.Initialize(controllerContext);
//Some code here...
}
protected override void Initialize(HttpControllerContext controllerContext)
{
base.Initialize(controllerContext);
baassiContext context = new baassiContext();
DomainManager = new EntityDomainManager<User>(context, Request, Services);
}
protected override void Initialize(HttpControllerContext controllerContext)
{
base.Initialize(controllerContext);
DomainManager = new DocumentDBDomainManager <DocumentTodoItem>(Request, Services);
}
public override string SelectAction(Microsoft.AspNet.OData.Routing.ODataPath odataPath, HttpControllerContext controllerContext, ILookup <string, HttpActionDescriptor> actionMap)
{
if (odataPath == null || controllerContext == null || actionMap == null)
{
return(null);
}
if (odataPath.PathTemplate != "~/entityset/key")
{
return(base.SelectAction(odataPath, controllerContext, actionMap));
}
if (!controllerContext.ControllerDescriptor.ControllerType.IsSubclassOfRawGeneric(typeof(GenericDataController <>)))
{
return(base.SelectAction(odataPath, controllerContext, actionMap));
}
var key = odataPath.Segments[1] as KeySegment;
controllerContext.RouteData.Values[ODataRouteConstants.Key] = key.GenerateKey();
return("Get");
}
protected override void Initialize(HttpControllerContext controllerContext)
{
base.Initialize(controllerContext);
context = new ChembetiMobileServiceContext();
DomainManager = new EntityDomainManager <Record>(context, Request, Services);
}
public void Test_AuditApiActionFilter_InsertOnStartReplaceOnEnd()
{
// Mock out the context to run the action filter.
var request = new Mock <HttpRequestBase>();
//var request = new HttpRequest(null, "http://200.10.10.20:1010/api/values", null);
request.Setup(c => c.ContentType).Returns("application/json");
var httpResponse = new Mock <HttpResponseBase>();
httpResponse.Setup(c => c.StatusCode).Returns(200);
var itemsDict = new Dictionary <object, object>();
var httpContext = new Mock <HttpContextBase>();
httpContext.SetupGet(c => c.Request).Returns(request.Object);
httpContext.SetupGet(c => c.Items).Returns(() => itemsDict);
httpContext.SetupGet(c => c.Response).Returns(() => httpResponse.Object);
var controllerContext = new HttpControllerContext()
{
ControllerDescriptor = new HttpControllerDescriptor()
{
ControllerName = "values"
},
Request = new HttpRequestMessage()
};
controllerContext.Request.Headers.Add("test-header", "header-value");
var actionDescriptor = new Mock <HttpActionDescriptor>();
actionDescriptor.Setup(c => c.ActionName).Returns("get");
var args = new Dictionary <string, object>()
{
{ "test1", "value1" }
};
var dataProvider = new Mock <AuditDataProvider>();
dataProvider.Setup(x => x.InsertEvent(It.IsAny <AuditEvent>())).Returns(Guid.NewGuid());
Audit.Core.Configuration.DataProvider = dataProvider.Object;
Audit.Core.Configuration.CreationPolicy = EventCreationPolicy.InsertOnStartReplaceOnEnd;
var filter = new AuditApiAttribute()
{
IncludeHeaders = true,
IncludeModelState = true,
IncludeResponseBody = true,
EventTypeName = "TestEvent"
};
var actionContext = new HttpActionContext()
{
ActionDescriptor = actionDescriptor.Object,
ControllerContext = controllerContext,
};
var actionExecutingContext = new HttpActionContext(controllerContext, actionDescriptor.Object);
actionExecutingContext.ActionArguments.Add("test1", "value1");
actionExecutingContext.Request.Properties.Add("MS_HttpContext", httpContext.Object);
filter.OnActionExecuting(actionExecutingContext);
var scopeFromController = AuditApiAttribute.GetCurrentScope(controllerContext.Request);
var actionFromController = scopeFromController.Event.GetWebApiAuditAction();
var actionExecutedContext = new HttpActionExecutedContext(actionContext, null);
actionExecutedContext.Response = new System.Net.Http.HttpResponseMessage()
{
StatusCode = HttpStatusCode.OK
};
filter.OnActionExecuted(actionExecutedContext);
var action = itemsDict["__private_AuditApiAction__"] as AuditApiAction;
var scope = itemsDict["__private_AuditApiScope__"] as AuditScope;
//Assert
dataProvider.Verify(p => p.InsertEvent(It.IsAny <AuditEvent>()), Times.Once);
dataProvider.Verify(p => p.ReplaceEvent(It.IsAny <object>(), It.IsAny <AuditEvent>()), Times.Once);
Assert.AreEqual(action, actionFromController);
Assert.AreEqual(scope, scopeFromController);
dataProvider.Verify(p => p.InsertEvent(It.IsAny <AuditEvent>()), Times.Once);
Assert.AreEqual("header-value", action.Headers["test-header"]);
Assert.AreEqual("get", action.ActionName);
Assert.AreEqual("value1", action.ActionParameters["test1"]);
}
/// <summary>
/// Deserialize the form data to the given type, using model binding.
/// </summary>
/// <param name="formData">collection with parsed form url data</param>
/// <param name="type">target type to read as</param>
/// <param name="modelName">null or empty to read the entire form as a single object. This is common for body data.
/// <param name="requiredMemberSelector">The <see cref="IRequiredMemberSelector"/> used to determine required members.</param>
/// <param name="formatterLogger">The <see cref="IFormatterLogger"/> to log events to.</param>
/// Or the name of a model to do a partial binding against the form data. This is common for extracting individual fields.</param>
/// <returns>best attempt to bind the object. The best attempt may be null.</returns>
public static object ReadAs(this FormDataCollection formData, Type type, string modelName, IRequiredMemberSelector requiredMemberSelector, IFormatterLogger formatterLogger)
{
if (formData == null)
{
throw Error.ArgumentNull("formData");
}
if (type == null)
{
throw Error.ArgumentNull("type");
}
if (modelName == null)
{
modelName = string.Empty;
}
using (HttpConfiguration config = new HttpConfiguration())
{
bool validateRequiredMembers = requiredMemberSelector != null && formatterLogger != null;
if (validateRequiredMembers)
{
// Set a ModelValidatorProvider that understands the IRequiredMemberSelector
config.ServiceResolver.SetService(typeof(ModelValidatorProvider), new RequiredMemberModelValidatorProvider(requiredMemberSelector));
}
// Looks like HttpActionContext is just a way of getting to the config, which we really
// just need to get a list of modelbinderPRoviders for composition.
HttpControllerContext controllerContext = new HttpControllerContext()
{
Configuration = config
};
HttpActionContext actionContext = new HttpActionContext {
ControllerContext = controllerContext
};
ModelMetadataProvider metadataProvider = config.ServiceResolver.GetModelMetadataProvider();
// Create default over config
IEnumerable <ModelBinderProvider> providers = config.ServiceResolver.GetModelBinderProviders();
ModelBinderProvider modelBinderProvider = new CompositeModelBinderProvider(providers);
IValueProvider vp = formData.GetJQueryValueProvider();
ModelBindingContext ctx = new ModelBindingContext()
{
ModelName = modelName,
FallbackToEmptyPrefix = false,
ModelMetadata = metadataProvider.GetMetadataForType(null, type),
ModelState = actionContext.ModelState,
ValueProvider = vp
};
IModelBinder binder = modelBinderProvider.GetBinder(actionContext, ctx);
bool haveResult = binder.BindModel(actionContext, ctx);
// Log model binding errors
if (validateRequiredMembers)
{
Contract.Assert(formatterLogger != null);
foreach (KeyValuePair <string, ModelState> modelStatePair in actionContext.ModelState)
{
foreach (ModelError modelError in modelStatePair.Value.Errors)
{
formatterLogger.LogError(modelStatePair.Key, modelError.ErrorMessage);
}
}
}
if (haveResult)
{
return(ctx.Model);
}
return(null);
}
}
private static string GetHttpRouteHelper(HttpControllerContext controllerContext, string routeName, object routeValues)
{
IDictionary <string, object> routeValuesDictionary = HttpRouteCollection.GetTypeProperties(routeValues);
return(GetHttpRouteHelper(controllerContext, routeName, routeValuesDictionary));
}
public override Task <object> ExecuteAsync(HttpControllerContext controllerContext, IDictionary <string, object> arguments, CancellationToken cancellationToken) => Inner.ExecuteAsync(controllerContext, arguments, cancellationToken);
protected override void Initialize(HttpControllerContext controllerContext)
{
base.Initialize(controllerContext);
this.Configuration.BindParameter(typeof(BinderPrecedenceModel), new BinderPrecedenceModelBinder());
}
/// <summary>
/// Simulating the action selecting process. It mimics the ASP.NET Web API internal logic
/// </summary>
/// <param name="controllerContext">The controller context.</param>
/// <returns>A structure contains the log of selecting process</returns>
public ActionSelectionLog Simulate(HttpControllerContext controllerContext)
{
Initialize(controllerContext.ControllerDescriptor);
ActionSelectionLog log = new ActionSelectionLog(_actionDescriptors);
// If the action name exists in route data, filter the action descriptors based on action name.
ReflectedHttpActionDescriptor[] actionsFoundByMethod = null;
var routeData = controllerContext.Request.GetRouteData();
string actionName;
if (routeData.Values.TryGetValue("action", out actionName))
{
var actionsFound = _actionNameMapping[actionName].OfType <ReflectedHttpActionDescriptor>().ToArray();
// Filter actions based on verb.
actionsFoundByMethod = actionsFound
.Where(actionDescriptor => actionDescriptor.SupportedHttpMethods.Contains(controllerContext.Request.Method))
.ToArray();
log.ActionName = actionName;
log.MarkSelected(actionsFound, info => info.FoundByActionName = true);
log.MarkOthersSelected(actionsFound, info => info.FoundByActionName = false);
log.MarkSelected(actionsFound, info => info.FoundByActionNameWithRightVerb = false);
log.MarkSelected(actionsFoundByMethod, info => info.FoundByActionNameWithRightVerb = true);
}
else
{
log.ActionName = string.Empty;
// If action name doesn't exist, find actions based on HTTP verb.
log.HttpMethod = controllerContext.Request.Method;
if (string.IsNullOrEmpty(actionName))
{
actionsFoundByMethod = FindActionsForVerb(log.HttpMethod);
log.MarkSelected(actionsFoundByMethod, info => info.FoundByVerb = true);
}
}
// If no action is found at this stage a failure must happen.
if (actionsFoundByMethod != null && actionsFoundByMethod.Length != 0)
{
// filter the actions by parameters matching
var actionsFilterByParam = FindActionUsingRouteAndQueryParameters(
controllerContext,
actionsFoundByMethod,
!string.IsNullOrEmpty(actionName)).ToArray();
log.MarkSelected(actionsFoundByMethod, info => info.FoundWithRightParam = false);
log.MarkSelected(actionsFilterByParam, info => info.FoundWithRightParam = true);
// filter the actions by selection filters
var actionsFilterBySelectors = RunSelectionFilters(controllerContext, actionsFilterByParam).ToArray();
log.MarkSelected(actionsFilterByParam, info => info.FoundWithSelectorsRun = false);
log.MarkSelected(actionsFilterBySelectors, info => info.FoundWithSelectorsRun = true);
}
return(log);
}
/// <inheritdoc/>
public override string SelectAction(ODataPath odataPath, HttpControllerContext controllerContext, ILookup <string, HttpActionDescriptor> actionMap)
{
if (odataPath == null)
{
throw Error.ArgumentNull("odataPath");
}
if (controllerContext == null)
{
throw Error.ArgumentNull("controllerContext");
}
if (actionMap == null)
{
throw Error.ArgumentNull("actionMap");
}
if (odataPath.PathTemplate == "~/entityset/key" ||
odataPath.PathTemplate == "~/entityset/key/cast")
{
HttpMethod httpMethod = controllerContext.Request.Method;
string httpMethodName;
switch (httpMethod.ToString().ToUpperInvariant())
{
case "GET":
httpMethodName = "Get";
break;
case "PUT":
httpMethodName = "Put";
break;
case "PATCH":
case "MERGE":
httpMethodName = "Patch";
break;
case "DELETE":
httpMethodName = "Delete";
break;
default:
return(null);
}
Contract.Assert(httpMethodName != null);
IEdmEntityType entityType = odataPath.EdmType as IEdmEntityType;
// e.g. Try GetCustomer first, then fallback on Get action name
string actionName = actionMap.FindMatchingAction(
httpMethodName + entityType.Name,
httpMethodName);
if (actionName != null)
{
KeyValuePathSegment keyValueSegment = (KeyValuePathSegment)odataPath.Segments[1];
controllerContext.AddKeyValueToRouteData(keyValueSegment, entityType, ODataRouteConstants.Key);
return(actionName);
}
}
return(null);
}
public virtual async Task<HttpResponseMessage> ExecuteAsync(HttpControllerContext controllerContext, CancellationToken cancellationToken)
{
return null;
}
