/// <summary>
/// Create the routes to handle tree requests
/// </summary>
/// <param name="routes"></param>
/// <param name="treeControllers"></param>
private void MapRouteTrees(RouteCollection routes, IEnumerable <TreeMetadata> treeControllers)
{
//get the core ubmraco trees
var defaultTreeTypes = treeControllers.Where(x => x.IsInternalRebelTree);
//First, register the special default route for the ApplicationTreeController, this is required
//because this special tree doesn't take a HiveId as a parameter but an application name (string)
//in order for it to render all trees in the application routed
var applicationTreeControllerName = RebelController.GetControllerName(typeof(ApplicationTreeController));
var applicationTreeControllerId = RebelController.GetControllerId <TreeAttribute>(typeof(ApplicationTreeController));
var route = routes.MapRoute(
ApplicationTreeRouteName, //name
AreaName + "/Trees/" + applicationTreeControllerName + "/{action}/{appAlias}", //url to match
new { controller = applicationTreeControllerName, action = "Index", appAlias = "content", treeId = applicationTreeControllerId.ToString("N") },
new { backOffice = new BackOfficeRouteConstraint(_applicationContext) },
new[] { typeof(ApplicationTreeController).Namespace }); //only match this namespace
route.DataTokens.Add("area", AreaName); //only match this area
route.DataTokens.Add("rebel", "backoffice"); //ensure the rebel token is set
//Register routes for the default trees
foreach (var t in defaultTreeTypes)
{
this.RouteControllerPlugin(t.Id, t.ControllerName, t.ComponentType, routes, "treeId", "Tree", "Trees", "Index", HiveId.Empty, true, _applicationContext);
}
//now, we need to get the 'internal' trees, these could be not part of a package and just exist in the 'bin' if someone just developed their
//trees in VS in their local Rebel project
var localTrees = treeControllers.Where(x => x.PluginDefinition == null && x.Id != applicationTreeControllerId);
foreach (var t in localTrees)
{
this.RouteControllerPlugin(t.Id, t.ControllerName, t.ComponentType, routes, "treeId", "Tree", "Trees", "Index", HiveId.Empty, true, _applicationContext);
}
}
/// <summary>
/// This adds some required elements to the ViewBag so that the Create view renders correctly
/// </summary>
/// <param name="model"></param>
protected virtual void EnsureViewData(CreateFileModel model)
{
var controllerName = RebelController.GetControllerName(this.GetType());
// Update thumbnails
var thumbnailFolder = Url.Content(BackOfficeRequestContext.Application.Settings.RebelFolders.DocTypeThumbnailFolder);
model.AvailableFileExtensions = AllowedFileExtensions;
model.FileThumbnail = thumbnailFolder + "/doc.png";
model.FolderThumbnail = thumbnailFolder + "/folder.png";
// Populate avilable stubs
var stubDirHiveId = new HiveId(new Uri("storage://stubs"), "stubs", new HiveIdValue(controllerName));
var stubHive = BackOfficeRequestContext.Application.Hive.GetReader <IFileStore>(stubDirHiveId.ToUri());
using (var uow = stubHive.CreateReadonly())
{
var stubFileRelations = uow.Repositories.GetChildRelations(stubDirHiveId, FixedRelationTypes.DefaultRelationType);
if (stubFileRelations.Any())
{
var stubFiles = uow.Repositories.Get <File>(true, stubFileRelations.Select(x => x.DestinationId).ToArray());
if (stubFiles.Any())
{
model.AvailableStubs = stubFiles.Select(x => new SelectListItem {
Text = x.Name, Value = x.Id.ToString()
});
}
}
}
// Populate viewbag
ViewBag.Title = CreateNewTitle;
ViewBag.ControllerId = RebelController.GetControllerId <EditorAttribute>(GetType());
}
/// <summary>
/// Return the tree url for a specified application
/// </summary>
/// <param name="url"></param>
/// <param name="applicationAlias"></param>
/// <returns></returns>
public static string GetTreeUrl(this UrlHelper url, string applicationAlias)
{
var appTreeControllerName = RebelController.GetControllerName(typeof(ApplicationTreeController));
var appTreeControllerId =
RebelController.GetControllerId <TreeAttribute>(typeof(ApplicationTreeController));
return(url.Action("Index", appTreeControllerName,
new { area = url.GetBackOfficeArea(), appAlias = applicationAlias, treeId = appTreeControllerId.ToString("N") }));
}
/// <summary>
/// Returns a RouteDefinition object based on the current renderModel
/// </summary>
/// <param name="requestContext"></param>
/// <param name="renderModel"></param>
/// <returns></returns>
protected virtual RouteDefinition GetRebelRouteDefinition(RequestContext requestContext, IRebelRenderModel renderModel)
{
//creates the default route definition which maps to the 'RebelController' controller
var def = new RouteDefinition
{
ControllerName = RebelController.GetControllerName <RebelController>(),
Controller = new RebelController(),
RenderModel = renderModel,
ActionName = ((Route)requestContext.RouteData.Route).Defaults["action"].ToString()
};
//check that a template is defined)
if (renderModel.CurrentNode != null && renderModel.CurrentNode.CurrentTemplate != null)
{
using (var uow = _applicationContext.Hive.OpenReader <IFileStore>(new Uri("storage://templates")))
{
var template = uow.Repositories.Get <File>(renderModel.CurrentNode.CurrentTemplate.Id);
//check if there's a custom controller assigned, base on the document type alias.
var controller = _controllerFactory.CreateController(requestContext, renderModel.CurrentNode.ContentType.Alias);
//check if that controller exists
if (controller != null)
{
//ensure the controller is of type 'RebelController'
if (controller is RebelController)
{
//set the controller and name to the custom one
def.Controller = (ControllerBase)controller;
def.ControllerName = RebelController.GetControllerName(controller.GetType());
}
else
{
LogHelper.Warn <RenderRouteHandler>("The current Document Type {0} matches a locally declared controller of type {1}. Custom Controllers for Rebel routing must inherit from '{2}'.", renderModel.CurrentNode.ContentType.Alias, controller.GetType().FullName, typeof(RebelController).FullName);
//exit as we cannnot route to the custom controller, just route to the standard one.
return(def);
}
// Template might be null if none is assigned to the node
if (template != null)
{
//check if the custom controller has an action with the same name as the template name (we convert ToRebelAlias since the template name might have invalid chars).
//NOTE: This also means that all custom actions MUST be PascalCase.. but that should be standard.
var templateName = template.Name.Split('.')[0].ToRebelAlias(StringAliasCaseType.PascalCase);
var action = controller.GetType().GetMethod(templateName);
if (action != null)
{
def.ActionName = templateName;
}
//otherwise it will continue to route to Index since thats teh default route
}
}
}
}
return(def);
}
/// <summary>
/// Returns the default dashboard url
/// </summary>
/// <param name="url"></param>
/// <param name="appAlias">The application (i.e. content) to render the dashboard for</param>
/// <returns></returns>
public static string GetDashboardUrl(this UrlHelper url, string appAlias)
{
var dashboardControllerName = RebelController.GetControllerName(typeof(DashboardEditorController));
var dashboardControllerId =
RebelController.GetControllerId <EditorAttribute>(typeof(DashboardEditorController));
return(url.Action("Dashboard",
dashboardControllerName,
new { editorId = dashboardControllerId.ToString("N"), appAlias = appAlias }));
}
public void BackOfficeRouting_Ensure_Plugin_Tree_Url_Structures()
{
//Arrange
var context = new FakeHttpContextFactory("~/empty", new RouteData());
var contentTree = new Stubs.Trees.ContentTreeController(new FakeBackOfficeRequestContext());
var contentControllerName = RebelController.GetControllerName(contentTree.GetType());
var contentControllerId = RebelController.GetControllerId <TreeAttribute>(contentTree.GetType());
var mediaTree = new Stubs.Trees.MediaTreeController(new FakeBackOfficeRequestContext());
var mediaTreeControllerName = RebelController.GetControllerName(mediaTree.GetType());
var mediaTreeControllerId = RebelController.GetControllerId <TreeAttribute>(mediaTree.GetType());
const string action = "Index";
var defaultId = HiveId.Empty;
const int customId = 123;
const string area = "TestPackage";
//Act
//ensure the area is passed in because we're matchin a URL in an area, otherwise it will not work
var contentTreeDefaultUrl = UrlHelper.GenerateUrl(null, action, contentControllerName,
new RouteValueDictionary(new { area, id = defaultId, treeId = contentControllerId.ToString("N") }),
RouteTable.Routes, context.RequestContext, true);
var mediaTreeDefaultUrl = UrlHelper.GenerateUrl(null, action, mediaTreeControllerName,
new RouteValueDictionary(new { area, id = defaultId, treeId = mediaTreeControllerId.ToString("N") }),
RouteTable.Routes, context.RequestContext, true);
var contentTreeCustomUrl = UrlHelper.GenerateUrl(null, action, contentControllerName,
new RouteValueDictionary(new { area, id = customId, treeId = contentControllerId.ToString("N") }),
RouteTable.Routes, context.RequestContext, true);
var mediaTreeCustomUrl = UrlHelper.GenerateUrl(null, action, mediaTreeControllerName,
new RouteValueDictionary(new { area, id = customId, treeId = mediaTreeControllerId.ToString("N") }),
RouteTable.Routes, context.RequestContext, true);
//Assert
//Assert.AreEqual(string.Format("/Rebel/TestPackage/Trees/{0}/{1}", contentControllerId.ToString("N"), contentControllerName), contentTreeDefaultUrl);
//Assert.AreEqual(string.Format("/Rebel/TestPackage/Trees/{0}/{1}", mediaTreeControllerId.ToString("N"), mediaTreeControllerName), mediaTreeDefaultUrl);
//Assert.AreEqual(string.Format("/Rebel/TestPackage/Trees/{0}/{1}/{2}/{3}", contentControllerId.ToString("N"), contentControllerName, action, customId), contentTreeCustomUrl);
//Assert.AreEqual(string.Format("/Rebel/TestPackage/Trees/{0}/{1}/{2}/{3}", mediaTreeControllerId.ToString("N"), mediaTreeControllerName, action, customId), mediaTreeCustomUrl);
Assert.AreEqual(string.Format("/Rebel/TestPackage/{0}", contentControllerName), contentTreeDefaultUrl);
Assert.AreEqual(string.Format("/Rebel/TestPackage/{0}", mediaTreeControllerName), mediaTreeDefaultUrl);
Assert.AreEqual(string.Format("/Rebel/TestPackage/{0}/{1}/{2}", contentControllerName, action, customId), contentTreeCustomUrl);
Assert.AreEqual(string.Format("/Rebel/TestPackage/{0}/{1}/{2}", mediaTreeControllerName, action, customId), mediaTreeCustomUrl);
}
public void BackOfficeRouting_Ensure_Plugin_Editor_Url_Structures()
{
//Arrange
var context = new FakeHttpContextFactory("~/empty", new RouteData());
var contentEditor = new Stubs.Editors.ContentEditorController(new FakeBackOfficeRequestContext());
var contentControllerName = RebelController.GetControllerName(contentEditor.GetType());
var contentControllerId = RebelController.GetControllerId <EditorAttribute>(contentEditor.GetType());
var mediaEditorController = new Stubs.Editors.MediaEditorController(new FakeBackOfficeRequestContext());
var mediaControllerName = RebelController.GetControllerName(mediaEditorController.GetType());
var mediaControllerId = RebelController.GetControllerId <EditorAttribute>(mediaEditorController.GetType());
const string customAction = "Index";
const string defaultAction = "Dashboard";
const int id = -1;
const string area = "TestPackage";
//Act
//ensure the area is passed in because we're matchin a URL in an area, otherwise it will not work
var contentEditorDefaultUrl = UrlHelper.GenerateUrl(null, defaultAction, contentControllerName,
new RouteValueDictionary(new { area, id = UrlParameter.Optional, editorId = contentControllerId.ToString("N") }),
RouteTable.Routes, context.RequestContext, true);
var dataTypeEditorDefaulturl = UrlHelper.GenerateUrl(null, defaultAction, mediaControllerName,
new RouteValueDictionary(new { area, id = UrlParameter.Optional, editorId = mediaControllerId.ToString("N") }),
RouteTable.Routes, context.RequestContext, true);
var contentEditorCustomUrl = UrlHelper.GenerateUrl(null, customAction, contentControllerName,
new RouteValueDictionary(new { area, id, editorId = contentControllerId.ToString("N") }),
RouteTable.Routes, context.RequestContext, true);
var dataTypeEditorCustomurl = UrlHelper.GenerateUrl(null, customAction, mediaControllerName,
new RouteValueDictionary(new { area, id, editorId = mediaControllerId.ToString("N") }),
RouteTable.Routes, context.RequestContext, true);
//Assert
//Assert.AreEqual(string.Format("/Rebel/TestPackage/Editors/{0}/{1}", contentControllerId.ToString("N"), contentControllerName), contentEditorDefaultUrl);
//Assert.AreEqual(string.Format("/Rebel/TestPackage/Editors/{0}/{1}", mediaControllerId.ToString("N"), mediaControllerName), dataTypeEditorDefaulturl);
//Assert.AreEqual(string.Format("/Rebel/TestPackage/Editors/{0}/{1}/{2}/{3}", contentControllerId.ToString("N"), contentControllerName, customAction, id), contentEditorCustomUrl);
//Assert.AreEqual(string.Format("/Rebel/TestPackage/Editors/{0}/{1}/{2}/{3}", mediaControllerId.ToString("N"), mediaControllerName, customAction, id), dataTypeEditorCustomurl);
Assert.AreEqual(string.Format("/Rebel/TestPackage/{0}", contentControllerName), contentEditorDefaultUrl);
Assert.AreEqual(string.Format("/Rebel/TestPackage/{0}", mediaControllerName), dataTypeEditorDefaulturl);
Assert.AreEqual(string.Format("/Rebel/TestPackage/{0}/{1}/{2}", contentControllerName, customAction, id), contentEditorCustomUrl);
Assert.AreEqual(string.Format("/Rebel/TestPackage/{0}/{1}/{2}", mediaControllerName, customAction, id), dataTypeEditorCustomurl);
}
/// <summary>
/// Returns the dashboard Url for a specified controller
/// </summary>
/// <param name="url"></param>
/// <param name="controllerType"></param>
/// <param name="appAlias">The application (i.e. content) to render the dashboard for</param>
/// <returns></returns>
public static string GetDashboardUrl(this UrlHelper url, Type controllerType, string appAlias)
{
Mandate.ParameterNotNull(controllerType, "controllerType");
if (!controllerType.GetCustomAttributes(typeof(EditorAttribute), false).Any())
{
throw new InvalidCastException("The controller type specified is not of type BaseEditorController");
}
return(url.Action("Dashboard",
RebelController.GetControllerName(controllerType),
new
{
editorId = RebelController.GetControllerId <EditorAttribute>(controllerType).ToString("N"),
appAlias = appAlias
}));
}
public void BackOfficeRouting_Ensure_Default_Tree_Url_Structures()
{
//Arrange
var context = new FakeHttpContextFactory("~/empty", new RouteData());
var contentTree = new ContentTreeController(new FakeBackOfficeRequestContext());
var contentControllerName = RebelController.GetControllerName(contentTree.GetType());
var contentControllerId = RebelController.GetControllerId <TreeAttribute>(contentTree.GetType());
var dataTypeTree = new DataTypeTreeController(new FakeBackOfficeRequestContext());
var dataTypeControllerName = RebelController.GetControllerName(dataTypeTree.GetType());
var dataTypeControllerId = RebelController.GetControllerId <TreeAttribute>(dataTypeTree.GetType());
const string action = "Index";
var customId = HiveId.ConvertIntToGuid(123);
const string area = "Rebel";
//Act
//ensure the area is passed in because we're matchin a URL in an area, otherwise it will not work
var contentTreeDefaultUrl = UrlHelper.GenerateUrl(null, action, contentControllerName,
new RouteValueDictionary(new { area, id = HiveId.Empty, treeId = contentControllerId.ToString("N") }),
RouteTable.Routes, context.RequestContext, true);
var dataTypeTreeDefaultUrl = UrlHelper.GenerateUrl(null, action, dataTypeControllerName,
new RouteValueDictionary(new { area, id = HiveId.Empty, treeId = dataTypeControllerId.ToString("N") }),
RouteTable.Routes, context.RequestContext, true);
var contentTreeCustomUrl = UrlHelper.GenerateUrl(null, action, contentControllerName,
new RouteValueDictionary(new { area, id = customId, treeId = contentControllerId.ToString("N") }),
RouteTable.Routes, context.RequestContext, true);
var dataTypeTreeCustomUrl = UrlHelper.GenerateUrl(null, action, dataTypeControllerName,
new RouteValueDictionary(new { area, id = customId, treeId = dataTypeControllerId.ToString("N") }),
RouteTable.Routes, context.RequestContext, true);
//Assert
Assert.AreEqual(string.Format("/Rebel/Trees/{0}", contentControllerName), contentTreeDefaultUrl);
Assert.AreEqual(string.Format("/Rebel/Trees/{0}", dataTypeControllerName), dataTypeTreeDefaultUrl);
Assert.AreEqual(string.Format("/Rebel/Trees/{0}/{1}/{2}", contentControllerName, action, HttpUtility.UrlEncode(customId.ToString())), contentTreeCustomUrl);
Assert.AreEqual(string.Format("/Rebel/Trees/{0}/{1}/{2}", dataTypeControllerName, action, HttpUtility.UrlEncode(customId.ToString())), dataTypeTreeCustomUrl);
}
public static IEnumerable <Lazy <SurfaceController, SurfaceMetadata> > GetSurfaceMetadata(DirectoryInfo packageFolder)
{
var surfaceTypes = new List <Type>
{
//standard editors
typeof(CustomSurfaceController),
typeof(BlahSurfaceController)
};
//now we need to create the meta data for each
return((from t in surfaceTypes
let a = t.GetCustomAttributes(typeof(SurfaceAttribute), false).Cast <SurfaceAttribute>().First()
select new Lazy <SurfaceController, SurfaceMetadata>(
new SurfaceMetadata(new Dictionary <string, object>())
{
Id = a.Id,
ComponentType = t,
ControllerName = RebelController.GetControllerName(t),
PluginDefinition = new PluginDefinition(
new FileInfo(Path.Combine(packageFolder.FullName, "lib", "hello.dll")),
packageFolder.FullName,
null, false)
})).ToList());
}
/// <summary>
/// Register the tree controllers
/// </summary>
/// <param name="builder"></param>
/// <param name="typeFinder"></param>
public virtual void RegisterTreeControllers(IContainerBuilder builder, TypeFinder typeFinder)
{
if (_treeControllersRegistered)
{
return;
}
using (DisposableTimer.Start(timer =>
{
LogHelper.TraceIfEnabled <RebelComponentRegistrar>("RegisterTreeControllers start took {0}ms", () => timer);
_treeControllersRegistered = true;
}))
{
//now register each type in the container and also add it to our collection
foreach (var t in FindTypesInRequiredAssemblies <TreeController>(typeFinder))
{
var treeType = t;
RegisterComponent <TreeController, TreeAttribute, TreeMetadata>(t, builder, true,
(pluginDef, attribute, registrar) =>
registrar
.WithMetadata <EditorMetadata, string>(am => am.ControllerName, RebelController.GetControllerName(treeType))
.WithMetadata <TreeMetadata, string>(am => am.TreeTitle, attribute.TreeTitle)
.WithMetadata <TreeMetadata, bool>(am => am.IsInternalRebelTree,
treeType.GetCustomAttributes(typeof(RebelTreeAttribute), false).Any()));
}
}
}
/// <summary>
/// Finds & Registers the Surface controllers
/// </summary>
/// <param name="builder"></param>
/// <param name="typeFinder"></param>
public virtual void RegisterSurfaceControllers(IContainerBuilder builder, TypeFinder typeFinder)
{
if (_surfaceControllersRegistered)
{
return;
}
using (DisposableTimer.Start(timer =>
{
LogHelper.TraceIfEnabled <RebelComponentRegistrar>("RegisterSurfaceControllers start took {0}ms", () => timer);
_surfaceControllersRegistered = true;
}))
{
//now register each type in the container and also add it to our collection);
foreach (var t in FindTypesInRequiredAssemblies <SurfaceController>(typeFinder))
{
var surfaceType = t;
RegisterComponent <SurfaceController, SurfaceAttribute, SurfaceMetadata>(
t, builder, false,
(pluginDef, attribute, registrar) =>
registrar
.WithMetadata <SurfaceMetadata, string>(am => am.ControllerName, RebelController.GetControllerName(surfaceType))
.WithMetadata <SurfaceMetadata, bool>(am => am.HasChildActionMacros,
surfaceType.GetMethods().Any(a => a.GetCustomAttributes(typeof(ChildActionOnlyAttribute), false).Any())));
}
}
}