@@ -64,9 +37,6 @@
@*Currently this needs to be loaded before anything*@
-
- @*Now we need to load in some legacy stuff*@
-
@*And finally we can load in our angular app*@
diff --git a/src/Umbraco.Web/Editors/AuthenticationController.cs b/src/Umbraco.Web/Editors/AuthenticationController.cs
index de201e6e8d..505d12253d 100644
--- a/src/Umbraco.Web/Editors/AuthenticationController.cs
+++ b/src/Umbraco.Web/Editors/AuthenticationController.cs
@@ -44,7 +44,10 @@ namespace Umbraco.Web.Editors
UmbracoContext.Security.GetUserId(UmbracoContext.Security.UmbracoUserContextId));
return _userModelMapper.ToUserDetail(user);
}
- throw new HttpResponseException(HttpStatusCode.Unauthorized);
+
+ //don't return not-authorized because this method is here to check if the current user is authorized.
+ // if they are not, then we just return no content.
+ throw new HttpResponseException(HttpStatusCode.NoContent);
}
public UserDetail PostLogin(string username, string password)
diff --git a/src/Umbraco.Web/Editors/BackOfficeController.cs b/src/Umbraco.Web/Editors/BackOfficeController.cs
index 7d4968e429..d10dfb8c48 100644
--- a/src/Umbraco.Web/Editors/BackOfficeController.cs
+++ b/src/Umbraco.Web/Editors/BackOfficeController.cs
@@ -56,6 +56,7 @@ namespace Umbraco.Web.Editors
var d = new Dictionary
{
{"umbracoPath", GlobalSettings.Path},
+ {"legacyTreeJs", Url.Action("LegacyTreeJs", "BackOffice")},
{"contentApiBaseUrl", Url.GetUmbracoApiService("PostSave").TrimEnd("PostSave")},
{"mediaApiBaseUrl", Url.GetUmbracoApiService("GetRootMedia").TrimEnd("GetRootMedia")},
{"sectionApiBaseUrl", Url.GetUmbracoApiService("GetSections").TrimEnd("GetSections")},
@@ -72,6 +73,7 @@ namespace Umbraco.Web.Editors
/// Returns the JavaScript blocks for any legacy trees declared
///
///
+ [UmbracoAuthorize]
public JavaScriptResult LegacyTreeJs()
{
var javascript = new StringBuilder();
diff --git a/src/Umbraco.Web/Mvc/UmbracoAuthorizeAttribute.cs b/src/Umbraco.Web/Mvc/UmbracoAuthorizeAttribute.cs
index 19615706d6..084ef39b62 100644
--- a/src/Umbraco.Web/Mvc/UmbracoAuthorizeAttribute.cs
+++ b/src/Umbraco.Web/Mvc/UmbracoAuthorizeAttribute.cs
@@ -52,12 +52,15 @@ namespace Umbraco.Web.Mvc
}
///
- /// Override to throw exception instead of returning a 401 result
+ /// Override to to ensure no redirect occurs
///
///
protected override void HandleUnauthorizedRequest(AuthorizationContext filterContext)
{
- throw new HttpException((int)global::System.Net.HttpStatusCode.Unauthorized, "You must login to view this resource.");
+ filterContext.Result = (ActionResult)new HttpUnauthorizedResult("You must login to view this resource.");
+
+ //DON'T do a FormsAuth redirect... argh!! thankfully we're running .Net 4.5 :)
+ filterContext.RequestContext.HttpContext.Response.SuppressFormsAuthenticationRedirect = true;
}
}
diff --git a/src/Umbraco.Web/Trees/ApplicationTreeExtensions.cs b/src/Umbraco.Web/Trees/ApplicationTreeExtensions.cs
index 283f8216db..860214adf8 100644
--- a/src/Umbraco.Web/Trees/ApplicationTreeExtensions.cs
+++ b/src/Umbraco.Web/Trees/ApplicationTreeExtensions.cs
@@ -74,17 +74,28 @@ namespace Umbraco.Web.Trees
}
internal static Attempt TryGetRootNodeFromLegacyTree(this ApplicationTree appTree, FormDataCollection formCollection, UrlHelper urlHelper)
+ {
+ var xmlTreeNodeAttempt = TryGetRootXmlNodeFromLegacyTree(appTree, formCollection, urlHelper);
+ if (xmlTreeNodeAttempt.Success == false)
+ {
+ return new Attempt(xmlTreeNodeAttempt.Error);
+ }
+ return new Attempt(true,
+ LegacyTreeDataConverter.ConvertFromLegacy(xmlTreeNodeAttempt.Result.NodeID, xmlTreeNodeAttempt.Result, urlHelper, isRoot: true));
+ }
+
+ internal static Attempt TryGetRootXmlNodeFromLegacyTree(this ApplicationTree appTree, FormDataCollection formCollection, UrlHelper urlHelper)
{
var treeDefAttempt = appTree.TryGetLegacyTreeDef();
if (treeDefAttempt.Success == false)
{
- return new Attempt(treeDefAttempt.Error);
+ return new Attempt(treeDefAttempt.Error);
}
var treeDef = treeDefAttempt.Result;
var bTree = treeDef.CreateInstance();
var treeParams = new LegacyTreeParams(formCollection);
bTree.SetTreeParameters(treeParams);
- return new Attempt(true, LegacyTreeDataConverter.ConvertFromLegacy(bTree.RootNode, urlHelper));
+ return new Attempt(true, bTree.RootNode);
}
private static Attempt TryGetLegacyTreeDef(this ApplicationTree appTree)
@@ -98,11 +109,49 @@ namespace Umbraco.Web.Trees
internal static Attempt TryLoadFromLegacyTree(this ApplicationTree appTree, string id, FormDataCollection formCollection, UrlHelper urlHelper)
{
- var treeDefAttempt = appTree.TryGetLegacyTreeDef();
+ var xTreeAttempt = appTree.TryGetXmlTree(id, formCollection);
+ if (xTreeAttempt.Success == false)
+ {
+ return new Attempt(xTreeAttempt.Error);
+ }
+ return new Attempt(true, LegacyTreeDataConverter.ConvertFromLegacy(id, xTreeAttempt.Result, urlHelper));
+ }
+
+ internal static Attempt TryGetMenuFromLegacyTreeRootNode(this ApplicationTree appTree, FormDataCollection formCollection, UrlHelper urlHelper)
+ {
+ var rootAttempt = appTree.TryGetRootXmlNodeFromLegacyTree(formCollection, urlHelper);
+ if (rootAttempt.Success == false)
+ {
+ return new Attempt(rootAttempt.Error);
+ }
+
+ var result = LegacyTreeDataConverter.ConvertFromLegacyMenu(rootAttempt.Result);
+ return new Attempt(true, result);
+ }
+
+ internal static Attempt TryGetMenuFromLegacyTreeNode(this ApplicationTree appTree, string parentId, string nodeId, FormDataCollection formCollection, UrlHelper urlHelper)
+ {
+ var xTreeAttempt = appTree.TryGetXmlTree(parentId, formCollection);
+ if (xTreeAttempt.Success == false)
+ {
+ return new Attempt(xTreeAttempt.Error);
+ }
+
+ var result = LegacyTreeDataConverter.ConvertFromLegacyMenu(nodeId, xTreeAttempt.Result);
+ if (result == null)
+ {
+ return new Attempt(new ApplicationException("Could not find the node with id " + nodeId + " in the collection of nodes contained with parent id " + parentId));
+ }
+ return new Attempt(true, result);
+ }
+
+ private static Attempt TryGetXmlTree(this ApplicationTree appTree, string id, FormDataCollection formCollection)
+ {
+ var treeDefAttempt = appTree.TryGetLegacyTreeDef();
if (treeDefAttempt.Success == false)
{
- return new Attempt(treeDefAttempt.Error);
- }
+ return new Attempt(treeDefAttempt.Error);
+ }
var treeDef = treeDefAttempt.Result;
//This is how the legacy trees worked....
var bTree = treeDef.CreateInstance();
@@ -122,8 +171,7 @@ namespace Umbraco.Web.Trees
var xTree = new XmlTree();
bTree.SetTreeParameters(treeParams);
bTree.Render(ref xTree);
-
- return new Attempt(true, LegacyTreeDataConverter.ConvertFromLegacy(xTree, urlHelper));
+ return new Attempt(true, xTree);
}
}
diff --git a/src/Umbraco.Web/Trees/LegacyTreeApiController.cs b/src/Umbraco.Web/Trees/LegacyTreeApiController.cs
index 8f6fb8a1da..b93afdb7b6 100644
--- a/src/Umbraco.Web/Trees/LegacyTreeApiController.cs
+++ b/src/Umbraco.Web/Trees/LegacyTreeApiController.cs
@@ -2,6 +2,8 @@
using System.Globalization;
using System.Linq;
using System.Net.Http.Formatting;
+using Umbraco.Core.Logging;
+using Umbraco.Core.Models;
using Umbraco.Core.Services;
using Umbraco.Web.Mvc;
using Umbraco.Web.WebApi;
@@ -24,6 +26,62 @@ namespace Umbraco.Web.Trees
///
[HttpQueryStringFilter("queryStrings")]
public TreeNodeCollection GetNodes(string id, FormDataCollection queryStrings)
+ {
+ var tree = GetTree(queryStrings);
+ var attempt = tree.TryLoadFromLegacyTree(id, queryStrings, Url);
+ if (attempt.Success == false)
+ {
+ var msg = "Could not render tree " + queryStrings.GetRequiredString("treeType") + " for node id " + id;
+ LogHelper.Error(msg, attempt.Error);
+ throw new ApplicationException(msg);
+ }
+
+ return attempt.Result;
+ }
+
+ ///
+ /// This will return the menu item collection for the tree node with the specified Id
+ ///
+ ///
+ ///
+ ///
+ ///
+ /// Due to the nature of legacy trees this means that we need to lookup the parent node, render
+ /// the TreeNodeCollection and then find the node we're looking for and render it's menu.
+ ///
+ [HttpQueryStringFilter("queryStrings")]
+ public MenuItemCollection GetMenu(string id, FormDataCollection queryStrings)
+ {
+ //get the parent id from the query strings
+ var parentId = queryStrings.GetRequiredString("parentId");
+ var tree = GetTree(queryStrings);
+
+ //if the id and the parentId are both -1 then we need to get the menu for the root node
+ if (id == "-1" && parentId == "-1")
+ {
+ var attempt = tree.TryGetMenuFromLegacyTreeRootNode(queryStrings, Url);
+ if (attempt.Success == false)
+ {
+ var msg = "Could not render menu for root node for treeType " + queryStrings.GetRequiredString("treeType");
+ LogHelper.Error(msg, attempt.Error);
+ throw new ApplicationException(msg);
+ }
+ return attempt.Result;
+ }
+ else
+ {
+ var attempt = tree.TryGetMenuFromLegacyTreeNode(parentId, id, queryStrings, Url);
+ if (attempt.Success == false)
+ {
+ var msg = "Could not render menu for treeType " + queryStrings.GetRequiredString("treeType") + " for node id " + parentId;
+ LogHelper.Error(msg, attempt.Error);
+ throw new ApplicationException(msg);
+ }
+ return attempt.Result;
+ }
+ }
+
+ private ApplicationTree GetTree(FormDataCollection queryStrings)
{
//need to ensure we have a tree type
var treeType = queryStrings.GetRequiredString("treeType");
@@ -31,14 +89,7 @@ namespace Umbraco.Web.Trees
var tree = Services.ApplicationTreeService.GetByAlias(treeType);
if (tree == null)
throw new InvalidOperationException("No tree found with alias " + treeType);
-
- var attempt = tree.TryLoadFromLegacyTree(id, queryStrings, Url);
- if (attempt.Success == false)
- {
- throw new ApplicationException("Could not render tree " + treeType + " for node id " + id);
- }
-
- return attempt.Result;
+ return tree;
}
}
diff --git a/src/Umbraco.Web/Trees/LegacyTreeDataConverter.cs b/src/Umbraco.Web/Trees/LegacyTreeDataConverter.cs
index af12749def..d57759bf0d 100644
--- a/src/Umbraco.Web/Trees/LegacyTreeDataConverter.cs
+++ b/src/Umbraco.Web/Trees/LegacyTreeDataConverter.cs
@@ -1,8 +1,10 @@
using System;
+using System.Collections.Generic;
using System.Linq;
using System.Web.Http.Routing;
using Umbraco.Core;
using umbraco.BusinessLogic.Actions;
+using umbraco.cms.helpers;
using umbraco.cms.presentation.Trees;
using umbraco.controls.Tree;
using umbraco.interfaces;
@@ -15,21 +17,87 @@ namespace Umbraco.Web.Trees
internal class LegacyTreeDataConverter
{
- internal static TreeNode ConvertFromLegacy(XmlTreeNode xmlTreeNode, UrlHelper urlHelper)
+ ///
+ /// Gets the menu item collection from a legacy tree node based on it's parent node's child collection
+ ///
+ /// The node id
+ /// The node collection that contains the node id
+ ///
+ internal static MenuItemCollection ConvertFromLegacyMenu(string nodeId, XmlTree xmlTree)
+ {
+ var xmlTreeNode = xmlTree.treeCollection.FirstOrDefault(x => x.NodeID == nodeId);
+ if (xmlTreeNode == null)
+ {
+ return null;
+ }
+
+ return ConvertFromLegacyMenu(xmlTreeNode);
+ }
+
+ ///
+ /// Gets the menu item collection from a legacy tree node
+ ///
+ ///
+ ///
+ internal static MenuItemCollection ConvertFromLegacyMenu(XmlTreeNode xmlTreeNode)
+ {
+ var collection = new MenuItemCollection();
+
+ var menuItems = xmlTreeNode.Menu.ToArray();
+ var numAdded = 0;
+ var seperators = new List();
+ foreach (var t in menuItems)
+ {
+ if (t is ContextMenuSeperator && numAdded > 0)
+ {
+ //store the index for which the seperator should be placed
+ seperators.Add(collection.Count());
+ }
+ else
+ {
+ collection.AddMenuItem(t);
+ numAdded++;
+ }
+ }
+ var length = collection.Count();
+ foreach (var s in seperators)
+ {
+ if (length >= s)
+ {
+ collection.ElementAt(s).Seperator = true;
+ }
+ }
+
+ return collection;
+ }
+
+ internal static TreeNode ConvertFromLegacy(string parentId, XmlTreeNode xmlTreeNode, UrlHelper urlHelper, bool isRoot = false)
{
// /umbraco/tree.aspx?rnd=d0d0ff11a1c347dabfaa0fc75effcc2a&id=1046&treeType=content&contextMenu=false&isDialog=false
//we need to convert the node source to our legacy tree controller
- var source = urlHelper.GetUmbracoApiService("GetNodes");
+ var childNodesSource = urlHelper.GetUmbracoApiService("GetNodes");
+
+ var childQuery = (xmlTreeNode.Source.IsNullOrWhiteSpace() || xmlTreeNode.Source.IndexOf('?') == -1)
+ ? ""
+ : xmlTreeNode.Source.Substring(xmlTreeNode.Source.IndexOf('?'));
+
//append the query strings
- var query = xmlTreeNode.Source.IsNullOrWhiteSpace()
- ? new string[] { }
- : xmlTreeNode.Source.Split(new[] { '?' }, StringSplitOptions.RemoveEmptyEntries);
- source += query.Length > 1 ? query[1].EnsureStartsWith('?') : "";
+ childNodesSource = childNodesSource.AppendQueryStringToUrl(childQuery);
+
+ //for the menu source we need to detect if this is a root node since we'll need to set the parentId and id to -1
+ // for which we'll handle correctly on the server side.
+ var menuSource = urlHelper.GetUmbracoApiService("GetMenu");
+ menuSource = menuSource.AppendQueryStringToUrl(new[]
+ {
+ "id=" + (isRoot ? "-1" : xmlTreeNode.NodeID),
+ "treeType=" + xmlTreeNode.TreeType,
+ "parentId=" + (isRoot ? "-1" : parentId)
+ });
//TODO: Might need to add stuff to additional attributes
-
- var node = new TreeNode(xmlTreeNode.NodeID, source)
+
+ var node = new TreeNode(xmlTreeNode.NodeID, childNodesSource, menuSource)
{
HasChildren = xmlTreeNode.HasChildren,
Icon = xmlTreeNode.Icon,
@@ -44,36 +112,18 @@ namespace Umbraco.Web.Trees
{
node.OnClickCallback = xmlTreeNode.Action;
}
-
- var menuItems = xmlTreeNode.Menu.ToArray();
- var numAdded = 0;
- foreach (var t in menuItems)
- {
- if (t is ContextMenuSeperator && numAdded > 0)
- {
- //if it is a seperator, then update the previous menu item that we've added to be flagged
- //with a seperator
- node.Menu.ElementAt(numAdded - 1).Seperator = true;
- }
- else
- {
- node.AddMenuItem(t);
- numAdded++;
- }
- }
-
return node;
}
- internal static TreeNodeCollection ConvertFromLegacy(XmlTree xmlTree, UrlHelper urlHelper)
+ internal static TreeNodeCollection ConvertFromLegacy(string parentId, XmlTree xmlTree, UrlHelper urlHelper)
{
//TODO: Once we get the editor URL stuff working we'll need to figure out how to convert
// that over to use the old school ui.xml stuff for these old trees and however the old menu items worked.
var collection = new TreeNodeCollection();
foreach (var x in xmlTree.treeCollection)
- {
- collection.Add(ConvertFromLegacy(x, urlHelper));
+ {
+ collection.Add(ConvertFromLegacy(parentId, x, urlHelper));
}
return collection;
}
diff --git a/src/Umbraco.Web/Trees/MenuItem.cs b/src/Umbraco.Web/Trees/MenuItem.cs
index 37690d630e..3608a06319 100644
--- a/src/Umbraco.Web/Trees/MenuItem.cs
+++ b/src/Umbraco.Web/Trees/MenuItem.cs
@@ -1,6 +1,7 @@
using System.ComponentModel.DataAnnotations;
using System.Runtime.Serialization;
using umbraco.interfaces;
+using System.Collections.Generic;
namespace Umbraco.Web.Trees
{
@@ -9,7 +10,7 @@ namespace Umbraco.Web.Trees
{
public MenuItem()
{
-
+ AdditionalData = new Dictionary();
}
public MenuItem(IAction legacyMenu)
@@ -20,6 +21,13 @@ namespace Umbraco.Web.Trees
Icon = legacyMenu.Icon;
}
+ ///
+ /// A dictionary to support any additional meta data that should be rendered for the node which is
+ /// useful for custom action commands such as 'create', 'copy', etc...
+ ///
+ [DataMember(Name = "metaData")]
+ public Dictionary AdditionalData { get; private set; }
+
[DataMember(Name = "name", IsRequired = true)]
[Required]
public string Name { get; set; }
diff --git a/src/Umbraco.Web/Trees/MenuItemCollection.cs b/src/Umbraco.Web/Trees/MenuItemCollection.cs
new file mode 100644
index 0000000000..0b94eaa4e0
--- /dev/null
+++ b/src/Umbraco.Web/Trees/MenuItemCollection.cs
@@ -0,0 +1,100 @@
+using System.Collections;
+using System.Collections.Generic;
+using System.Runtime.Serialization;
+using Umbraco.Core;
+using umbraco.interfaces;
+
+namespace Umbraco.Web.Trees
+{
+ [CollectionDataContract(Name = "menuItems", Namespace = "")]
+ public class MenuItemCollection : IEnumerable