internal static TreeAttribute GetTreeAttribute(this ApplicationTree tree)
{
return(tree.GetRuntimeType().GetTreeAttribute());
}
/// <summary>
/// This will go and get the root node from a controller tree by executing the tree's GetRootNode method
/// </summary>
/// <param name="appTree"></param>
/// <param name="formCollection"></param>
/// <param name="controllerContext"></param>
/// <returns></returns>
/// <remarks>
/// This ensures that authorization filters are applied to the sub request
/// </remarks>
internal static async Task <Attempt <TreeNode> > TryGetRootNodeFromControllerTree(this ApplicationTree appTree, FormDataCollection formCollection, HttpControllerContext controllerContext)
{
var foundControllerTreeAttempt = appTree.TryGetControllerTree();
if (foundControllerTreeAttempt.Success == false)
{
return(Attempt <TreeNode> .Fail(foundControllerTreeAttempt.Exception));
}
var foundControllerTree = foundControllerTreeAttempt.Result;
//instantiate it, since we are proxying, we need to setup the instance with our current context
var instance = (TreeController)DependencyResolver.Current.GetService(foundControllerTree);
//NOTE: This is all required in order to execute the auth-filters for the sub request, we
// need to "trick" web-api into thinking that it is actually executing the proxied controller.
var urlHelper = controllerContext.Request.GetUrlHelper();
//create the proxied URL for the controller action
var proxiedUrl = controllerContext.Request.RequestUri.GetLeftPart(UriPartial.Authority) +
urlHelper.GetUmbracoApiService("GetRootNode", instance.GetType());
//add the query strings to it
proxiedUrl += "?" + formCollection.ToQueryString();
//create proxy route data specifying the action / controller to execute
var proxiedRouteData = new HttpRouteData(
controllerContext.RouteData.Route,
new HttpRouteValueDictionary(new { action = "GetRootNode", controller = ControllerExtensions.GetControllerName(instance.GetType()) }));
//create a proxied controller context
var proxiedControllerContext = new HttpControllerContext(
controllerContext.Configuration,
proxiedRouteData,
new HttpRequestMessage(HttpMethod.Get, proxiedUrl))
{
ControllerDescriptor = new HttpControllerDescriptor(controllerContext.ControllerDescriptor.Configuration, ControllerExtensions.GetControllerName(instance.GetType()), instance.GetType())
};
if (WebApiVersionCheck.WebApiVersion >= Version.Parse("5.0.0"))
{
//In WebApi2, this is required to be set:
// proxiedControllerContext.RequestContext = controllerContext.RequestContext
// but we need to do this with reflection because of codebase changes between version 4/5
//NOTE: Use TypeHelper here since the reflection is cached
var controllerContextRequestContext = TypeHelper.GetProperty(controllerContext.GetType(), "RequestContext").GetValue(controllerContext);
TypeHelper.GetProperty(proxiedControllerContext.GetType(), "RequestContext").SetValue(proxiedControllerContext, controllerContextRequestContext);
}
instance.ControllerContext = proxiedControllerContext;
instance.Request = controllerContext.Request;
if (WebApiVersionCheck.WebApiVersion >= Version.Parse("5.0.0"))
{
//now we can change the request context's route data to be the proxied route data - NOTE: we cannot do this directly above
// because it will detect that the request context is different throw an exception. This is a change in webapi2 and we need to set
// this with reflection due to codebase changes between version 4/5
// instance.RequestContext.RouteData = proxiedRouteData;
//NOTE: Use TypeHelper here since the reflection is cached
var instanceRequestContext = TypeHelper.GetProperty(typeof(ApiController), "RequestContext").GetValue(instance);
TypeHelper.GetProperty(instanceRequestContext.GetType(), "RouteData").SetValue(instanceRequestContext, proxiedRouteData);
}
//invoke auth filters for this sub request
var result = await instance.ControllerContext.InvokeAuthorizationFiltersForRequest();
//if a result is returned it means they are unauthorized, just throw the response.
if (result != null)
{
throw new HttpResponseException(result);
}
//return the root
var node = instance.GetRootNode(formCollection);
return(node == null
? Attempt <TreeNode> .Fail(new InvalidOperationException("Could not return a root node for tree " + appTree.Type))
: Attempt <TreeNode> .Succeed(node));
}
internal static Attempt <MenuItemCollection> TryGetMenuFromLegacyTreeRootNode(this ApplicationTree appTree, FormDataCollection formCollection, UrlHelper urlHelper)
{
var rootAttempt = appTree.TryGetRootXmlNodeFromLegacyTree(formCollection, urlHelper);
if (rootAttempt.Success == false)
{
return(Attempt <MenuItemCollection> .Fail(rootAttempt.Exception));
}
var currentSection = formCollection.GetRequiredString("section");
var result = LegacyTreeDataConverter.ConvertFromLegacyMenu(rootAttempt.Result, currentSection);
return(Attempt.Succeed(result));
}
