So far so good. Kan relatere til documents og media fra resp. og doctypes og mediatypes fra resp.

lars-erik · lars-erik · commit f50cfe84e6fd · 2014-01-28T15:18:15.000+01:00
diff --git a/Umbraco.RelationEditor.Web/App_Plugins/RelationEditor/relationeditor.js b/Umbraco.RelationEditor.Web/App_Plugins/RelationEditor/relationeditor.js
@@ -1,5 +1,5 @@
 ﻿(function () {
-    function EditRelationsController($scope, dialogService, relationsResources, assetsService, navigationService) {
+    function EditRelationsController($scope, dialogService, relationsResources, assetsService, navigationService, eventsService) {
         var dialog;
 
         function relationPicked(index, data) {
@@ -34,13 +34,18 @@
         $scope.data = {};
 
         $scope.pickRelation = function (index) {
+            var selected = eventsService.on("dialogs.treePickerController.select", function (evt, args) {
+                relationPicked(index, args.node);
+                args.node.filtered = true;
+                dialogService.close(dialog);
+            });
+
             dialogService.close(dialog);
             dialog = dialogService.treePicker({
-                treeAlias: "content",
-                section: "content",
-                customTreeParams: "test=tast",
-                callback: function (data) {
-                    relationPicked(index, data);
+                treeAlias: $scope.resourceSets[index].ChildType.TreeType,
+                section: $scope.resourceSets[index].ChildType.Section,
+                closeCallback: function () {
+                    selected();
                 }
             });
         };
@@ -64,7 +69,7 @@
 
         assetsService.loadCss(Umbraco.Sys.ServerVariables.umbracoSettings.appPluginsPath + "/RelationEditor/relationeditor.css");
 
-        var promise = relationsResources.getById($scope.currentNode.id);
+        var promise = relationsResources.getById($scope.currentNode.section, $scope.currentNode.nodeType, $scope.currentNode.id);
         promise.then(function (data) {
             $scope.data = data;
             $scope.resourceSets = data.Sets;
@@ -74,13 +79,13 @@
 
     function RelationsResources($q, $http, umbDataFormatter, umbRequestHelper) {
         return {
-            getById: function(id) {
+            getById: function(section, treeType, id) {
                 return umbRequestHelper.resourcePromise(
                     $http.get(
                         Umbraco.Sys.ServerVariables.umbracoSettings.umbracoPath + "/relationseditor/relations/getrelations", {
                             params: {
-                                from: "Document",
-                                to: "Document",
+                                section: section,
+                                treeType: treeType || "",
                                 parentId: id
                             }
                         }),
@@ -104,6 +109,7 @@
             "RelationEditor.RelationResources",
             "assetsService",
             "navigationService",
+            "eventsService",
             EditRelationsController]);
 
     /*
diff --git a/Umbraco.RelationEditor/RelationsController.cs b/Umbraco.RelationEditor/RelationsController.cs
@@ -6,6 +6,7 @@
 using System.Transactions;
 using System.Web.Http;
 using System.Web.Http.Controllers;
+using umbraco;
 using Umbraco.Core.Models;
 using Umbraco.Core.Services;
 using Umbraco.Web;
@@ -20,11 +21,39 @@ public class RelationsController : UmbracoApiController
     {
         private readonly IRelationService relationService;
         private readonly IContentService contentService;
+        private readonly IMediaService mediaService;
+        private readonly IContentTypeService contentTypeService;
+
+        private readonly Dictionary<UmbracoObjectTypes, UmbracoObjectTypes[]> allowedRelations = new Dictionary<UmbracoObjectTypes, UmbracoObjectTypes[]>
+        {
+            {UmbracoObjectTypes.DocumentType, new[] {UmbracoObjectTypes.DocumentType, UmbracoObjectTypes.MediaType}},
+            {UmbracoObjectTypes.MediaType, new[] {UmbracoObjectTypes.DocumentType, UmbracoObjectTypes.MediaType}},
+            {UmbracoObjectTypes.Document, new[] {UmbracoObjectTypes.Document, UmbracoObjectTypes.Media}},
+            {UmbracoObjectTypes.Media, new[] {UmbracoObjectTypes.Document, UmbracoObjectTypes.Media}},
+        };
+
+        private readonly Dictionary<TreeNodeType, UmbracoObjectTypes> treeNodeObjectTypes = new Dictionary<TreeNodeType, UmbracoObjectTypes>
+        {
+            { new TreeNodeType("content", null), UmbracoObjectTypes.Document },
+            { new TreeNodeType("media", null), UmbracoObjectTypes.Media },
+            { new TreeNodeType("settings", "nodeTypes"), UmbracoObjectTypes.DocumentType },
+            { new TreeNodeType("settings", "mediaTypes"), UmbracoObjectTypes.MediaType }
+        };
+
+        private readonly Dictionary<Guid, TreeNodeType> objectTypeTreeTypes = new Dictionary<Guid, TreeNodeType>
+        {
+            { UmbracoObjectTypes.Document.GetGuid(), new TreeNodeType("content", null) },
+            { UmbracoObjectTypes.Media.GetGuid(), new TreeNodeType("media", null) },
+            { UmbracoObjectTypes.DocumentType.GetGuid(), new TreeNodeType("settings", "nodeTypes") },
+            { UmbracoObjectTypes.MediaType.GetGuid(), new TreeNodeType("settings", "mediaTypes") }
+        };
 
         public RelationsController()
         {
             relationService = ApplicationContext.Services.RelationService;
             contentService = ApplicationContext.Services.ContentService;
+            mediaService = ApplicationContext.Services.MediaService;
+            contentTypeService = ApplicationContext.Services.ContentTypeService;
         }
 
         public string[] GetObjectTypes()
@@ -33,39 +62,35 @@ public string[] GetObjectTypes()
         }
 
         public ContentRelationsDto GetRelations(
-            string from,
-            string to,
+            string section,
+            string treeType,
             int parentId
             )
         {
-            UmbracoObjectTypes fromType;
-            UmbracoObjectTypes toType;
+            var treeNodeType = new TreeNodeType(section, treeType);
+            var fromType = UmbracoObjectTypes.Unknown;
 
             if (
-                !Enum.TryParse(from, out fromType) ||
-                !Enum.TryParse(to, out toType) ||
-                fromType == UmbracoObjectTypes.Unknown ||
-                toType == UmbracoObjectTypes.Unknown
+                !treeNodeObjectTypes.TryGetValue(treeNodeType, out fromType)
+                || fromType == UmbracoObjectTypes.Unknown
             )
                 throw new Exception("Cannot get relation types for unknown object type");
 
-            if (fromType != UmbracoObjectTypes.Document || toType != UmbracoObjectTypes.Document)
-                throw new Exception("Haven't implemented anything but document relations yet");
-
             var allRelations = relationService.GetByParentOrChildId(parentId);
             var relationSets = relationService.GetAllRelationTypes()
-                .Where(rt => rt.ParentObjectType == fromType.GetGuid() && rt.ChildObjectType == toType.GetGuid())
+                .Where(rt => rt.ParentObjectType == fromType.GetGuid() && allowedRelations[fromType].Any(ar => ar.GetGuid() == rt.ChildObjectType))
                 .Select(rt => new RelationSetDto
                 {
                     RelationTypeId = rt.Id,
+                    ChildType = objectTypeTreeTypes[rt.ChildObjectType],
                     Alias = rt.Alias,
                     Name = rt.Name,
                     Relations = allRelations
                         .Where(r => r.RelationTypeId == rt.Id)
                         .Select(r => new RelationDto
                         {
                             ChildId = r.ChildId,
-                            ChildName = contentService.GetById(r.ChildId).Name,
+                            ChildName = GetChildName(rt.ChildObjectType, r.ChildId),
                             State = RelationStateEnum.Unmodified
                         }).ToList()
                 }).ToList();
@@ -100,6 +125,22 @@ public void SaveRelations(ContentRelationsDto contentRelations)
                 }
             }
         }
+
+        private string GetChildName(Guid childObjectType, int childId)
+        {
+            switch (UmbracoObjectTypesExtensions.GetUmbracoObjectType(childObjectType))
+            {
+                case UmbracoObjectTypes.Document:
+                    return contentService.GetById(childId).Name;
+                case UmbracoObjectTypes.Media:
+                    return mediaService.GetById(childId).Name;
+                case UmbracoObjectTypes.DocumentType:
+                    return contentTypeService.GetContentType(childId).Name;
+                case UmbracoObjectTypes.MediaType:
+                    return contentTypeService.GetMediaType(childId).Name;
+            }
+            throw new Exception("Unknown child type");
+        }
     }
 
     public class ContentRelationsDto
@@ -111,6 +152,7 @@ public class ContentRelationsDto
     public class RelationSetDto
     {
         public int RelationTypeId { get; set; }
+        public TreeNodeType ChildType { get; set; }
         public string Alias { get; set; }
         public string Name { get; set; }
         public IList<RelationDto> Relations { get; set; }
diff --git a/Umbraco.RelationEditor/Startup.cs b/Umbraco.RelationEditor/Startup.cs
@@ -1,4 +1,5 @@
 ﻿using System;
+using System.Linq;
 using System.Web;
 using System.Web.Mvc;
 using System.Web.Routing;
@@ -10,6 +11,15 @@ namespace Umbraco.RelationEditor
 {
     public class Startup : ApplicationEventHandler
     {
+        private readonly TreeNodeType[] treeNodeTypes =
+        {
+            new TreeNodeType("content", null),
+            new TreeNodeType("media", null),
+            new TreeNodeType("settings", "nodeTypes"), 
+            new TreeNodeType("settings", "mediaTypes")
+        };
+        //private readonly string[] types = {}
+
         protected override void ApplicationStarted(UmbracoApplicationBase umbracoApplication, ApplicationContext applicationContext)
         {
             base.ApplicationStarted(umbracoApplication, applicationContext);
@@ -27,15 +37,27 @@ private void TreeControllerBaseOnMenuRendering(TreeControllerBase sender, MenuRe
         {
             var context = new HttpContextWrapper(HttpContext.Current);
             var urlHelper = new UrlHelper(new RequestContext(context, new RouteData()));
-
-            if (sender.TreeAlias == "content")
+            var treeNodeType = new TreeNodeType(sender.TreeAlias ?? eventArgs.QueryStrings.Get("section"), eventArgs.QueryStrings.Get("treeType"));
+            if (treeNodeTypes.Contains(treeNodeType) && Convert.ToInt32(eventArgs.NodeId) > 0)
             {
                 var menuItem = eventArgs.Menu.Items.Add<EditRelationsAction>("Edit relations");
                 menuItem.LaunchDialogView(
-                    urlHelper.Content("~/App_Plugins/RelationEditor/editrelations.html"), 
+                    urlHelper.Content("~/App_Plugins/RelationEditor/editrelations.html"),
                     "Edit relations"
                 );
             }
         }
     }
+
+    public struct TreeNodeType
+    {
+        public string Section;
+        public string TreeType;
+
+        public TreeNodeType(string section, string treeType)
+        {
+            Section = section;
+            TreeType = treeType;
+        }
+    }
 }
