Added EntityController.GetUrlsByIds support for int & guid + update MNTP (#11680)

Fixes issue with MNTP (for 8.18) in a partial view macro - GH #11631

Renamed GetUrlsByUdis to match, don't do this in v9 as it would be
breaking there, instead mark it obsolete.

TODO: v9 ensure integration test coverage, more painful here as no 
WebApplicationFactory.

Author: Paul Johnson

src/Umbraco.Web.UI.Client/src/common/mocks/resources/entity.mocks.js

@@ -34,7 +34,7 @@ angular.module('umbraco.mocks').
           return [200, nodes, null];
       }
 
-      function returnUrlsbyUdis(status, data, headers) {
+      function returnUrlsByIds(status, data, headers) {
 
           if (!mocksUtils.checkAuth()) {
               return [401, null, null];
@@ -83,8 +83,8 @@ angular.module('umbraco.mocks').
                   .respond(returnEntitybyIdsPost);
 
               $httpBackend
-                  .whenPOST(mocksUtils.urlRegex('/umbraco/UmbracoApi/Entity/GetUrlsByUdis'))
-                  .respond(returnUrlsbyUdis);
+                  .whenPOST(mocksUtils.urlRegex('/umbraco/UmbracoApi/Entity/GetUrlsByIds'))
+                  .respond(returnUrlsByIds);
 
               $httpBackend
                   .whenGET(mocksUtils.urlRegex('/umbraco/UmbracoApi/Entity/GetAncestors'))

src/Umbraco.Web.UI.Client/src/common/resources/entity.resource.js

@@ -127,19 +127,19 @@ function entityResource($q, $http, umbRequestHelper) {
                'Failed to retrieve url for id:' + id);
         },
 
-        getUrlsByUdis: function(udis, culture) {
-          var query = "culture=" + (culture || "");
+        getUrlsByIds: function(ids, type, culture) {
+          var query = `type=${type}&culture=${culture || ""}`;
 
           return umbRequestHelper.resourcePromise(
              $http.post(
                  umbRequestHelper.getApiUrl(
                      "entityApiBaseUrl",
-                     "GetUrlsByUdis",
+                     "GetUrlsByIds",
                      query),
                  {
-                     udis: udis
+                     ids: ids
                  }),
-             'Failed to retrieve url map for udis ' + udis);
+             'Failed to retrieve url map for ids ' + ids);
         },
 
         getUrlByUdi: function (udi, culture) {

src/Umbraco.Web.UI.Client/src/views/propertyeditors/contentpicker/contentpicker.controller.js

@@ -421,7 +421,7 @@ function contentPickerController($scope, $q, $routeParams, $location, entityReso
 
                 var requests = [
                     entityResource.getByIds(missingIds, entityType),
-                    entityResource.getUrlsByUdis(missingIds)
+                    entityResource.getUrlsByIds(missingIds, entityType)
                 ];
 
                 return $q.all(requests).then(function ([data, urlMap]) {

src/Umbraco.Web/Editors/EntityController.cs

@@ -76,7 +76,8 @@ public void Initialize(HttpControllerSettings controllerSettings, HttpController
                     new ParameterSwapControllerActionSelector.ParameterSwapInfo("GetPath", "id", typeof(int), typeof(Guid), typeof(Udi)),
                     new ParameterSwapControllerActionSelector.ParameterSwapInfo("GetUrlAndAnchors", "id", typeof(int), typeof(Guid), typeof(Udi)),
                     new ParameterSwapControllerActionSelector.ParameterSwapInfo("GetById", "id", typeof(int), typeof(Guid), typeof(Udi)),
-                    new ParameterSwapControllerActionSelector.ParameterSwapInfo("GetByIds", "ids", typeof(int[]), typeof(Guid[]), typeof(Udi[]))));
+                    new ParameterSwapControllerActionSelector.ParameterSwapInfo("GetByIds", "ids", typeof(int[]), typeof(Guid[]), typeof(Udi[])),
+                    new ParameterSwapControllerActionSelector.ParameterSwapInfo("GetUrlsByIds", "ids", typeof(int[]), typeof(Guid[]), typeof(Udi[]))));
             }
         }
 
@@ -236,47 +237,147 @@ public HttpResponseMessage GetUrl(Udi udi, string culture = "*")
         }
 
         /// <summary>
-        /// Get entity URLs by UDIs
+        /// Get entity URLs by IDs
         /// </summary>
-        /// <param name="udis">
-        /// A list of UDIs to lookup items by
+        /// <param name="ids">
+        /// A list of IDs to lookup items by
         /// </param>
-        /// <param name="culture">The culture to fetch the URL for</param>
+        /// <param name="type">The entity type to look for.</param>
+        /// <param name="culture">The culture to fetch the URL for.</param>
+        /// <returns>Dictionary mapping Udi -> Url</returns>
+        /// <remarks>
+        /// We allow for POST because there could be quite a lot of Ids.
+        /// </remarks>
+        [HttpGet]
+        [HttpPost]
+        public IDictionary<int, string> GetUrlsByIds([FromJsonPath] int[] ids, [FromUri] UmbracoEntityTypes type, [FromUri] string culture = null)
+        {
+            if (ids == null || !ids.Any())
+            {
+                return new Dictionary<int, string>();
+            }
+
+            string MediaOrDocumentUrl(int id)
+            {
+                switch (type)
+                {
+                    case UmbracoEntityTypes.Document:
+                        return UmbracoContext.UrlProvider.GetUrl(id, culture: culture ?? ClientCulture());
+                    case UmbracoEntityTypes.Media: {
+                        var media = UmbracoContext.Media.GetById(id);
+                        // NOTE: If culture is passed here we get an empty string rather than a media item URL.
+                        return UmbracoContext.UrlProvider.GetMediaUrl(media, culture: null);
+                    }
+                    default:
+                        return null;
+                }
+            }
+
+            return ids
+                .Distinct()
+                .Select(id => new {
+                    Id = id,
+                    Url = MediaOrDocumentUrl(id)
+                }).ToDictionary(x => x.Id, x => x.Url);
+        }
+
+        /// <summary>
+        /// Get entity URLs by IDs
+        /// </summary>
+        /// <param name="ids">
+        /// A list of IDs to lookup items by
+        /// </param>
+        /// <param name="type">The entity type to look for.</param>
+        /// <param name="culture">The culture to fetch the URL for.</param>
         /// <returns>Dictionary mapping Udi -> Url</returns>
         /// <remarks>
         /// We allow for POST because there could be quite a lot of Ids.
         /// </remarks>
         [HttpGet]
         [HttpPost]
-        public IDictionary<Udi, string> GetUrlsByUdis([FromJsonPath] Udi[] udis, string culture = null)
+        public IDictionary<Guid, string> GetUrlsByIds([FromJsonPath] Guid[] ids, [FromUri] UmbracoEntityTypes type, [FromUri] string culture = null)
         {
-            if (udis == null || udis.Length == 0)
+            if (ids == null || !ids.Any())
+            {
+                return new Dictionary<Guid, string>();
+            }
+
+            string MediaOrDocumentUrl(Guid id)
+            {
+                switch (type)
+                {
+                    case UmbracoEntityTypes.Document:
+                        return UmbracoContext.UrlProvider.GetUrl(id, culture: culture ?? ClientCulture());
+                    case UmbracoEntityTypes.Media:
+                    {
+                        var media = UmbracoContext.Media.GetById(id);
+                        // NOTE: If culture is passed here we get an empty string rather than a media item URL.
+                        return UmbracoContext.UrlProvider.GetMediaUrl(media, culture: null);
+                    }
+                    default:
+                        return null;
+                }
+            }
+
+            return ids
+                .Distinct()
+                .Select(id => new {
+                    Id = id,
+                    Url = MediaOrDocumentUrl(id)
+                }).ToDictionary(x => x.Id, x => x.Url);
+        }
+
+        /// <summary>
+        /// Get entity URLs by IDs
+        /// </summary>
+        /// <param name="ids">
+        /// A list of IDs to lookup items by
+        /// </param>
+        /// <param name="type">The entity type to look for.</param>
+        /// <param name="culture">The culture to fetch the URL for.</param>
+        /// <returns>Dictionary mapping Udi -> Url</returns>
+        /// <remarks>
+        /// We allow for POST because there could be quite a lot of Ids.
+        /// </remarks>
+        [HttpGet]
+        [HttpPost]
+        // NOTE: V9 - can't rename GetUrlsByUdis in v9 as it's already released, it's OK to do here as 8.18 isn't out yet.
+        public IDictionary<Udi, string> GetUrlsByIds([FromJsonPath] Udi[] ids, [FromUri] UmbracoEntityTypes type, [FromUri] string culture = null)
+        {
+            if (ids == null || !ids.Any())
             {
                 return new Dictionary<Udi, string>();
             }
 
             // TODO: PMJ 2021-09-27 - Should GetUrl(Udi) exist as an extension method on UrlProvider/IUrlProvider (in v9)
-            string MediaOrDocumentUrl(Udi udi)
+            string MediaOrDocumentUrl(Udi id)
             {
-                if (udi is not GuidUdi guidUdi)
+                if (id is not GuidUdi guidUdi)
                 {
                     return null;
                 }
 
-                return guidUdi.EntityType switch
+                switch (type)
                 {
-                    Constants.UdiEntityType.Document => UmbracoContext.UrlProvider.GetUrl(guidUdi.Guid, culture: culture ?? ClientCulture()),
-                    // NOTE: If culture is passed here we get an empty string rather than a media item URL WAT
-                    Constants.UdiEntityType.Media => UmbracoContext.UrlProvider.GetMediaUrl(guidUdi.Guid, culture: null),
-                    _ => null
-                };
+                    case UmbracoEntityTypes.Document:
+                        return UmbracoContext.UrlProvider.GetUrl(guidUdi.Guid, culture: culture ?? ClientCulture());
+                    case UmbracoEntityTypes.Media:
+                        {
+                            var media = UmbracoContext.Media.GetById(id);
+                            // NOTE: If culture is passed here we get an empty string rather than a media item URL.
+                            return UmbracoContext.UrlProvider.GetMediaUrl(media, culture: null);
+                        }
+                    default:
+                        return null;
+                }
             }
 
-            return udis
-                .Select(udi => new {
-                    Udi = udi,
-                    Url = MediaOrDocumentUrl(udi)
-                }).ToDictionary(x => x.Udi, x => x.Url);
+            return ids
+                .Distinct()
+                .Select(id => new {
+                    Id = id,
+                    Url = MediaOrDocumentUrl(id)
+                }).ToDictionary(x => x.Id, x => x.Url);
         }
 
         /// <summary>