Elements: Add flag support for pending changes and scheduled publish

src/Umbraco.Cms.Api.Management/Factories/DocumentPresentationFactory.cs

@@ -114,7 +114,7 @@ public DocumentItemResponseModel CreateItemResponseModel(IDocumentEntitySlim ent
 
         responseModel.Variants = CreateVariantsItemResponseModels(entity);
 
-        PopulateFlagsOnDocuments(responseModel);
+        PopulateFlags(responseModel);
 
         return responseModel;
     }
@@ -143,7 +143,7 @@ public IEnumerable<DocumentVariantItemResponseModel> CreateVariantsItemResponseM
                 Culture = null,
             };
 
-            PopulateFlagsOnVariants(model);
+            PopulateFlags(model);
             yield return model;
             yield break;
         }
@@ -157,7 +157,7 @@ public IEnumerable<DocumentVariantItemResponseModel> CreateVariantsItemResponseM
                 State = DocumentVariantStateHelper.GetState(entity, cultureNamePair.Key)
             };
 
-            PopulateFlagsOnVariants(model);
+            PopulateFlags(model);
             yield return model;
         }
     }
@@ -212,19 +212,12 @@ public Attempt<List<CulturePublishScheduleModel>, ContentPublishingOperationStat
         return Attempt.SucceedWithStatus(ContentPublishingOperationStatus.Success, model);
     }
 
-    private void PopulateFlagsOnDocuments(DocumentItemResponseModel model)
+    private void PopulateFlags<TItem>(TItem model)
+        where TItem : IHasFlags
     {
-        foreach (IFlagProvider signProvider in _flagProviderCollection.Where(x => x.CanProvideFlags<DocumentItemResponseModel>()))
+        foreach (IFlagProvider flagProvider in _flagProviderCollection.Where(x => x.CanProvideFlags<TItem>()))
         {
-            signProvider.PopulateFlagsAsync([model]).GetAwaiter().GetResult();
-        }
-    }
-
-    private void PopulateFlagsOnVariants(DocumentVariantItemResponseModel model)
-    {
-        foreach (IFlagProvider signProvider in _flagProviderCollection.Where(x => x.CanProvideFlags<DocumentVariantItemResponseModel>()))
-        {
-            signProvider.PopulateFlagsAsync([model]).GetAwaiter().GetResult();
+            flagProvider.PopulateFlagsAsync([model]).GetAwaiter().GetResult();
         }
     }
 }

src/Umbraco.Cms.Api.Management/Factories/ElementPresentationFactory.cs

@@ -1,9 +1,12 @@
-using Umbraco.Cms.Api.Management.Mapping.Content;
+using Microsoft.Extensions.DependencyInjection;
+using Umbraco.Cms.Api.Management.Mapping.Content;
+using Umbraco.Cms.Api.Management.Services.Flags;
 using Umbraco.Cms.Api.Management.ViewModels;
 using Umbraco.Cms.Api.Management.ViewModels.DocumentType;
 using Umbraco.Cms.Api.Management.ViewModels.Element;
 using Umbraco.Cms.Api.Management.ViewModels.Element.Item;
 using Umbraco.Cms.Core;
+using Umbraco.Cms.Core.DependencyInjection;
 using Umbraco.Cms.Core.Mapping;
 using Umbraco.Cms.Core.Models;
 using Umbraco.Cms.Core.Models.Entities;
@@ -17,11 +20,13 @@ public class ElementPresentationFactory : IElementPresentationFactory
 {
     private readonly IUmbracoMapper _umbracoMapper;
     private readonly IIdKeyMap _idKeyMap;
+    private readonly FlagProviderCollection _flagProviderCollection;
 
-    public ElementPresentationFactory(IUmbracoMapper umbracoMapper, IIdKeyMap idKeyMap)
+    public ElementPresentationFactory(IUmbracoMapper umbracoMapper, IIdKeyMap idKeyMap, FlagProviderCollection flagProviderCollection)
     {
         _umbracoMapper = umbracoMapper;
         _idKeyMap = idKeyMap;
+        _flagProviderCollection = flagProviderCollection;
     }
 
     public ElementResponseModel CreateResponseModel(IElement element, ContentScheduleCollection schedule)
@@ -47,6 +52,8 @@ public ElementItemResponseModel CreateItemResponseModel(IElementEntitySlim entit
 
         responseModel.Variants = CreateVariantsItemResponseModels(entity);
 
+        PopulateFlags(responseModel);
+
         return responseModel;
     }
 
@@ -61,6 +68,7 @@ public IEnumerable<ElementVariantItemResponseModel> CreateVariantsItemResponseMo
                 Culture = null,
             };
 
+            PopulateFlags(model);
             yield return model;
             yield break;
         }
@@ -74,10 +82,20 @@ public IEnumerable<ElementVariantItemResponseModel> CreateVariantsItemResponseMo
                 State = DocumentVariantStateHelper.GetState(entity, cultureNamePair.Key)
             };
 
+            PopulateFlags(model);
             yield return model;
         }
     }
 
     public DocumentTypeReferenceResponseModel CreateDocumentTypeReferenceResponseModel(IElementEntitySlim entity)
         => _umbracoMapper.Map<DocumentTypeReferenceResponseModel>(entity)!;
+
+    private void PopulateFlags<TItem>(TItem model)
+        where TItem : IHasFlags
+    {
+        foreach (IFlagProvider flagProvider in _flagProviderCollection.Where(x => x.CanProvideFlags<TItem>()))
+        {
+            flagProvider.PopulateFlagsAsync([model]).GetAwaiter().GetResult();
+        }
+    }
 }

src/Umbraco.Cms.Api.Management/Services/Flags/HasPendingChangesFlagProvider.cs

@@ -1,11 +1,12 @@
-using Umbraco.Cms.Api.Management.ViewModels;
+using Umbraco.Cms.Api.Management.ViewModels;
 using Umbraco.Cms.Api.Management.ViewModels.Document;
+using Umbraco.Cms.Api.Management.ViewModels.Element;
 using Umbraco.Cms.Core;
 
 namespace Umbraco.Cms.Api.Management.Services.Flags;
 
 /// <summary>
-/// Implements a <see cref="IFlagProvider"/> that provides flags for documents that have pending changes.
+/// Implements a <see cref="IFlagProvider"/> that provides flags for documents and elements that have pending changes.
 /// </summary>
 public class HasPendingChangesFlagProvider : IFlagProvider
 {
@@ -15,31 +16,31 @@ public class HasPendingChangesFlagProvider : IFlagProvider
     public bool CanProvideFlags<TItem>()
         where TItem : IHasFlags =>
         typeof(TItem) == typeof(DocumentVariantItemResponseModel) ||
-        typeof(TItem) == typeof(DocumentVariantResponseModel);
-
+        typeof(TItem) == typeof(DocumentVariantResponseModel) ||
+        typeof(TItem) == typeof(ElementVariantItemResponseModel) ||
+        typeof(TItem) == typeof(ElementVariantResponseModel);
 
     /// <inheritdoc/>
     public Task PopulateFlagsAsync<TItem>(IEnumerable<TItem> items)
         where TItem : IHasFlags
     {
         foreach (TItem item in items)
         {
-            if (HasPendingChanges(item))
+            DocumentVariantState? state = item switch
+            {
+                DocumentVariantItemResponseModel variant => variant.State,
+                DocumentVariantResponseModel variant => variant.State,
+                ElementVariantItemResponseModel variant => variant.State,
+                ElementVariantResponseModel variant => variant.State,
+                _ => null,
+            };
+
+            if (state == DocumentVariantState.PublishedPendingChanges)
             {
                 item.AddFlag(Alias);
             }
         }
 
         return Task.CompletedTask;
     }
-
-    /// <summary>
-    /// Determines if the given item has any variant that has pending changes.
-    /// </summary>
-    private static bool HasPendingChanges(object item) => item switch
-    {
-        DocumentVariantItemResponseModel variant => variant.State == DocumentVariantState.PublishedPendingChanges,
-        DocumentVariantResponseModel variant => variant.State == DocumentVariantState.PublishedPendingChanges,
-        _ => false,
-    };
 }