Code changes from V13.4

src/Umbraco.Core/DeliveryApi/ApiMediaUrlProvider.cs

@@ -17,6 +17,6 @@ public string GetUrl(IPublishedContent media)
             throw new ArgumentException("Media URLs can only be generated from Media items.", nameof(media));
         }
 
-        return _publishedUrlProvider.GetMediaUrl(media, UrlMode.Relative);
+        return _publishedUrlProvider.GetMediaUrl(media);
     }
 }

src/Umbraco.Core/Routing/IPublishedRouter.cs

@@ -47,4 +47,37 @@ public interface IPublishedRouter
     ///     </para>
     /// </remarks>
     Task<IPublishedRequest> UpdateRequestAsync(IPublishedRequest request, IPublishedContent? publishedContent);
+
+    /// <summary>
+    /// Finds the site root (if any) matching the http request, and updates the PublishedRequest and VariationContext accordingly.
+    /// <remarks>
+    /// <para>
+    /// This method is used for VirtualPage routing.
+    /// </para>
+    /// <para>
+    /// In this case we do not want to run the entire routing pipeline since ContentFinders are not needed here.
+    /// However, we do want to set the culture on VariationContext and PublishedRequest to the values specified by the domains.
+    /// </para>
+    /// </remarks>
+    /// </summary>
+    /// <param name="request">The request to update the culture on domain on</param>
+    /// <returns>True if a domain was found otherwise false.</returns>
+    bool RouteDomain(IPublishedRequestBuilder request) => false;
+
+    /// <summary>
+    /// Finds the site root (if any) matching the http request, and updates the VariationContext accordingly.
+    /// </summary>
+    /// <remarks>
+    /// <para>
+    /// This is used for VirtualPage routing.
+    /// </para>
+    /// <para>
+    /// This is required to set the culture on VariationContext to the values specified by the domains, before the FindContent method is called.
+    /// In order to allow the FindContent implementer to correctly find content based off the culture. Before the PublishedRequest is built.
+    /// </para>
+    /// </remarks>
+    /// <param name="uri">The URI to resolve the domain from.</param>
+    /// <returns>True if a domain was found, otherwise false.</returns>
+    bool UpdateVariationContext(Uri uri) => false;
+
 }

src/Umbraco.Core/Routing/PublishedRouter.cs

@@ -1,4 +1,4 @@
 using System.Globalization;
 using Microsoft.Extensions.Logging;
 using Microsoft.Extensions.Options;
 using Umbraco.Cms.Core.Configuration.Models;
@@ -108,7 +108,7 @@
         // find domain
         if (builder.Domain == null)
         {
-            FindDomain(builder);
+            FindAndSetDomain(builder);
         }
 
         await RouteRequestInternalAsync(builder);
@@ -185,7 +185,7 @@
 
     private async Task<IPublishedRequest> TryRouteRequest(IPublishedRequestBuilder request)
     {
-        FindDomain(request);
+        FindAndSetDomain(request);
 
         if (request.IsRedirect())
         {
@@ -270,55 +270,78 @@
         // to find out the appropriate template
     }
 
-    /// <summary>
-    ///     Finds the site root (if any) matching the http request, and updates the PublishedRequest accordingly.
-    /// </summary>
-    /// <returns>A value indicating whether a domain was found.</returns>
-    internal bool FindDomain(IPublishedRequestBuilder request)
+    /// <inheritdoc />
+    public bool RouteDomain(IPublishedRequestBuilder request)
+    {
+        var found = FindAndSetDomain(request);
+        HandleWildcardDomains(request);
+        SetVariationContext(request.Culture);
+        return found;
+    }
+
+    /// <inheritdoc />
+    public bool UpdateVariationContext(Uri uri)
+    {
+        DomainAndUri? domain = FindDomain(uri, out _);
+        SetVariationContext(domain?.Culture);
+        return domain?.Culture is not null;
+    }
+
+    private DomainAndUri? FindDomain(Uri uri, out string? defaultCulture)
     {
         const string tracePrefix = "FindDomain: ";
 
         // note - we are not handling schemes nor ports here.
         if (_logger.IsEnabled(LogLevel.Debug))
         {
-            _logger.LogDebug("{TracePrefix}Uri={RequestUri}", tracePrefix, request.Uri);
+            _logger.LogDebug("{TracePrefix}Uri={RequestUri}", tracePrefix, uri);
         }
 
         IUmbracoContext umbracoContext = _umbracoContextAccessor.GetRequiredUmbracoContext();
         IDomainCache? domainsCache = umbracoContext.PublishedSnapshot.Domains;
         var domains = domainsCache?.GetAll(false).ToList();
 
         // determines whether a domain corresponds to a published document, since some
         // domains may exist but on a document that has been unpublished - as a whole - or
         // that is not published for the domain's culture - in which case the domain does
         // not apply
         bool IsPublishedContentDomain(Domain domain)
         {
             // just get it from content cache - optimize there, not here
             IPublishedContent? domainDocument = umbracoContext.PublishedSnapshot.Content?.GetById(domain.ContentId);
 
             // not published - at all
             if (domainDocument == null)
             {
                 return false;
             }
 
             // invariant - always published
             if (!domainDocument.ContentType.VariesByCulture())
             {
                 return true;
             }
 
             // variant, ensure that the culture corresponding to the domain's language is published
             return domain.Culture is not null && domainDocument.Cultures.ContainsKey(domain.Culture);
         }
 
         domains = domains?.Where(IsPublishedContentDomain).ToList();
 
-        var defaultCulture = domainsCache?.DefaultCulture;
+        defaultCulture = domainsCache?.DefaultCulture;
 
+        return DomainUtilities.SelectDomain(domains, uri, defaultCulture: defaultCulture);
+    }
+
+    /// <summary>
+    ///     Finds the site root (if any) matching the http request, and updates the PublishedRequest accordingly.
+    /// </summary>
+    /// <returns>A value indicating whether a domain was found.</returns>
+    internal bool FindAndSetDomain(IPublishedRequestBuilder request)
+    {
+        const string tracePrefix = "FindDomain: ";
         // try to find a domain matching the current request
-        DomainAndUri? domainAndUri = DomainUtilities.SelectDomain(domains, request.Uri, defaultCulture: defaultCulture);
+        DomainAndUri? domainAndUri = FindDomain(request.Uri, out var defaultCulture);
 
         // handle domain - always has a contentId and a culture
         if (domainAndUri != null)

src/Umbraco.Core/Services/ContentService.cs

@@ -1,4 +1,4 @@
 using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.Logging;
 using Umbraco.Cms.Core.DependencyInjection;
 using Umbraco.Cms.Core.Events;
@@ -1140,66 +1140,74 @@
             throw new ArgumentException("Cultures cannot be null or whitespace", nameof(cultures));
         }
 
+        EventMessages evtMsgs = EventMessagesFactory.Get();
+
         // we need to guard against unsaved changes before proceeding; the content will be saved, but we're not firing any saved notifications
         if (HasUnsavedChanges(content))
         {
             return new PublishResult(PublishResultType.FailedPublishUnsavedChanges, EventMessagesFactory.Get(), content);
         }
 
         if (content.Name != null && content.Name.Length > 255)
         {
             throw new InvalidOperationException("Name cannot be more than 255 characters in length.");
         }
 
         PublishedState publishedState = content.PublishedState;
         if (publishedState != PublishedState.Published && publishedState != PublishedState.Unpublished)
         {
             throw new InvalidOperationException(
                 $"Cannot save-and-publish (un)publishing content, use the dedicated {nameof(CommitDocumentChanges)} method.");
         }
 
         // cannot accept invariant (null or empty) culture for variant content type
         // cannot accept a specific culture for invariant content type (but '*' is ok)
         if (content.ContentType.VariesByCulture())
         {
             if (cultures.Length > 1 && cultures.Contains("*"))
             {
                 throw new ArgumentException("Cannot combine wildcard and specific cultures when publishing variant content types.", nameof(cultures));
             }
         }
         else
         {
             if (cultures.Length == 0)
             {
                 cultures = new[] { "*" };
             }
 
             if (cultures[0] != "*" || cultures.Length > 1)
             {
                 throw new ArgumentException($"Only wildcard culture is supported when publishing invariant content types.", nameof(cultures));
             }
         }
 
         using (ICoreScope scope = ScopeProvider.CreateCoreScope())
         {
             scope.WriteLock(Constants.Locks.ContentTree);
 
             var allLangs = _languageRepository.GetMany().ToList();
 
-            EventMessages evtMsgs = EventMessagesFactory.Get();
-
             // this will create the correct culture impact even if culture is * or null
             IEnumerable<CultureImpact?> impacts =
                 cultures.Select(culture => _cultureImpactFactory.Create(culture, IsDefaultCulture(allLangs, culture), content));
 
             // publish the culture(s)
             // we don't care about the response here, this response will be rechecked below but we need to set the culture info values now.
             foreach (CultureImpact? impact in impacts)
             {
                 content.PublishCulture(impact);
             }
 
-            PublishResult result = CommitDocumentChangesInternal(scope, content, evtMsgs, allLangs, userId, out _);
+            // Change state to publishing
+            content.PublishedState = PublishedState.Publishing;
+            var publishingNotification = new ContentPublishingNotification(content, evtMsgs);
+            if (scope.Notifications.PublishCancelable(publishingNotification))
+            {
+                return new PublishResult(PublishResultType.FailedPublishCancelledByEvent, evtMsgs, content);
+            }
+
+            PublishResult result = CommitDocumentChangesInternal(scope, content, evtMsgs, allLangs, publishingNotification.State, userId);
             scope.Complete();
             return result;
         }
@@ -1254,29 +1262,35 @@
 
             var allLangs = _languageRepository.GetMany().ToList();
 
+            var savingNotification = new ContentSavingNotification(content, evtMsgs);
+            if (scope.Notifications.PublishCancelable(savingNotification))
+            {
+                return new PublishResult(PublishResultType.FailedPublishCancelledByEvent, evtMsgs, content);
+            }
+
             // all cultures = unpublish whole
             if (culture == "*" || (!content.ContentType.VariesByCulture() && culture == null))
             {
                 // Unpublish the culture, this will change the document state to Publishing! ... which is expected because this will
                 // essentially be re-publishing the document with the requested culture removed
                 // We are however unpublishing all cultures, so we will set this to unpublishing.
                 content.UnpublishCulture(culture);
                 content.PublishedState = PublishedState.Unpublishing;
-                PublishResult result = CommitDocumentChangesInternal(scope, content, evtMsgs, allLangs, userId, out _);
+                PublishResult result = CommitDocumentChangesInternal(scope, content, evtMsgs, allLangs, savingNotification.State, userId);
                 scope.Complete();
                 return result;
             }
             else
             {
                 // Unpublish the culture, this will change the document state to Publishing! ... which is expected because this will
                 // essentially be re-publishing the document with the requested culture removed.
                 // The call to CommitDocumentChangesInternal will perform all the checks like if this is a mandatory culture or the last culture being unpublished
                 // and will then unpublish the document accordingly.
                 // If the result of this is false it means there was no culture to unpublish (i.e. it was already unpublished or it did not exist)
                 var removed = content.UnpublishCulture(culture);
 
                 // Save and publish any changes
-                PublishResult result = CommitDocumentChangesInternal(scope, content, evtMsgs, allLangs, userId, out _);
+                PublishResult result = CommitDocumentChangesInternal(scope, content, evtMsgs, allLangs, savingNotification.State, userId);
 
                 scope.Complete();
 
@@ -1327,9 +1341,15 @@
 
             scope.WriteLock(Constants.Locks.ContentTree);
 
+            var savingNotification = new ContentSavingNotification(content, evtMsgs);
+            if (scope.Notifications.PublishCancelable(savingNotification))
+            {
+                return new PublishResult(PublishResultType.FailedPublishCancelledByEvent, evtMsgs, content);
+            }
+
             var allLangs = _languageRepository.GetMany().ToList();
 
-            PublishResult result = CommitDocumentChangesInternal(scope, content, evtMsgs, allLangs, userId, out _);
+            PublishResult result = CommitDocumentChangesInternal(scope, content, evtMsgs, allLangs, savingNotification.State, userId);
             scope.Complete();
             return result;
         }
@@ -1359,259 +1379,267 @@
         IContent content,
         EventMessages eventMessages,
         IReadOnlyCollection<ILanguage> allLangs,
+        IDictionary<string, object?>? notificationState,
         int userId,
-        out IDictionary<string, object?>? initialNotificationState,
         bool branchOne = false,
         bool branchRoot = false)
     {
         if (scope == null)
         {
             throw new ArgumentNullException(nameof(scope));
         }
 
         if (content == null)
         {
             throw new ArgumentNullException(nameof(content));
         }
 
         if (eventMessages == null)
         {
             throw new ArgumentNullException(nameof(eventMessages));
         }
 
         PublishResult? publishResult = null;
         PublishResult? unpublishResult = null;
 
         // nothing set = republish it all
         if (content.PublishedState != PublishedState.Publishing &&
             content.PublishedState != PublishedState.Unpublishing)
         {
             content.PublishedState = PublishedState.Publishing;
         }
 
         // State here is either Publishing or Unpublishing
         // Publishing to unpublish a culture may end up unpublishing everything so these flags can be flipped later
         var publishing = content.PublishedState == PublishedState.Publishing;
         var unpublishing = content.PublishedState == PublishedState.Unpublishing;
 
         var variesByCulture = content.ContentType.VariesByCulture();
 
         // Track cultures that are being published, changed, unpublished
         IReadOnlyList<string>? culturesPublishing = null;
         IReadOnlyList<string>? culturesUnpublishing = null;
         IReadOnlyList<string>? culturesChanging = variesByCulture
             ? content.CultureInfos?.Values.Where(x => x.IsDirty()).Select(x => x.Culture).ToList()
             : null;
 
         var isNew = !content.HasIdentity;
         TreeChangeTypes changeType = isNew ? TreeChangeTypes.RefreshNode : TreeChangeTypes.RefreshBranch;
         var previouslyPublished = content.HasIdentity && content.Published;
 
         // Inline method to persist the document with the documentRepository since this logic could be called a couple times below
         void SaveDocument(IContent c)
         {
             // save, always
             if (c.HasIdentity == false)
             {
                 c.CreatorId = userId;
             }
 
             c.WriterId = userId;
 
             // saving does NOT change the published version, unless PublishedState is Publishing or Unpublishing
             _documentRepository.Save(c);
         }
 
-        initialNotificationState = null;
         if (publishing)
         {
             // Determine cultures publishing/unpublishing which will be based on previous calls to content.PublishCulture and ClearPublishInfo
             culturesUnpublishing = content.GetCulturesUnpublishing();
             culturesPublishing = variesByCulture
                 ? content.PublishCultureInfos?.Values.Where(x => x.IsDirty()).Select(x => x.Culture).ToList()
                 : null;
 
             // ensure that the document can be published, and publish handling events, business rules, etc
             publishResult = StrategyCanPublish(
                 scope,
                 content, /*checkPath:*/
                 !branchOne || branchRoot,
                 culturesPublishing,
                 culturesUnpublishing,
                 eventMessages,
                 allLangs,
-                out initialNotificationState);
+                notificationState);
+
             if (publishResult.Success)
             {
+                // raise Publishing notification
+                if (scope.Notifications.PublishCancelable(
+                        new ContentPublishingNotification(content, eventMessages).WithState(notificationState)))
+                {
+                    _logger.LogInformation("Document {ContentName} (id={ContentId}) cannot be published: {Reason}", content.Name, content.Id, "publishing was cancelled");
+                    return new PublishResult(PublishResultType.FailedPublishCancelledByEvent, eventMessages, content);
+                }
+
                 // note: StrategyPublish flips the PublishedState to Publishing!
                 publishResult = StrategyPublish(content, culturesPublishing, culturesUnpublishing, eventMessages);
 
                 // Check if a culture has been unpublished and if there are no cultures left, and then unpublish document as a whole
                 if (publishResult.Result == PublishResultType.SuccessUnpublishCulture &&
                     content.PublishCultureInfos?.Count == 0)
                 {
                     // This is a special case! We are unpublishing the last culture and to persist that we need to re-publish without any cultures
                     // so the state needs to remain Publishing to do that. However, we then also need to unpublish the document and to do that
                     // the state needs to be Unpublishing and it cannot be both. This state is used within the documentRepository to know how to
                     // persist certain things. So before proceeding below, we need to save the Publishing state to publish no cultures, then we can
                     // mark the document for Unpublishing.
                     SaveDocument(content);
 
                     // Set the flag to unpublish and continue
                     unpublishing = content.Published; // if not published yet, nothing to do
                 }
             }
             else
             {
                 // in a branch, just give up
                 if (branchOne && !branchRoot)
                 {
                     return publishResult;
                 }
 
                 // Check for mandatory culture missing, and then unpublish document as a whole
                 if (publishResult.Result == PublishResultType.FailedPublishMandatoryCultureMissing)
                 {
                     publishing = false;
                     unpublishing = content.Published; // if not published yet, nothing to do
 
                     // we may end up in a state where we won't publish nor unpublish
                     // keep going, though, as we want to save anyways
                 }
 
                 // reset published state from temp values (publishing, unpublishing) to original value
                 // (published, unpublished) in order to save the document, unchanged - yes, this is odd,
                 // but: (a) it means we don't reproduce the PublishState logic here and (b) setting the
                 // PublishState to anything other than Publishing or Unpublishing - which is precisely
                 // what we want to do here - throws
                 content.Published = content.Published;
             }
         }
 
         // won't happen in a branch
         if (unpublishing)
         {
             IContent? newest = GetById(content.Id); // ensure we have the newest version - in scope
             if (content.VersionId != newest?.VersionId)
             {
                 return new PublishResult(PublishResultType.FailedPublishConcurrencyViolation, eventMessages, content);
             }
 
             if (content.Published)
             {
                 // ensure that the document can be unpublished, and unpublish
                 // handling events, business rules, etc
                 // note: StrategyUnpublish flips the PublishedState to Unpublishing!
                 // note: This unpublishes the entire document (not different variants)
-                unpublishResult = StrategyCanUnpublish(scope, content, eventMessages, out initialNotificationState);
+                unpublishResult = StrategyCanUnpublish(scope, content, eventMessages, notificationState);
                 if (unpublishResult.Success)
                 {
                     unpublishResult = StrategyUnpublish(content, eventMessages);
                 }
                 else
                 {
                     // reset published state from temp values (publishing, unpublishing) to original value
                     // (published, unpublished) in order to save the document, unchanged - yes, this is odd,
                     // but: (a) it means we don't reproduce the PublishState logic here and (b) setting the
                     // PublishState to anything other than Publishing or Unpublishing - which is precisely
                     // what we want to do here - throws
                     content.Published = content.Published;
                     return unpublishResult;
                 }
             }
             else
             {
                 // already unpublished - optimistic concurrency collision, really,
                 // and I am not sure at all what we should do, better die fast, else
                 // we may end up corrupting the db
                 throw new InvalidOperationException("Concurrency collision.");
             }
         }
 
         // Persist the document
         SaveDocument(content);
 
         // we have tried to unpublish - won't happen in a branch
         if (unpublishing)
         {
             // and succeeded, trigger events
             if (unpublishResult?.Success ?? false)
             {
                 // events and audit
                 scope.Notifications.Publish(
-                    new ContentUnpublishedNotification(content, eventMessages).WithState(initialNotificationState));
+                    new ContentUnpublishedNotification(content, eventMessages).WithState(notificationState));
                 scope.Notifications.Publish(new ContentTreeChangeNotification(content, TreeChangeTypes.RefreshBranch, eventMessages));
 
                 if (culturesUnpublishing != null)
                 {
                     // This will mean that that we unpublished a mandatory culture or we unpublished the last culture.
                     var langs = string.Join(", ", allLangs
                         .Where(x => culturesUnpublishing.InvariantContains(x.IsoCode))
                         .Select(x => x.CultureName));
                     Audit(AuditType.UnpublishVariant, userId, content.Id, $"Unpublished languages: {langs}", langs);
 
                     if (publishResult == null)
                     {
                         throw new PanicException("publishResult == null - should not happen");
                     }
 
                     switch (publishResult.Result)
                     {
                         case PublishResultType.FailedPublishMandatoryCultureMissing:
                             // Occurs when a mandatory culture was unpublished (which means we tried publishing the document without a mandatory culture)
 
                             // Log that the whole content item has been unpublished due to mandatory culture unpublished
                             Audit(AuditType.Unpublish, userId, content.Id, "Unpublished (mandatory language unpublished)");
                             return new PublishResult(PublishResultType.SuccessUnpublishMandatoryCulture, eventMessages, content);
                         case PublishResultType.SuccessUnpublishCulture:
                             // Occurs when the last culture is unpublished
                             Audit(AuditType.Unpublish, userId, content.Id, "Unpublished (last language unpublished)");
                             return new PublishResult(PublishResultType.SuccessUnpublishLastCulture, eventMessages, content);
                     }
                 }
 
                 Audit(AuditType.Unpublish, userId, content.Id);
                 return new PublishResult(PublishResultType.SuccessUnpublish, eventMessages, content);
             }
 
             // or, failed
             scope.Notifications.Publish(new ContentTreeChangeNotification(content, changeType, eventMessages));
             return new PublishResult(PublishResultType.FailedUnpublish, eventMessages, content); // bah
         }
 
         // we have tried to publish
         if (publishing)
         {
             // and succeeded, trigger events
             if (publishResult?.Success ?? false)
             {
                 if (isNew == false && previouslyPublished == false)
                 {
                     changeType = TreeChangeTypes.RefreshBranch; // whole branch
                 }
                 else if (isNew == false && previouslyPublished)
                 {
                     changeType = TreeChangeTypes.RefreshNode; // single node
                 }
 
                 // invalidate the node/branch
                 // for branches, handled by SaveAndPublishBranch
                 if (!branchOne)
                 {
                     scope.Notifications.Publish(
                         new ContentTreeChangeNotification(content, changeType, eventMessages));
                     scope.Notifications.Publish(
-                        new ContentPublishedNotification(content, eventMessages).WithState(initialNotificationState));
+                        new ContentPublishedNotification(content, eventMessages).WithState(notificationState));
                 }
 
                 // it was not published and now is... descendants that were 'published' (but
                 // had an unpublished ancestor) are 're-published' ie not explicitly published
                 // but back as 'published' nevertheless
                 if (!branchOne && isNew == false && previouslyPublished == false && HasChildren(content.Id))
                 {
                     IContent[] descendants = GetPublishedDescendantsLocked(content).ToArray();
                     scope.Notifications.Publish(
-                        new ContentPublishedNotification(descendants, eventMessages).WithState(initialNotificationState));
+                        new ContentPublishedNotification(descendants, eventMessages).WithState(notificationState));
                 }
 
                 switch (publishResult.Result)
@@ -1711,17 +1739,24 @@
                         continue; // shouldn't happen but no point in processing this document if there's nothing there
                     }
 
+                    var savingNotification = new ContentSavingNotification(d, evtMsgs);
+                    if (scope.Notifications.PublishCancelable(savingNotification))
+                    {
+                        results.Add(new PublishResult(PublishResultType.FailedPublishCancelledByEvent, evtMsgs, d));
+                        continue;
+                    }
+
                     foreach (var c in pendingCultures)
                     {
                         // Clear this schedule for this culture
                         contentSchedule.Clear(c, ContentScheduleAction.Expire, date);
 
                         // set the culture to be published
                         d.UnpublishCulture(c);
                     }
 
                     _documentRepository.PersistContentSchedule(d, contentSchedule);
-                    PublishResult result = CommitDocumentChangesInternal(scope, d, evtMsgs, allLangs.Value, d.WriterId, out _);
+                    PublishResult result = CommitDocumentChangesInternal(scope, d, evtMsgs, allLangs.Value, savingNotification.State, d.WriterId);
                     if (result.Success == false)
                     {
                         _logger.LogError(null, "Failed to publish document id={DocumentId}, reason={Reason}.", d.Id, result.Result);
@@ -1775,52 +1810,59 @@
                     {
                         continue; // shouldn't happen but no point in processing this document if there's nothing there
                     }
+                    var savingNotification = new ContentSavingNotification(d, evtMsgs);
+                    if (scope.Notifications.PublishCancelable(savingNotification))
+                    {
+                        results.Add(new PublishResult(PublishResultType.FailedPublishCancelledByEvent, evtMsgs, d));
+                        continue;
+                    }
+
 
                     var publishing = true;
                     foreach (var culture in pendingCultures)
                     {
                         // Clear this schedule for this culture
                         contentSchedule.Clear(culture, ContentScheduleAction.Release, date);
 
                         if (d.Trashed)
                         {
                             continue; // won't publish
                         }
 
                         // publish the culture values and validate the property values, if validation fails, log the invalid properties so the develeper has an idea of what has failed
                         IProperty[]? invalidProperties = null;
                         var impact = _cultureImpactFactory.ImpactExplicit(culture, IsDefaultCulture(allLangs.Value, culture));
                         var tryPublish = d.PublishCulture(impact) &&
                                          _propertyValidationService.Value.IsPropertyDataValid(d, out invalidProperties, impact);
                         if (invalidProperties != null && invalidProperties.Length > 0)
                         {
                             _logger.LogWarning(
                                 "Scheduled publishing will fail for document {DocumentId} and culture {Culture} because of invalid properties {InvalidProperties}",
                                 d.Id,
                                 culture,
                                 string.Join(",", invalidProperties.Select(x => x.Alias)));
                         }
 
                         publishing &= tryPublish; // set the culture to be published
                         if (!publishing)
                         {
                         }
                     }
 
                     PublishResult result;
 
                     if (d.Trashed)
                     {
                         result = new PublishResult(PublishResultType.FailedPublishIsTrashed, evtMsgs, d);
                     }
                     else if (!publishing)
                     {
                         result = new PublishResult(PublishResultType.FailedPublishContentInvalid, evtMsgs, d);
                     }
                     else
                     {
                         _documentRepository.PersistContentSchedule(d, contentSchedule);
-                        result = CommitDocumentChangesInternal(scope, d, evtMsgs, allLangs.Value, d.WriterId, out _);
+                        result = CommitDocumentChangesInternal(scope, d, evtMsgs, allLangs.Value, savingNotification.State, d.WriterId);
                     }
 
                     if (result.Success == false)
@@ -2162,14 +2204,20 @@
             return new PublishResult(PublishResultType.SuccessPublishAlready, evtMsgs, document);
         }
 
+        var savingNotification = new ContentSavingNotification(document, evtMsgs);
+        if (scope.Notifications.PublishCancelable(savingNotification))
+        {
+            return new PublishResult(PublishResultType.FailedPublishCancelledByEvent, evtMsgs, document);
+        }
+
         // publish & check if values are valid
         if (!publishCultures(document, culturesToPublish, allLangs))
         {
             // TODO: Based on this callback behavior there is no way to know which properties may have been invalid if this failed, see other results of FailedPublishContentInvalid
             return new PublishResult(PublishResultType.FailedPublishContentInvalid, evtMsgs, document);
         }
 
-        PublishResult result = CommitDocumentChangesInternal(scope, document, evtMsgs, allLangs, userId, out initialNotificationState, true, isRoot);
+        PublishResult result = CommitDocumentChangesInternal(scope, document, evtMsgs, allLangs, savingNotification.State, userId, true, isRoot);
         if (result.Success)
         {
             publishedDocuments.Add(document);
@@ -3018,19 +3066,8 @@
         IReadOnlyCollection<string>? culturesUnpublishing,
         EventMessages evtMsgs,
         IReadOnlyCollection<ILanguage> allLangs,
-        out IDictionary<string, object?>? initialNotificationState)
+        IDictionary<string, object?>? notificationState)
     {
-        // raise Publishing notification
-        var notification = new ContentPublishingNotification(content, evtMsgs);
-        var notificationResult = scope.Notifications.PublishCancelable(notification);
-        initialNotificationState = notification.State;
-
-        if (notificationResult)
-        {
-            _logger.LogInformation("Document {ContentName} (id={ContentId}) cannot be published: {Reason}", content.Name, content.Id, "publishing was cancelled");
-            return new PublishResult(PublishResultType.FailedPublishCancelledByEvent, evtMsgs, content);
-        }
-
         var variesByCulture = content.ContentType.VariesByCulture();
 
         // If it's null it's invariant
@@ -3268,12 +3305,11 @@
         ICoreScope scope,
         IContent content,
         EventMessages evtMsgs,
-        out IDictionary<string, object?>? initialNotificationState)
+        IDictionary<string, object?>? notificationState)
     {
         // raise Unpublishing notification
-        var notification = new ContentUnpublishingNotification(content, evtMsgs);
+        var notification = new ContentUnpublishingNotification(content, evtMsgs).WithState(notificationState);
         var notificationResult = scope.Notifications.PublishCancelable(notification);
-        initialNotificationState = notification.State;
 
         if (notificationResult)
         {