diff --git a/.gitattributes b/.gitattributes
index a664be3a85..c8987ade67 100644
--- a/.gitattributes
+++ b/.gitattributes
@@ -13,7 +13,7 @@
*.png binary
*.gif binary
-*.cs text=auto diff=csharp
+*.cs text=auto diff=csharp
*.vb text=auto
*.c text=auto
*.cpp text=auto
@@ -41,9 +41,13 @@
*.fs text=auto
*.fsx text=auto
*.hs text=auto
+*.json text=auto
+*.xml text=auto
-*.csproj text=auto merge=union
-*.vbproj text=auto merge=union
-*.fsproj text=auto merge=union
-*.dbproj text=auto merge=union
-*.sln text=auto eol=crlf merge=union
+*.csproj text=auto merge=union
+*.vbproj text=auto merge=union
+*.fsproj text=auto merge=union
+*.dbproj text=auto merge=union
+*.sln text=auto eol=crlf merge=union
+
+*.gitattributes text=auto
diff --git a/.github/BUILD.md b/.github/BUILD.md
index c6e870f396..ad33872423 100644
--- a/.github/BUILD.md
+++ b/.github/BUILD.md
@@ -43,6 +43,8 @@ If you only see a build.bat-file, you're probably on the wrong branch. If you sw
You might run into [Powershell quirks](#powershell-quirks).
+If it runs without errors; Hooray! Now you can continue with [the next step](CONTRIBUTING.md#how-do-i-begin) and open the solution and build it.
+
### Build Infrastructure
The Umbraco Build infrastructure relies on a PowerShell object. The object can be retrieved with:
diff --git a/.github/CONTRIBUTING.md b/.github/CONTRIBUTING.md
index e009ee2294..0101ac9d16 100644
--- a/.github/CONTRIBUTING.md
+++ b/.github/CONTRIBUTING.md
@@ -28,7 +28,7 @@ This project and everyone participating in it, is governed by the [our Code of C
[Working with the code](#working-with-the-code)
* [Building Umbraco from source code](#building-umbraco-from-source-code)
* [Working with the source code](#working-with-the-source-code)
- * [Making changes after the PR was opened](#making-changes-after-the-pr-was-opened)
+ * [Making changes after the PR is open](#making-changes-after-the-pr-is-open)
* [Which branch should I target for my contributions?](#which-branch-should-i-target-for-my-contributions)
* [Keeping your Umbraco fork in sync with the main repository](#keeping-your-umbraco-fork-in-sync-with-the-main-repository)
@@ -60,12 +60,12 @@ Great question! The short version goes like this:

- * **Switch to the correct branch** - switch to the v8-dev branch
+ * **Switch to the correct branch** - switch to the `v8/contrib` branch
* **Build** - build your fork of Umbraco locally as described in [building Umbraco from source code](BUILD.md)
* **Change** - make your changes, experiment, have fun, explore and learn, and don't be afraid. We welcome all contributions and will [happily give feedback](#questions)
- * **Commit** - done? Yay! 🎉 **Important:** create a new branch now and name it after the issue you're fixing, we usually follow the format: `temp-12345`. This means it's a temporary branch for the particular issue you're working on, in this case `12345`. When you have a branch, commit your changes. Don't commit to `v8/dev`, create a new branch first.
+ * **Commit** - done? Yay! 🎉 **Important:** create a new branch now and name it after the issue you're fixing, we usually follow the format: `temp-12345`. This means it's a temporary branch for the particular issue you're working on, in this case `12345`. When you have a branch, commit your changes. Don't commit to `v8/contrib`, create a new branch first.
* **Push** - great, now you can push the changes up to your fork on GitHub
- * **Create pull request** - exciting! You're ready to show us your changes (or not quite ready, you just need some feedback to progress - you can now make use of GitHub's draft pull request status, detailed [here] (https://github.blog/2019-02-14-introducing-draft-pull-requests/)). GitHub has picked up on the new branch you've pushed and will offer to create a Pull Request. Click that green button and away you go.
+ * **Create pull request** - exciting! You're ready to show us your changes (or not quite ready, you just need some feedback to progress - you can now make use of GitHub's draft pull request status, detailed [here](https://github.blog/2019-02-14-introducing-draft-pull-requests/)). GitHub has picked up on the new branch you've pushed and will offer to create a Pull Request. Click that green button and away you go.

@@ -158,7 +158,7 @@ To find the general areas for something you're looking to fix or improve, have a
### Which branch should I target for my contributions?
-We like to use [Gitflow as much as possible](https://jeffkreeftmeijer.com/git-flow/), but don't worry if you are not familiar with it. The most important thing you need to know is that when you fork the Umbraco repository, the default branch is set to something, usually `v8/dev`. If you are working on v8, this is the branch you should be targetting. For v7 contributions, please target 'v7/dev'.
+We like to use [Gitflow as much as possible](https://jeffkreeftmeijer.com/git-flow/), but don't worry if you are not familiar with it. The most important thing you need to know is that when you fork the Umbraco repository, the default branch is set to something, usually `v8/contrib`. If you are working on v8, this is the branch you should be targetting. For v7 contributions, please target 'v7/dev'.
Please note: we are no longer accepting features for v7 but will continue to merge bug fixes as and when they arise.
@@ -184,10 +184,10 @@ Then when you want to get the changes from the main repository:
```
git fetch upstream
-git rebase upstream/v8/dev
+git rebase upstream/v8/contrib
```
-In this command we're syncing with the `v8/dev` branch, but you can of course choose another one if needed.
+In this command we're syncing with the `v8/contrib` branch, but you can of course choose another one if needed.
(More info on how this works: [http://robots.thoughtbot.com/post/5133345960/keeping-a-git-fork-updated](http://robots.thoughtbot.com/post/5133345960/keeping-a-git-fork-updated))
diff --git a/.github/README.md b/.github/README.md
index d6d978c3d6..467ca6e5e6 100644
--- a/.github/README.md
+++ b/.github/README.md
@@ -1,4 +1,4 @@
-# [Umbraco CMS](https://umbraco.com) · [](../LICENSE.md) [](https://umbraco.visualstudio.com/Umbraco%20Cms/_build?definitionId=75) [](CONTRIBUTING.md) [](https://twitter.com/intent/follow?screen_name=umbraco)
+# [Umbraco CMS](https://umbraco.com) · [](../LICENSE.md) [](https://umbraco.visualstudio.com/Umbraco%20Cms/_build?definitionId=75) [](CONTRIBUTING.md) [](https://twitter.com/intent/follow?screen_name=umbraco)
Umbraco is the friendliest, most flexible and fastest growing ASP.NET CMS, and used by more than 500,000 websites worldwide. Our mission is to help you deliver delightful digital experiences by making Umbraco friendly, simpler and social.
diff --git a/.github/img/defaultbranch.png b/.github/img/defaultbranch.png
index f3a5b9efbc..3550b5c34c 100644
Binary files a/.github/img/defaultbranch.png and b/.github/img/defaultbranch.png differ
diff --git a/.gitignore b/.gitignore
index a0ff4d5b27..12ad3299ad 100644
--- a/.gitignore
+++ b/.gitignore
@@ -55,6 +55,7 @@ App_Data/TEMP/*
src/Umbraco.Web.UI/[Cc]ss/*
src/Umbraco.Web.UI/App_Code/*
src/Umbraco.Web.UI/App_Data/*
+src/Umbraco.Web.UI/data/*
src/Umbraco.Tests/App_Data/*
src/Umbraco.Web.UI/[Mm]edia/*
src/Umbraco.Web.UI/[Mm]aster[Pp]ages/*
diff --git a/build/NuSpecs/UmbracoCms.Web.nuspec b/build/NuSpecs/UmbracoCms.Web.nuspec
index c8374bc2f7..347bde139e 100644
--- a/build/NuSpecs/UmbracoCms.Web.nuspec
+++ b/build/NuSpecs/UmbracoCms.Web.nuspec
@@ -28,7 +28,7 @@
-
+
@@ -52,14 +52,17 @@
+
+
+
diff --git a/build/NuSpecs/UmbracoCms.nuspec b/build/NuSpecs/UmbracoCms.nuspec
index 97e9ef3df2..a6b06d9964 100644
--- a/build/NuSpecs/UmbracoCms.nuspec
+++ b/build/NuSpecs/UmbracoCms.nuspec
@@ -26,7 +26,6 @@
not want this to happen as the alpha of the next major is, really, the next major already.
-->
-
diff --git a/build/build.ps1 b/build/build.ps1
index 892654d3cd..ea07e4516f 100644
--- a/build/build.ps1
+++ b/build/build.ps1
@@ -456,10 +456,10 @@
$ubuild.DefineMethod("PrepareAngularDocs",
{
Write-Host "Prepare Angular Documentation"
-
+
$src = "$($this.SolutionRoot)\src"
$out = $this.BuildOutput
-
+
"Moving to Umbraco.Web.UI.Docs folder"
cd ..\src\Umbraco.Web.UI.Docs
diff --git a/src/SolutionInfo.cs b/src/SolutionInfo.cs
index 363677b826..a0d969c1b8 100644
--- a/src/SolutionInfo.cs
+++ b/src/SolutionInfo.cs
@@ -18,5 +18,5 @@ using System.Resources;
[assembly: AssemblyVersion("8.0.0")]
// these are FYI and changed automatically
-[assembly: AssemblyFileVersion("8.6.0")]
-[assembly: AssemblyInformationalVersion("8.6.0")]
+[assembly: AssemblyFileVersion("8.7.0")]
+[assembly: AssemblyInformationalVersion("8.7.0")]
diff --git a/src/Umbraco.Core/Cache/WebCachingAppCache.cs b/src/Umbraco.Core/Cache/WebCachingAppCache.cs
index c6e104221a..044aab4c42 100644
--- a/src/Umbraco.Core/Cache/WebCachingAppCache.cs
+++ b/src/Umbraco.Core/Cache/WebCachingAppCache.cs
@@ -86,7 +86,7 @@ namespace Umbraco.Core.Cache
protected override void EnterWriteLock()
{
- _locker.EnterWriteLock();;
+ _locker.EnterWriteLock();
}
protected override void ExitReadLock()
diff --git a/src/Umbraco.Core/Collections/ConcurrentHashSet.cs b/src/Umbraco.Core/Collections/ConcurrentHashSet.cs
index 54367ed588..c4dba51acd 100644
--- a/src/Umbraco.Core/Collections/ConcurrentHashSet.cs
+++ b/src/Umbraco.Core/Collections/ConcurrentHashSet.cs
@@ -70,7 +70,23 @@ namespace Umbraco.Core.Collections
/// The number of elements contained in the .
///
/// 2
- public int Count => GetThreadSafeClone().Count;
+ public int Count
+ {
+ get
+ {
+ try
+ {
+ _instanceLocker.EnterReadLock();
+ return _innerSet.Count;
+ }
+ finally
+ {
+ if (_instanceLocker.IsReadLockHeld)
+ _instanceLocker.ExitReadLock();
+ }
+
+ }
+ }
///
/// Gets a value indicating whether the is read-only.
@@ -105,8 +121,7 @@ namespace Umbraco.Core.Collections
///
public bool TryAdd(T item)
{
- var clone = GetThreadSafeClone();
- if (clone.Contains(item)) return false;
+ if (Contains(item)) return false;
try
{
_instanceLocker.EnterWriteLock();
@@ -150,7 +165,16 @@ namespace Umbraco.Core.Collections
/// The object to locate in the .
public bool Contains(T item)
{
- return GetThreadSafeClone().Contains(item);
+ try
+ {
+ _instanceLocker.EnterReadLock();
+ return _innerSet.Contains(item);
+ }
+ finally
+ {
+ if (_instanceLocker.IsReadLockHeld)
+ _instanceLocker.ExitReadLock();
+ }
}
///
@@ -168,13 +192,13 @@ namespace Umbraco.Core.Collections
HashSet clone = null;
try
{
- _instanceLocker.EnterWriteLock();
+ _instanceLocker.EnterReadLock();
clone = new HashSet(_innerSet, _innerSet.Comparer);
}
finally
{
- if (_instanceLocker.IsWriteLockHeld)
- _instanceLocker.ExitWriteLock();
+ if (_instanceLocker.IsReadLockHeld)
+ _instanceLocker.ExitReadLock();
}
return clone;
}
diff --git a/src/Umbraco.Core/Collections/TopoGraph.cs b/src/Umbraco.Core/Collections/TopoGraph.cs
index b8ded4a458..955a210465 100644
--- a/src/Umbraco.Core/Collections/TopoGraph.cs
+++ b/src/Umbraco.Core/Collections/TopoGraph.cs
@@ -126,7 +126,7 @@ namespace Umbraco.Core.Collections
if (_items.TryGetValue(key, out value))
yield return value;
else if (throwOnMissing)
- throw new Exception(MissingDependencyError);
+ throw new Exception($"{MissingDependencyError} Error in type {typeof(TItem).Name}, with key {key}");
}
}
}
diff --git a/src/Umbraco.Core/Compose/RelateOnCopyComponent.cs b/src/Umbraco.Core/Compose/RelateOnCopyComponent.cs
index 63a7e170da..b56ff8b87e 100644
--- a/src/Umbraco.Core/Compose/RelateOnCopyComponent.cs
+++ b/src/Umbraco.Core/Compose/RelateOnCopyComponent.cs
@@ -26,10 +26,11 @@ namespace Umbraco.Core.Compose
if (relationType == null)
{
- relationType = new RelationType(Constants.ObjectTypes.Document,
+ relationType = new RelationType(Constants.Conventions.RelationTypes.RelateDocumentOnCopyAlias,
+ Constants.Conventions.RelationTypes.RelateDocumentOnCopyName,
+ true,
Constants.ObjectTypes.Document,
- Constants.Conventions.RelationTypes.RelateDocumentOnCopyAlias,
- Constants.Conventions.RelationTypes.RelateDocumentOnCopyName) { IsBidirectional = true };
+ Constants.ObjectTypes.Document);
relationService.Save(relationType);
}
diff --git a/src/Umbraco.Core/Compose/RelateOnTrashComponent.cs b/src/Umbraco.Core/Compose/RelateOnTrashComponent.cs
index 8371f9b279..4e01c50fc6 100644
--- a/src/Umbraco.Core/Compose/RelateOnTrashComponent.cs
+++ b/src/Umbraco.Core/Compose/RelateOnTrashComponent.cs
@@ -63,7 +63,7 @@ namespace Umbraco.Core.Compose
var documentObjectType = Constants.ObjectTypes.Document;
const string relationTypeName = Constants.Conventions.RelationTypes.RelateParentDocumentOnDeleteName;
- relationType = new RelationType(documentObjectType, documentObjectType, relationTypeAlias, relationTypeName);
+ relationType = new RelationType(relationTypeName, relationTypeAlias, false, documentObjectType, documentObjectType);
relationService.Save(relationType);
}
@@ -106,7 +106,7 @@ namespace Umbraco.Core.Compose
{
var documentObjectType = Constants.ObjectTypes.Document;
const string relationTypeName = Constants.Conventions.RelationTypes.RelateParentMediaFolderOnDeleteName;
- relationType = new RelationType(documentObjectType, documentObjectType, relationTypeAlias, relationTypeName);
+ relationType = new RelationType(relationTypeName, relationTypeAlias, false, documentObjectType, documentObjectType);
relationService.Save(relationType);
}
foreach (var item in e.MoveInfoCollection)
diff --git a/src/Umbraco.Core/Composing/ComponentCollection.cs b/src/Umbraco.Core/Composing/ComponentCollection.cs
index 9b5319dc41..62b240f10f 100644
--- a/src/Umbraco.Core/Composing/ComponentCollection.cs
+++ b/src/Umbraco.Core/Composing/ComponentCollection.cs
@@ -1,4 +1,5 @@
-using System.Collections.Generic;
+using System;
+using System.Collections.Generic;
using System.Linq;
using Umbraco.Core.Logging;
@@ -43,8 +44,15 @@ namespace Umbraco.Core.Composing
var componentType = component.GetType();
using (_logger.DebugDuration($"Terminating {componentType.FullName}.", $"Terminated {componentType.FullName}.", thresholdMilliseconds: LogThresholdMilliseconds))
{
- component.Terminate();
- component.DisposeIfDisposable();
+ try
+ {
+ component.Terminate();
+ component.DisposeIfDisposable();
+ }
+ catch (Exception ex)
+ {
+ _logger.Error(ex, "Error while terminating component {ComponentType}.", componentType.FullName);
+ }
}
}
}
diff --git a/src/Umbraco.Core/Composing/Composers.cs b/src/Umbraco.Core/Composing/Composers.cs
index 0510740e42..b2e6c9d068 100644
--- a/src/Umbraco.Core/Composing/Composers.cs
+++ b/src/Umbraco.Core/Composing/Composers.cs
@@ -18,19 +18,52 @@ namespace Umbraco.Core.Composing
private readonly Composition _composition;
private readonly IProfilingLogger _logger;
private readonly IEnumerable _composerTypes;
+ private readonly IEnumerable _enableDisableAttributes;
private const int LogThresholdMilliseconds = 100;
///
- /// Initializes a new instance of the class.
+ /// Initializes a new instance of the class.
///
/// The composition.
- /// The composer types.
- /// A profiling logger.
+ /// The types.
+ /// The profiling logger.
+ [Obsolete("This overload only gets the EnableComposer/DisableComposer attributes from the composerTypes assemblies.")]
public Composers(Composition composition, IEnumerable composerTypes, IProfilingLogger logger)
+ : this(composition, composerTypes, Enumerable.Empty(), logger)
+ {
+ var enableDisableAttributes = new List();
+
+ var assemblies = composerTypes.Select(t => t.Assembly).Distinct();
+ foreach (var assembly in assemblies)
+ {
+ enableDisableAttributes.AddRange(assembly.GetCustomAttributes(typeof(EnableComposerAttribute)));
+ enableDisableAttributes.AddRange(assembly.GetCustomAttributes(typeof(DisableComposerAttribute)));
+ }
+
+ _enableDisableAttributes = enableDisableAttributes;
+ }
+
+ ///
+ /// Initializes a new instance of the class.
+ ///
+ /// The composition.
+ /// The types.
+ /// The and/or attributes.
+ /// The profiling logger.
+ /// composition
+ /// or
+ /// composerTypes
+ /// or
+ /// enableDisableAttributes
+ /// or
+ /// logger
+
+ public Composers(Composition composition, IEnumerable composerTypes, IEnumerable enableDisableAttributes, IProfilingLogger logger)
{
_composition = composition ?? throw new ArgumentNullException(nameof(composition));
_composerTypes = composerTypes ?? throw new ArgumentNullException(nameof(composerTypes));
+ _enableDisableAttributes = enableDisableAttributes ?? throw new ArgumentNullException(nameof(enableDisableAttributes));
_logger = logger ?? throw new ArgumentNullException(nameof(logger));
}
@@ -103,7 +136,7 @@ namespace Umbraco.Core.Composing
.ToList();
// enable or disable composers
- EnableDisableComposers(composerTypeList);
+ EnableDisableComposers(_enableDisableAttributes, composerTypeList);
void GatherInterfaces(Type type, Func getTypeInAttribute, HashSet iset, List set2)
where TAttribute : Attribute
@@ -218,7 +251,7 @@ namespace Umbraco.Core.Composing
return text.ToString();
}
- private static void EnableDisableComposers(ICollection types)
+ private static void EnableDisableComposers(IEnumerable enableDisableAttributes, ICollection types)
{
var enabled = new Dictionary();
@@ -240,20 +273,16 @@ namespace Umbraco.Core.Composing
enableInfo.Weight = weight2;
}
- var assemblies = types.Select(x => x.Assembly).Distinct();
- foreach (var assembly in assemblies)
+ foreach (var attr in enableDisableAttributes.OfType())
{
- foreach (var attr in assembly.GetCustomAttributes())
- {
- var type = attr.EnabledType;
- UpdateEnableInfo(type, 2, enabled, true);
- }
+ var type = attr.EnabledType;
+ UpdateEnableInfo(type, 2, enabled, true);
+ }
- foreach (var attr in assembly.GetCustomAttributes())
- {
- var type = attr.DisabledType;
- UpdateEnableInfo(type, 2, enabled, false);
- }
+ foreach (var attr in enableDisableAttributes.OfType())
+ {
+ var type = attr.DisabledType;
+ UpdateEnableInfo(type, 2, enabled, false);
}
foreach (var composerType in types)
diff --git a/src/Umbraco.Core/Composing/Current.cs b/src/Umbraco.Core/Composing/Current.cs
index f12bf0dd63..a06f09baf6 100644
--- a/src/Umbraco.Core/Composing/Current.cs
+++ b/src/Umbraco.Core/Composing/Current.cs
@@ -5,6 +5,7 @@ using Umbraco.Core.Dictionary;
using Umbraco.Core.IO;
using Umbraco.Core.Logging;
using Umbraco.Core.Mapping;
+using Umbraco.Core.Models;
using Umbraco.Core.Models.PublishedContent;
using Umbraco.Core.PackageActions;
using Umbraco.Core.Packaging;
@@ -154,6 +155,9 @@ namespace Umbraco.Core.Composing
public static DataEditorCollection DataEditors
=> Factory.GetInstance();
+ public static DataValueReferenceFactoryCollection DataValueReferenceFactories
+ => Factory.GetInstance();
+
public static PropertyEditorCollection PropertyEditors
=> Factory.GetInstance();
@@ -205,6 +209,8 @@ namespace Umbraco.Core.Composing
public static IVariationContextAccessor VariationContextAccessor
=> Factory.GetInstance();
+ public static IImageUrlGenerator ImageUrlGenerator
+ => Factory.GetInstance();
#endregion
}
}
diff --git a/src/Umbraco.Core/Composing/TypeLoader.cs b/src/Umbraco.Core/Composing/TypeLoader.cs
index 9f3b4b6858..6d0b1a0514 100644
--- a/src/Umbraco.Core/Composing/TypeLoader.cs
+++ b/src/Umbraco.Core/Composing/TypeLoader.cs
@@ -506,6 +506,49 @@ namespace Umbraco.Core.Composing
#endregion
+ #region Get Assembly Attributes
+
+ ///
+ /// Gets the assembly attributes of the specified type .
+ ///
+ /// The attribute type.
+ ///
+ /// The assembly attributes of the specified type .
+ ///
+ public IEnumerable GetAssemblyAttributes()
+ where T : Attribute
+ {
+ return AssembliesToScan.SelectMany(a => a.GetCustomAttributes()).ToList();
+ }
+
+ ///
+ /// Gets all the assembly attributes.
+ ///
+ ///
+ /// All assembly attributes.
+ ///
+ public IEnumerable GetAssemblyAttributes()
+ {
+ return AssembliesToScan.SelectMany(a => a.GetCustomAttributes()).ToList();
+ }
+
+ ///
+ /// Gets the assembly attributes of the specified .
+ ///
+ /// The attribute types.
+ ///
+ /// The assembly attributes of the specified types.
+ ///
+ /// attributeTypes
+ public IEnumerable GetAssemblyAttributes(params Type[] attributeTypes)
+ {
+ if (attributeTypes == null) throw new ArgumentNullException(nameof(attributeTypes));
+
+ return AssembliesToScan.SelectMany(a => attributeTypes.SelectMany(at => a.GetCustomAttributes(at))).ToList();
+ }
+
+ #endregion
+
#region Get Types
///
diff --git a/src/Umbraco.Core/CompositionExtensions.cs b/src/Umbraco.Core/CompositionExtensions.cs
index 5dd33c2a60..ced9a9386a 100644
--- a/src/Umbraco.Core/CompositionExtensions.cs
+++ b/src/Umbraco.Core/CompositionExtensions.cs
@@ -49,6 +49,13 @@ namespace Umbraco.Core
public static DataEditorCollectionBuilder DataEditors(this Composition composition)
=> composition.WithCollectionBuilder();
+ ///
+ /// Gets the data value reference factory collection builder.
+ ///
+ /// The composition.
+ public static DataValueReferenceFactoryCollectionBuilder DataValueReferenceFactories(this Composition composition)
+ => composition.WithCollectionBuilder();
+
///
/// Gets the property value converters collection builder.
///
diff --git a/src/Umbraco.Core/Configuration/UmbracoSettings/IKeepAliveSection.cs b/src/Umbraco.Core/Configuration/UmbracoSettings/IKeepAliveSection.cs
new file mode 100644
index 0000000000..3a0ad258c5
--- /dev/null
+++ b/src/Umbraco.Core/Configuration/UmbracoSettings/IKeepAliveSection.cs
@@ -0,0 +1,8 @@
+namespace Umbraco.Core.Configuration.UmbracoSettings
+{
+ public interface IKeepAliveSection : IUmbracoConfigurationSection
+ {
+ bool DisableKeepAliveTask { get; }
+ string KeepAlivePingUrl { get; }
+ }
+}
diff --git a/src/Umbraco.Core/Configuration/UmbracoSettings/IUmbracoSettingsSection.cs b/src/Umbraco.Core/Configuration/UmbracoSettings/IUmbracoSettingsSection.cs
index 81d27e7bae..acd9c92588 100644
--- a/src/Umbraco.Core/Configuration/UmbracoSettings/IUmbracoSettingsSection.cs
+++ b/src/Umbraco.Core/Configuration/UmbracoSettings/IUmbracoSettingsSection.cs
@@ -15,5 +15,7 @@ namespace Umbraco.Core.Configuration.UmbracoSettings
ILoggingSection Logging { get; }
IWebRoutingSection WebRouting { get; }
+
+ IKeepAliveSection KeepAlive { get; }
}
}
diff --git a/src/Umbraco.Core/Configuration/UmbracoSettings/KeepAliveElement.cs b/src/Umbraco.Core/Configuration/UmbracoSettings/KeepAliveElement.cs
new file mode 100644
index 0000000000..89ba9be54d
--- /dev/null
+++ b/src/Umbraco.Core/Configuration/UmbracoSettings/KeepAliveElement.cs
@@ -0,0 +1,13 @@
+using System.Configuration;
+
+namespace Umbraco.Core.Configuration.UmbracoSettings
+{
+ internal class KeepAliveElement : ConfigurationElement, IKeepAliveSection
+ {
+ [ConfigurationProperty("disableKeepAliveTask", DefaultValue = "false")]
+ public bool DisableKeepAliveTask => (bool)base["disableKeepAliveTask"];
+
+ [ConfigurationProperty("keepAlivePingUrl", DefaultValue = "{umbracoApplicationUrl}/api/keepalive/ping")]
+ public string KeepAlivePingUrl => (string)base["keepAlivePingUrl"];
+ }
+}
diff --git a/src/Umbraco.Core/Configuration/UmbracoSettings/UmbracoSettingsSection.cs b/src/Umbraco.Core/Configuration/UmbracoSettings/UmbracoSettingsSection.cs
index 7cf8096345..17430c81eb 100644
--- a/src/Umbraco.Core/Configuration/UmbracoSettings/UmbracoSettingsSection.cs
+++ b/src/Umbraco.Core/Configuration/UmbracoSettings/UmbracoSettingsSection.cs
@@ -19,10 +19,12 @@ namespace Umbraco.Core.Configuration.UmbracoSettings
[ConfigurationProperty("logging")]
internal LoggingElement Logging => (LoggingElement)this["logging"];
-
[ConfigurationProperty("web.routing")]
internal WebRoutingElement WebRouting => (WebRoutingElement)this["web.routing"];
+ [ConfigurationProperty("keepAlive")]
+ internal KeepAliveElement KeepAlive => (KeepAliveElement)this["keepAlive"];
+
IContentSection IUmbracoSettingsSection.Content => Content;
ISecuritySection IUmbracoSettingsSection.Security => Security;
@@ -34,5 +36,7 @@ namespace Umbraco.Core.Configuration.UmbracoSettings
ILoggingSection IUmbracoSettingsSection.Logging => Logging;
IWebRoutingSection IUmbracoSettingsSection.WebRouting => WebRouting;
+
+ IKeepAliveSection IUmbracoSettingsSection.KeepAlive => KeepAlive;
}
}
diff --git a/src/Umbraco.Core/Constants-AppSettings.cs b/src/Umbraco.Core/Constants-AppSettings.cs
index 509be46b61..704617d90c 100644
--- a/src/Umbraco.Core/Constants-AppSettings.cs
+++ b/src/Umbraco.Core/Constants-AppSettings.cs
@@ -9,6 +9,8 @@ namespace Umbraco.Core
///
public static class AppSettings
{
+ public const string MainDomLock = "Umbraco.Core.MainDom.Lock";
+
// TODO: Kill me - still used in Umbraco.Core.IO.SystemFiles:27
[Obsolete("We need to kill this appsetting as we do not use XML content cache umbraco.config anymore due to NuCache")]
public const string ContentXML = "Umbraco.Core.ContentXML"; //umbracoContentXML
@@ -41,6 +43,21 @@ namespace Umbraco.Core
///
public const string Path = "Umbraco.Core.Path";
+ ///
+ /// Gets the path to the css directory (/css by default).
+ ///
+ public const string CssPath = "umbracoCssPath";
+
+ ///
+ /// Gets the path to the scripts directory (/scripts by default).
+ ///
+ public const string ScriptsPath = "umbracoScriptsPath";
+
+ ///
+ /// Gets the path to media directory (/media by default).
+ ///
+ public const string MediaPath = "umbracoMediaPath";
+
///
/// The reserved urls from web.config.
///
diff --git a/src/Umbraco.Core/Constants-Conventions.cs b/src/Umbraco.Core/Constants-Conventions.cs
index e78c498e66..c1d7103a1c 100644
--- a/src/Umbraco.Core/Constants-Conventions.cs
+++ b/src/Umbraco.Core/Constants-Conventions.cs
@@ -315,34 +315,65 @@ namespace Umbraco.Core
public static class RelationTypes
{
///
- /// ContentType name for default relation type "Relate Document On Copy".
+ /// Name for default relation type "Related Media".
+ ///
+ public const string RelatedMediaName = "Related Media";
+
+ ///
+ /// Alias for default relation type "Related Media"
+ ///
+ public const string RelatedMediaAlias = "umbMedia";
+
+ ///
+ /// Name for default relation type "Related Document".
+ ///
+ public const string RelatedDocumentName = "Related Document";
+
+ ///
+ /// Alias for default relation type "Related Document"
+ ///
+ public const string RelatedDocumentAlias = "umbDocument";
+
+ ///
+ /// Name for default relation type "Relate Document On Copy".
///
public const string RelateDocumentOnCopyName = "Relate Document On Copy";
///
- /// ContentType alias for default relation type "Relate Document On Copy".
+ /// Alias for default relation type "Relate Document On Copy".
///
public const string RelateDocumentOnCopyAlias = "relateDocumentOnCopy";
///
- /// ContentType name for default relation type "Relate Parent Document On Delete".
+ /// Name for default relation type "Relate Parent Document On Delete".
///
public const string RelateParentDocumentOnDeleteName = "Relate Parent Document On Delete";
///
- /// ContentType alias for default relation type "Relate Parent Document On Delete".
+ /// Alias for default relation type "Relate Parent Document On Delete".
///
public const string RelateParentDocumentOnDeleteAlias = "relateParentDocumentOnDelete";
///
- /// ContentType name for default relation type "Relate Parent Media Folder On Delete".
+ /// Name for default relation type "Relate Parent Media Folder On Delete".
///
public const string RelateParentMediaFolderOnDeleteName = "Relate Parent Media Folder On Delete";
///
- /// ContentType alias for default relation type "Relate Parent Media Folder On Delete".
+ /// Alias for default relation type "Relate Parent Media Folder On Delete".
///
public const string RelateParentMediaFolderOnDeleteAlias = "relateParentMediaFolderOnDelete";
+
+ ///
+ /// Returns the types of relations that are automatically tracked
+ ///
+ ///
+ /// Developers should not manually use these relation types since they will all be cleared whenever an entity
+ /// (content, media or member) is saved since they are auto-populated based on property values.
+ ///
+ public static string[] AutomaticRelationTypes = new[] { RelatedMediaAlias, RelatedDocumentAlias };
+
+ //TODO: return a list of built in types so we can use that to prevent deletion in the uI
}
}
}
diff --git a/src/Umbraco.Core/UdiEntityType.cs b/src/Umbraco.Core/Contants-UdiEntityType.cs
similarity index 100%
rename from src/Umbraco.Core/UdiEntityType.cs
rename to src/Umbraco.Core/Contants-UdiEntityType.cs
diff --git a/src/Umbraco.Core/ContentExtensions.cs b/src/Umbraco.Core/ContentExtensions.cs
index a7d40b0b7d..3edad0c963 100644
--- a/src/Umbraco.Core/ContentExtensions.cs
+++ b/src/Umbraco.Core/ContentExtensions.cs
@@ -13,6 +13,7 @@ using Umbraco.Core.IO;
using Umbraco.Core.Models;
using Umbraco.Core.Models.Entities;
using Umbraco.Core.Models.Membership;
+using Umbraco.Core.PropertyEditors;
using Umbraco.Core.Services;
using Umbraco.Core.Services.Implement;
@@ -23,6 +24,8 @@ namespace Umbraco.Core
// this ain't pretty
private static IMediaFileSystem _mediaFileSystem;
private static IMediaFileSystem MediaFileSystem => _mediaFileSystem ?? (_mediaFileSystem = Current.MediaFileSystem);
+ private static readonly PropertyEditorCollection _propertyEditors;
+ private static PropertyEditorCollection PropertyEditors = _propertyEditors ?? (_propertyEditors = Current.PropertyEditors);
#region IContent
@@ -162,14 +165,12 @@ namespace Umbraco.Core
// Fixes https://github.com/umbraco/Umbraco-CMS/issues/3937 - Assigning a new file to an
// existing IMedia with extension SetValue causes exception 'Illegal characters in path'
string oldpath = null;
- if (property.GetValue(culture, segment) is string svalue)
+ var value = property.GetValue(culture, segment);
+
+ if (PropertyEditors.TryGet(propertyTypeAlias, out var editor)
+ && editor is IDataEditorWithMediaPath dataEditor)
{
- if (svalue.DetectIsJson())
- {
- // the property value is a JSON serialized image crop data set - grab the "src" property as the file source
- var jObject = JsonConvert.DeserializeObject(svalue);
- svalue = jObject != null ? jObject.GetValueAsString("src") : svalue;
- }
+ var svalue = dataEditor.GetMediaPath(value);
oldpath = MediaFileSystem.GetRelativePath(svalue);
}
diff --git a/src/Umbraco.Core/ContentVariationExtensions.cs b/src/Umbraco.Core/ContentVariationExtensions.cs
index 5b157307ab..29442b78e6 100644
--- a/src/Umbraco.Core/ContentVariationExtensions.cs
+++ b/src/Umbraco.Core/ContentVariationExtensions.cs
@@ -12,121 +12,260 @@ namespace Umbraco.Core
///
/// Determines whether the content type is invariant.
///
+ /// The content type.
+ ///
+ /// A value indicating whether the content type is invariant.
+ ///
public static bool VariesByNothing(this ISimpleContentType contentType) => contentType.Variations.VariesByNothing();
- ///
- /// Determines whether the content type varies by culture.
- ///
- public static bool VariesByCulture(this ISimpleContentType contentType) => contentType.Variations.VariesByCulture();
-
///
/// Determines whether the content type is invariant.
///
+ /// The content type.
+ ///
+ /// A value indicating whether the content type is invariant.
+ ///
public static bool VariesByNothing(this IContentTypeBase contentType) => contentType.Variations.VariesByNothing();
- ///
- /// Determines whether the content type varies by culture.
- ///
- /// And then it could also vary by segment.
- public static bool VariesByCulture(this IContentTypeBase contentType) => contentType.Variations.VariesByCulture();
-
- ///
- /// Determines whether the content type varies by segment.
- ///
- /// And then it could also vary by culture.
- public static bool VariesBySegment(this IContentTypeBase contentType) => contentType.Variations.VariesBySegment();
-
- ///
- /// Determines whether the content type varies by culture and segment.
- ///
- public static bool VariesByCultureAndSegment(this IContentTypeBase contentType) => contentType.Variations.VariesByCultureAndSegment();
-
- ///
- /// Determines whether the property type is invariant.
- ///
- public static bool VariesByNothing(this PropertyType propertyType) => propertyType.Variations.VariesByNothing();
-
- ///
- /// Determines whether the property type varies by culture.
- ///
- /// And then it could also vary by segment.
- public static bool VariesByCulture(this PropertyType propertyType) => propertyType.Variations.VariesByCulture();
-
- ///
- /// Determines whether the property type varies by segment.
- ///
- /// And then it could also vary by culture.
- public static bool VariesBySegment(this PropertyType propertyType) => propertyType.Variations.VariesBySegment();
-
- ///
- /// Determines whether the property type varies by culture and segment.
- ///
- public static bool VariesByCultureAndSegment(this PropertyType propertyType) => propertyType.Variations.VariesByCultureAndSegment();
-
///
/// Determines whether the content type is invariant.
///
+ /// The content type.
+ ///
+ /// A value indicating whether the content type is invariant.
+ ///
public static bool VariesByNothing(this IPublishedContentType contentType) => contentType.Variations.VariesByNothing();
///
- /// Determines whether the content type varies by culture.
+ /// Determines whether the property type is invariant.
///
- /// And then it could also vary by segment.
- public static bool VariesByCulture(this IPublishedContentType contentType) => contentType.Variations.VariesByCulture();
-
- ///
- /// Determines whether the content type varies by segment.
- ///
- /// And then it could also vary by culture.
- public static bool VariesBySegment(this IPublishedContentType contentType) => contentType.Variations.VariesBySegment();
-
- ///
- /// Determines whether the content type varies by culture and segment.
- ///
- public static bool VariesByCultureAndSegment(this IPublishedContentType contentType) => contentType.Variations.VariesByCultureAndSegment();
+ /// The property type.
+ ///
+ /// A value indicating whether the property type is invariant.
+ ///
+ public static bool VariesByNothing(this PropertyType propertyType) => propertyType.Variations.VariesByNothing();
///
/// Determines whether the property type is invariant.
///
+ /// The property type.
+ ///
+ /// A value indicating whether the property type is invariant.
+ ///
public static bool VariesByNothing(this IPublishedPropertyType propertyType) => propertyType.Variations.VariesByNothing();
- ///
- /// Determines whether the property type varies by culture.
- ///
- public static bool VariesByCulture(this IPublishedPropertyType propertyType) => propertyType.Variations.VariesByCulture();
-
- ///
- /// Determines whether the property type varies by segment.
- ///
- public static bool VariesBySegment(this IPublishedPropertyType propertyType) => propertyType.Variations.VariesBySegment();
-
- ///
- /// Determines whether the property type varies by culture and segment.
- ///
- public static bool VariesByCultureAndSegment(this IPublishedPropertyType propertyType) => propertyType.Variations.VariesByCultureAndSegment();
-
///
/// Determines whether a variation is invariant.
///
+ /// The variation.
+ ///
+ /// A value indicating whether the variation is invariant.
+ ///
public static bool VariesByNothing(this ContentVariation variation) => variation == ContentVariation.Nothing;
+ ///
+ /// Determines whether the content type varies by culture.
+ ///
+ /// The content type.
+ ///
+ /// A value indicating whether the content type varies by culture.
+ ///
+ public static bool VariesByCulture(this ISimpleContentType contentType) => contentType.Variations.VariesByCulture();
+
+ ///
+ /// Determines whether the content type varies by culture.
+ ///
+ /// The content type.
+ ///
+ /// A value indicating whether the content type varies by culture.
+ ///
+ public static bool VariesByCulture(this IContentTypeBase contentType) => contentType.Variations.VariesByCulture();
+
+ ///
+ /// Determines whether the content type varies by culture.
+ ///
+ /// The content type.
+ ///
+ /// A value indicating whether the content type varies by culture.
+ ///
+ public static bool VariesByCulture(this IPublishedContentType contentType) => contentType.Variations.VariesByCulture();
+
+ ///
+ /// Determines whether the property type varies by culture.
+ ///
+ /// The property type.
+ ///
+ /// A value indicating whether the property type varies by culture.
+ ///
+ public static bool VariesByCulture(this PropertyType propertyType) => propertyType.Variations.VariesByCulture();
+
+ ///
+ /// Determines whether the property type varies by culture.
+ ///
+ /// The property type.
+ ///
+ /// A value indicating whether the property type varies by culture.
+ ///
+ public static bool VariesByCulture(this IPublishedPropertyType propertyType) => propertyType.Variations.VariesByCulture();
+
///
/// Determines whether a variation varies by culture.
///
- /// And then it could also vary by segment.
+ /// The variation.
+ ///
+ /// A value indicating whether the variation varies by culture.
+ ///
public static bool VariesByCulture(this ContentVariation variation) => (variation & ContentVariation.Culture) > 0;
+ ///
+ /// Determines whether the content type varies by segment.
+ ///
+ /// The content type.
+ ///
+ /// A value indicating whether the content type varies by segment.
+ ///
+ public static bool VariesBySegment(this ISimpleContentType contentType) => contentType.Variations.VariesBySegment();
+
+ ///
+ /// Determines whether the content type varies by segment.
+ ///
+ /// The content type.
+ ///
+ /// A value indicating whether the content type varies by segment.
+ ///
+ public static bool VariesBySegment(this IContentTypeBase contentType) => contentType.Variations.VariesBySegment();
+
+ ///
+ /// Determines whether the content type varies by segment.
+ ///
+ /// The content type.
+ ///
+ /// A value indicating whether the content type varies by segment.
+ ///
+ public static bool VariesBySegment(this IPublishedContentType contentType) => contentType.Variations.VariesBySegment();
+
+ ///
+ /// Determines whether the property type varies by segment.
+ ///
+ /// The property type.
+ ///
+ /// A value indicating whether the property type varies by segment.
+ ///
+ public static bool VariesBySegment(this PropertyType propertyType) => propertyType.Variations.VariesBySegment();
+
+ ///
+ /// Determines whether the property type varies by segment.
+ ///
+ /// The property type.
+ ///
+ /// A value indicating whether the property type varies by segment.
+ ///
+ public static bool VariesBySegment(this IPublishedPropertyType propertyType) => propertyType.Variations.VariesBySegment();
+
///
/// Determines whether a variation varies by segment.
///
- /// And then it could also vary by culture.
+ /// The variation.
+ ///
+ /// A value indicating whether the variation varies by segment.
+ ///
public static bool VariesBySegment(this ContentVariation variation) => (variation & ContentVariation.Segment) > 0;
+ ///
+ /// Determines whether the content type varies by culture and segment.
+ ///
+ /// The content type.
+ ///
+ /// A value indicating whether the content type varies by culture and segment.
+ ///
+ public static bool VariesByCultureAndSegment(this ISimpleContentType contentType) => contentType.Variations.VariesByCultureAndSegment();
+
+ ///
+ /// Determines whether the content type varies by culture and segment.
+ ///
+ /// The content type.
+ ///
+ /// A value indicating whether the content type varies by culture and segment.
+ ///
+ public static bool VariesByCultureAndSegment(this IContentTypeBase contentType) => contentType.Variations.VariesByCultureAndSegment();
+
+ ///
+ /// Determines whether the content type varies by culture and segment.
+ ///
+ /// The content type.
+ ///
+ /// A value indicating whether the content type varies by culture and segment.
+ ///
+ public static bool VariesByCultureAndSegment(this IPublishedContentType contentType) => contentType.Variations.VariesByCultureAndSegment();
+
+ ///
+ /// Determines whether the property type varies by culture and segment.
+ ///
+ /// The property type.
+ ///
+ /// A value indicating whether the property type varies by culture and segment.
+ ///
+ public static bool VariesByCultureAndSegment(this PropertyType propertyType) => propertyType.Variations.VariesByCultureAndSegment();
+
+ ///
+ /// Determines whether the property type varies by culture and segment.
+ ///
+ /// The property type.
+ ///
+ /// A value indicating whether the property type varies by culture and segment.
+ ///
+ public static bool VariesByCultureAndSegment(this IPublishedPropertyType propertyType) => propertyType.Variations.VariesByCultureAndSegment();
+
///
/// Determines whether a variation varies by culture and segment.
///
+ /// The variation.
+ ///
+ /// A value indicating whether the variation varies by culture and segment.
+ ///
public static bool VariesByCultureAndSegment(this ContentVariation variation) => (variation & ContentVariation.CultureAndSegment) == ContentVariation.CultureAndSegment;
+ ///
+ /// Sets or removes the content type variation depending on the specified value.
+ ///
+ /// The content type.
+ /// The variation to set or remove.
+ /// If set to true sets the variation; otherwise, removes the variation.
+ ///
+ /// This method does not support setting the variation to nothing.
+ ///
+ public static void SetVariesBy(this IContentTypeBase contentType, ContentVariation variation, bool value = true) => contentType.Variations = contentType.Variations.SetFlag(variation, value);
+
+ ///
+ /// Sets or removes the property type variation depending on the specified value.
+ ///
+ /// The property type.
+ /// The variation to set or remove.
+ /// If set to true sets the variation; otherwise, removes the variation.
+ ///
+ /// This method does not support setting the variation to nothing.
+ ///
+ public static void SetVariesBy(this PropertyType propertyType, ContentVariation variation, bool value = true) => propertyType.Variations = propertyType.Variations.SetFlag(variation, value);
+
+ ///
+ /// Returns the variations with the variation set or removed depending on the specified value.
+ ///
+ /// The existing variations.
+ /// The variation to set or remove.
+ /// If set to true sets the variation; otherwise, removes the variation.
+ ///
+ /// The variations with the variation set or removed.
+ ///
+ ///
+ /// This method does not support setting the variation to nothing.
+ ///
+ public static ContentVariation SetFlag(this ContentVariation variations, ContentVariation variation, bool value = true)
+ {
+ return value
+ ? variations | variation // Set flag using bitwise logical OR
+ : variations & ~variation; // Remove flag using bitwise logical AND with bitwise complement (reversing the bit)
+ }
+
///
/// Validates that a combination of culture and segment is valid for the variation.
///
@@ -135,16 +274,18 @@ namespace Umbraco.Core
/// The segment.
/// A value indicating whether to perform exact validation.
/// A value indicating whether to support wildcards.
- /// A value indicating whether to throw a when the combination is invalid.
- /// True if the combination is valid; otherwise false.
+ /// A value indicating whether to throw a when the combination is invalid.
+ ///
+ /// true if the combination is valid; otherwise false.
+ ///
+ /// Occurs when the combination is invalid, and is true.
///
/// When validation is exact, the combination must match the variation exactly. For instance, if the variation is Culture, then
/// a culture is required. When validation is not strict, the combination must be equivalent, or more restrictive: if the variation is
/// Culture, an invariant combination is ok.
/// Basically, exact is for one content type, or one property type, and !exact is for "all property types" of one content type.
- /// Both and can be "*" to indicate "all of them".
+ /// Both and can be "*" to indicate "all of them".
///
- /// Occurs when the combination is invalid, and is true.
public static bool ValidateVariation(this ContentVariation variation, string culture, string segment, bool exact, bool wildcards, bool throwIfInvalid)
{
culture = culture.NullOrWhiteSpaceAsNull();
@@ -161,13 +302,14 @@ namespace Umbraco.Core
if (variation.VariesByCulture())
{
// varies by culture
- // in exact mode, the culture cannot be null
+ // in exact mode, the culture cannot be null
if (exact && culture == null)
{
if (throwIfInvalid)
throw new NotSupportedException($"Culture may not be null because culture variation is enabled.");
+
return false;
- }
+ }
}
else
{
@@ -178,9 +320,10 @@ namespace Umbraco.Core
{
if (throwIfInvalid)
throw new NotSupportedException($"Culture \"{culture}\" is invalid because culture variation is disabled.");
+
return false;
}
- }
+ }
// if it does not vary by segment
// the segment cannot have a value
@@ -190,6 +333,7 @@ namespace Umbraco.Core
{
if (throwIfInvalid)
throw new NotSupportedException($"Segment \"{segment}\" is invalid because segment variation is disabled.");
+
return false;
}
diff --git a/src/Umbraco.Core/EnumExtensions.cs b/src/Umbraco.Core/EnumExtensions.cs
index 1443a27876..9097432f64 100644
--- a/src/Umbraco.Core/EnumExtensions.cs
+++ b/src/Umbraco.Core/EnumExtensions.cs
@@ -3,43 +3,42 @@
namespace Umbraco.Core
{
///
- /// Provides extension methods to enums.
+ /// Provides extension methods to .
///
public static class EnumExtensions
{
- // note:
- // - no need to HasFlagExact, that's basically an == test
- // - HasFlagAll cannot be named HasFlag because ext. methods never take priority over instance methods
-
///
- /// Determines whether a flag enum has all the specified values.
+ /// Determines whether all the flags/bits are set within the enum value.
///
- ///
- /// True when all bits set in are set in , though other bits may be set too.
- /// This is the behavior of the original method.
- ///
- public static bool HasFlagAll(this T use, T uses)
+ /// The enum type.
+ /// The enum value.
+ /// The flags.
+ ///
+ /// true if all the flags/bits are set within the enum value; otherwise, false.
+ ///
+ [Obsolete("Use Enum.HasFlag() or bitwise operations (if performance is important) instead.")]
+ public static bool HasFlagAll(this T value, T flags)
where T : Enum
{
- var num = Convert.ToUInt64(use);
- var nums = Convert.ToUInt64(uses);
-
- return (num & nums) == nums;
+ return value.HasFlag(flags);
}
///
- /// Determines whether a flag enum has any of the specified values.
+ /// Determines whether any of the flags/bits are set within the enum value.
///
- ///
- /// True when at least one of the bits set in is set in .
- ///
- public static bool HasFlagAny(this T use, T uses)
+ /// The enum type.
+ /// The value.
+ /// The flags.
+ ///
+ /// true if any of the flags/bits are set within the enum value; otherwise, false.
+ ///
+ public static bool HasFlagAny(this T value, T flags)
where T : Enum
{
- var num = Convert.ToUInt64(use);
- var nums = Convert.ToUInt64(uses);
+ var v = Convert.ToUInt64(value);
+ var f = Convert.ToUInt64(flags);
- return (num & nums) > 0;
+ return (v & f) > 0;
}
}
}
diff --git a/src/Umbraco.Core/HashGenerator.cs b/src/Umbraco.Core/HashGenerator.cs
index 80cc3c3de4..58034f05d7 100644
--- a/src/Umbraco.Core/HashGenerator.cs
+++ b/src/Umbraco.Core/HashGenerator.cs
@@ -41,7 +41,7 @@ namespace Umbraco.Core
internal void AddDateTime(DateTime d)
{
- _writer.Write(d.Ticks);;
+ _writer.Write(d.Ticks);
}
internal void AddString(string s)
diff --git a/src/Umbraco.Core/IO/SystemDirectories.cs b/src/Umbraco.Core/IO/SystemDirectories.cs
index d6fb63b0a1..b4688d2e9f 100644
--- a/src/Umbraco.Core/IO/SystemDirectories.cs
+++ b/src/Umbraco.Core/IO/SystemDirectories.cs
@@ -29,13 +29,13 @@ namespace Umbraco.Core.IO
public static string MacroPartials => MvcViews + "/MacroPartials/";
- public static string Media => IOHelper.ReturnPath("umbracoMediaPath", "~/media");
+ public static string Media => IOHelper.ReturnPath(Constants.AppSettings.MediaPath, "~/media");
- public static string Scripts => IOHelper.ReturnPath("umbracoScriptsPath", "~/scripts");
+ public static string Scripts => IOHelper.ReturnPath(Constants.AppSettings.ScriptsPath, "~/scripts");
- public static string Css => IOHelper.ReturnPath("umbracoCssPath", "~/css");
+ public static string Css => IOHelper.ReturnPath(Constants.AppSettings.CssPath, "~/css");
- public static string Umbraco => IOHelper.ReturnPath("umbracoPath", "~/umbraco");
+ public static string Umbraco => IOHelper.ReturnPath(Constants.AppSettings.Path, "~/umbraco");
public static string Packages => Data + "/packages";
diff --git a/src/Umbraco.Core/Manifest/ManifestContentAppFactory.cs b/src/Umbraco.Core/Manifest/ManifestContentAppFactory.cs
index 1c50a4b895..788310d7a1 100644
--- a/src/Umbraco.Core/Manifest/ManifestContentAppFactory.cs
+++ b/src/Umbraco.Core/Manifest/ManifestContentAppFactory.cs
@@ -19,6 +19,8 @@ namespace Umbraco.Core.Manifest
// '-content/foo', // hide for content type 'foo'
// '+content/*', // show for all other content types
// '+media/*', // show for all media types
+ // '-member/foo' // hide for member type 'foo'
+ // '+member/*' // show for all member types
// '+role/admin' // show for admin users. Role based permissions will override others.
// ]
// },
@@ -56,6 +58,10 @@ namespace Umbraco.Core.Manifest
partA = "media";
partB = media.ContentType.Alias;
break;
+ case IMember member:
+ partA = "member";
+ partB = member.ContentType.Alias;
+ break;
default:
return null;
diff --git a/src/Umbraco.Core/Migrations/Install/DatabaseDataCreator.cs b/src/Umbraco.Core/Migrations/Install/DatabaseDataCreator.cs
index 94d8cfbc62..76a8b3a2f4 100644
--- a/src/Umbraco.Core/Migrations/Install/DatabaseDataCreator.cs
+++ b/src/Umbraco.Core/Migrations/Install/DatabaseDataCreator.cs
@@ -151,6 +151,8 @@ namespace Umbraco.Core.Migrations.Install
_database.Insert(Constants.DatabaseSchema.Tables.Lock, "id", false, new LockDto { Id = Constants.Locks.Domains, Name = "Domains" });
_database.Insert(Constants.DatabaseSchema.Tables.Lock, "id", false, new LockDto { Id = Constants.Locks.KeyValues, Name = "KeyValues" });
_database.Insert(Constants.DatabaseSchema.Tables.Lock, "id", false, new LockDto { Id = Constants.Locks.Languages, Name = "Languages" });
+
+ _database.Insert(Constants.DatabaseSchema.Tables.Lock, "id", false, new LockDto { Id = Constants.Locks.MainDom, Name = "MainDom" });
}
private void CreateContentTypeData()
@@ -310,14 +312,27 @@ namespace Umbraco.Core.Migrations.Install
private void CreateRelationTypeData()
{
var relationType = new RelationTypeDto { Id = 1, Alias = Constants.Conventions.RelationTypes.RelateDocumentOnCopyAlias, ChildObjectType = Constants.ObjectTypes.Document, ParentObjectType = Constants.ObjectTypes.Document, Dual = true, Name = Constants.Conventions.RelationTypes.RelateDocumentOnCopyName };
- relationType.UniqueId = (relationType.Alias + "____" + relationType.Name).ToGuid();
+ relationType.UniqueId = CreateUniqueRelationTypeId(relationType.Alias, relationType.Name);
_database.Insert(Constants.DatabaseSchema.Tables.RelationType, "id", false, relationType);
relationType = new RelationTypeDto { Id = 2, Alias = Constants.Conventions.RelationTypes.RelateParentDocumentOnDeleteAlias, ChildObjectType = Constants.ObjectTypes.Document, ParentObjectType = Constants.ObjectTypes.Document, Dual = false, Name = Constants.Conventions.RelationTypes.RelateParentDocumentOnDeleteName };
- relationType.UniqueId = (relationType.Alias + "____" + relationType.Name).ToGuid();
+ relationType.UniqueId = CreateUniqueRelationTypeId(relationType.Alias, relationType.Name);
_database.Insert(Constants.DatabaseSchema.Tables.RelationType, "id", false, relationType);
relationType = new RelationTypeDto { Id = 3, Alias = Constants.Conventions.RelationTypes.RelateParentMediaFolderOnDeleteAlias, ChildObjectType = Constants.ObjectTypes.Media, ParentObjectType = Constants.ObjectTypes.Media, Dual = false, Name = Constants.Conventions.RelationTypes.RelateParentMediaFolderOnDeleteName };
- relationType.UniqueId = (relationType.Alias + "____" + relationType.Name).ToGuid();
+ relationType.UniqueId = CreateUniqueRelationTypeId(relationType.Alias, relationType.Name);
_database.Insert(Constants.DatabaseSchema.Tables.RelationType, "id", false, relationType);
+
+ relationType = new RelationTypeDto { Id = 4, Alias = Constants.Conventions.RelationTypes.RelatedMediaAlias, ChildObjectType = null, ParentObjectType = null, Dual = false, Name = Constants.Conventions.RelationTypes.RelatedMediaName };
+ relationType.UniqueId = CreateUniqueRelationTypeId(relationType.Alias, relationType.Name);
+ _database.Insert(Constants.DatabaseSchema.Tables.RelationType, "id", false, relationType);
+
+ relationType = new RelationTypeDto { Id = 5, Alias = Constants.Conventions.RelationTypes.RelatedDocumentAlias, ChildObjectType = null, ParentObjectType = null, Dual = false, Name = Constants.Conventions.RelationTypes.RelatedDocumentName };
+ relationType.UniqueId = CreateUniqueRelationTypeId(relationType.Alias, relationType.Name);
+ _database.Insert(Constants.DatabaseSchema.Tables.RelationType, "id", false, relationType);
+ }
+
+ internal static Guid CreateUniqueRelationTypeId(string alias, string name)
+ {
+ return (alias + "____" + name).ToGuid();
}
private void CreateKeyValueData()
diff --git a/src/Umbraco.Core/Migrations/MigrationBase_Extra.cs b/src/Umbraco.Core/Migrations/MigrationBase_Extra.cs
index bf07e4d08f..f4c6150073 100644
--- a/src/Umbraco.Core/Migrations/MigrationBase_Extra.cs
+++ b/src/Umbraco.Core/Migrations/MigrationBase_Extra.cs
@@ -1,5 +1,6 @@
using System.Collections.Generic;
using System.Linq;
+using Umbraco.Core.Persistence;
using Umbraco.Core.Persistence.DatabaseModelDefinitions;
using Umbraco.Core.Persistence.SqlSyntax;
@@ -84,10 +85,18 @@ namespace Umbraco.Core.Migrations
protected void ReplaceColumn(string tableName, string currentName, string newName)
{
- AddColumn(tableName, newName, out var sqls);
- Execute.Sql($"UPDATE {SqlSyntax.GetQuotedTableName(tableName)} SET {SqlSyntax.GetQuotedColumnName(newName)}={SqlSyntax.GetQuotedColumnName(currentName)}").Do();
- foreach (var sql in sqls) Execute.Sql(sql).Do();
- Delete.Column(currentName).FromTable(tableName).Do();
+ if (DatabaseType.IsSqlCe())
+ {
+ AddColumn(tableName, newName, out var sqls);
+ Execute.Sql($"UPDATE {SqlSyntax.GetQuotedTableName(tableName)} SET {SqlSyntax.GetQuotedColumnName(newName)}={SqlSyntax.GetQuotedColumnName(currentName)}").Do();
+ foreach (var sql in sqls) Execute.Sql(sql).Do();
+ Delete.Column(currentName).FromTable(tableName).Do();
+ }
+ else
+ {
+ Execute.Sql(SqlSyntax.FormatColumnRename(tableName, currentName, newName)).Do();
+ AlterColumn(tableName, newName);
+ }
}
protected bool TableExists(string tableName)
diff --git a/src/Umbraco.Core/Migrations/Upgrade/Common/CreateKeysAndIndexes.cs b/src/Umbraco.Core/Migrations/Upgrade/Common/CreateKeysAndIndexes.cs
index 29006c8811..4872e0019d 100644
--- a/src/Umbraco.Core/Migrations/Upgrade/Common/CreateKeysAndIndexes.cs
+++ b/src/Umbraco.Core/Migrations/Upgrade/Common/CreateKeysAndIndexes.cs
@@ -12,6 +12,7 @@ namespace Umbraco.Core.Migrations.Upgrade.Common
{
// remove those that may already have keys
Delete.KeysAndIndexes(Constants.DatabaseSchema.Tables.KeyValue).Do();
+ Delete.KeysAndIndexes(Constants.DatabaseSchema.Tables.PropertyData).Do();
// re-create *all* keys and indexes
foreach (var x in DatabaseSchemaCreator.OrderedTables)
diff --git a/src/Umbraco.Core/Migrations/Upgrade/UmbracoPlan.cs b/src/Umbraco.Core/Migrations/Upgrade/UmbracoPlan.cs
index 223603be14..7143be2b90 100644
--- a/src/Umbraco.Core/Migrations/Upgrade/UmbracoPlan.cs
+++ b/src/Umbraco.Core/Migrations/Upgrade/UmbracoPlan.cs
@@ -183,8 +183,15 @@ namespace Umbraco.Core.Migrations.Upgrade
To("{0372A42B-DECF-498D-B4D1-6379E907EB94}");
To("{5B1E0D93-F5A3-449B-84BA-65366B84E2D4}");
- // to 8.6.0
+ // to 8.6.0...
+ To("{4759A294-9860-46BC-99F9-B4C975CAE580}");
+ To("{0BC866BC-0665-487A-9913-0290BD0169AD}");
To("{3D67D2C8-5E65-47D0-A9E1-DC2EE0779D6B}");
+ To("{EE288A91-531B-4995-8179-1D62D9AA3E2E}");
+ To("{2AB29964-02A1-474D-BD6B-72148D2A53A2}");
+
+
+ To("{a78e3369-8ea3-40ec-ad3f-5f76929d2b20}");
//FINAL
}
diff --git a/src/Umbraco.Core/Migrations/Upgrade/V_8_0_0/AddTypedLabels.cs b/src/Umbraco.Core/Migrations/Upgrade/V_8_0_0/AddTypedLabels.cs
index 309f8acbc3..66f9114370 100644
--- a/src/Umbraco.Core/Migrations/Upgrade/V_8_0_0/AddTypedLabels.cs
+++ b/src/Umbraco.Core/Migrations/Upgrade/V_8_0_0/AddTypedLabels.cs
@@ -75,8 +75,7 @@ namespace Umbraco.Core.Migrations.Upgrade.V_8_0_0
var labelPropertyTypes = Database.Fetch(Sql()
.Select(x => x.Id, x => x.Alias)
.From()
- .Where(x => x.DataTypeId == Constants.DataTypes.LabelString)
- );
+ .Where(x => x.DataTypeId == Constants.DataTypes.LabelString));
var intPropertyAliases = new[] { Constants.Conventions.Media.Width, Constants.Conventions.Media.Height, Constants.Conventions.Member.FailedPasswordAttempts };
var bigintPropertyAliases = new[] { Constants.Conventions.Media.Bytes };
@@ -101,16 +100,18 @@ namespace Umbraco.Core.Migrations.Upgrade.V_8_0_0
foreach (var value in values)
Database.Execute(Sql()
.Update(u => u
- .Set(x => x.IntegerValue, string.IsNullOrWhiteSpace(value.VarcharValue) ? (int?) null : int.Parse(value.VarcharValue, NumberStyles.Any, CultureInfo.InvariantCulture))
- .Set(x => x.TextValue, null))
+ .Set(x => x.IntegerValue, string.IsNullOrWhiteSpace(value.VarcharValue) ? (int?)null : int.Parse(value.VarcharValue, NumberStyles.Any, CultureInfo.InvariantCulture))
+ .Set(x => x.TextValue, null)
+ .Set(x => x.VarcharValue, null))
.Where(x => x.Id == value.Id));
values = Database.Fetch(Sql().Select(x => x.Id, x => x.VarcharValue).From().WhereIn(x => x.PropertyTypeId, dtPropertyTypes));
foreach (var value in values)
Database.Execute(Sql()
.Update(u => u
- .Set(x => x.DateValue, string.IsNullOrWhiteSpace(value.VarcharValue) ? (DateTime?) null : DateTime.Parse(value.VarcharValue, CultureInfo.InvariantCulture, DateTimeStyles.None))
- .Set(x => x.TextValue, null))
+ .Set(x => x.DateValue, string.IsNullOrWhiteSpace(value.VarcharValue) ? (DateTime?)null : DateTime.Parse(value.VarcharValue, CultureInfo.InvariantCulture, DateTimeStyles.None))
+ .Set(x => x.TextValue, null)
+ .Set(x => x.VarcharValue, null))
.Where(x => x.Id == value.Id));
// anything that's custom... ppl will have to figure it out manually, there isn't much we can do about it
diff --git a/src/Umbraco.Core/Migrations/Upgrade/V_8_0_0/ContentVariationMigration.cs b/src/Umbraco.Core/Migrations/Upgrade/V_8_0_0/ContentVariationMigration.cs
index 84dd393b0d..eabbd34b08 100644
--- a/src/Umbraco.Core/Migrations/Upgrade/V_8_0_0/ContentVariationMigration.cs
+++ b/src/Umbraco.Core/Migrations/Upgrade/V_8_0_0/ContentVariationMigration.cs
@@ -4,8 +4,10 @@ using System.Linq;
using System.Text;
using System.Threading.Tasks;
using NPoco;
+using Umbraco.Core.Migrations.Upgrade.V_8_0_0.Models;
using Umbraco.Core.Persistence;
using Umbraco.Core.Persistence.DatabaseAnnotations;
+using Umbraco.Core.Persistence.DatabaseModelDefinitions;
using Umbraco.Core.Persistence.Dtos;
namespace Umbraco.Core.Migrations.Upgrade.V_8_0_0
@@ -47,14 +49,14 @@ namespace Umbraco.Core.Migrations.Upgrade.V_8_0_0
}
}
- var propertyTypes = Database.Fetch(Sql().Select().From());
+ var propertyTypes = Database.Fetch(Sql().Select().From());
foreach (var dto in propertyTypes)
{
dto.Variations = GetNewValue(dto.Variations);
Database.Update(dto);
}
- var contentTypes = Database.Fetch(Sql().Select().From());
+ var contentTypes = Database.Fetch(Sql().Select().From());
foreach (var dto in contentTypes)
{
dto.Variations = GetNewValue(dto.Variations);
@@ -62,57 +64,11 @@ namespace Umbraco.Core.Migrations.Upgrade.V_8_0_0
}
}
- // we *need* to use this private DTO here, which does *not* have extra properties, which would kill the migration
+ // we *need* to use these private DTOs here, which does *not* have extra properties, which would kill the migration
- [TableName(TableName)]
- [PrimaryKey("pk")]
- [ExplicitColumns]
- private class ContentTypeDto
- {
- public const string TableName = Constants.DatabaseSchema.Tables.ContentType;
+
- [Column("pk")]
- [PrimaryKeyColumn(IdentitySeed = 535)]
- public int PrimaryKey { get; set; }
-
- [Column("nodeId")]
- [ForeignKey(typeof(NodeDto))]
- [Index(IndexTypes.UniqueNonClustered, Name = "IX_cmsContentType")]
- public int NodeId { get; set; }
-
- [Column("alias")]
- [NullSetting(NullSetting = NullSettings.Null)]
- public string Alias { get; set; }
-
- [Column("icon")]
- [Index(IndexTypes.NonClustered)]
- [NullSetting(NullSetting = NullSettings.Null)]
- public string Icon { get; set; }
-
- [Column("thumbnail")]
- [Constraint(Default = "folder.png")]
- public string Thumbnail { get; set; }
-
- [Column("description")]
- [NullSetting(NullSetting = NullSettings.Null)]
- [Length(1500)]
- public string Description { get; set; }
-
- [Column("isContainer")]
- [Constraint(Default = "0")]
- public bool IsContainer { get; set; }
-
- [Column("allowAtRoot")]
- [Constraint(Default = "0")]
- public bool AllowAtRoot { get; set; }
-
- [Column("variations")]
- [Constraint(Default = "1" /*ContentVariation.InvariantNeutral*/)]
- public byte Variations { get; set; }
-
- [ResultColumn]
- public NodeDto NodeDto { get; set; }
- }
+
}
}
diff --git a/src/Umbraco.Core/Migrations/Upgrade/V_8_0_0/ConvertRelatedLinksToMultiUrlPicker.cs b/src/Umbraco.Core/Migrations/Upgrade/V_8_0_0/ConvertRelatedLinksToMultiUrlPicker.cs
index 1956876402..1e327346cf 100644
--- a/src/Umbraco.Core/Migrations/Upgrade/V_8_0_0/ConvertRelatedLinksToMultiUrlPicker.cs
+++ b/src/Umbraco.Core/Migrations/Upgrade/V_8_0_0/ConvertRelatedLinksToMultiUrlPicker.cs
@@ -2,8 +2,7 @@
using System.Linq;
using System.Runtime.Serialization;
using Newtonsoft.Json;
-using Umbraco.Core.Logging;
-using Umbraco.Core.Models.PublishedContent;
+using Umbraco.Core.Migrations.Upgrade.V_8_0_0.Models;
using Umbraco.Core.Persistence;
using Umbraco.Core.Persistence.Dtos;
@@ -34,11 +33,11 @@ namespace Umbraco.Core.Migrations.Upgrade.V_8_0_0
}
var sqlPropertyTpes = Sql()
- .Select()
- .From()
- .Where(x => dataTypeIds.Contains(x.DataTypeId));
+ .Select()
+ .From()
+ .Where(x => dataTypeIds.Contains(x.DataTypeId));
- var propertyTypeIds = Database.Fetch(sqlPropertyTpes).Select(x => x.Id).ToList();
+ var propertyTypeIds = Database.Fetch(sqlPropertyTpes).Select(x => x.Id).ToList();
if (propertyTypeIds.Count == 0) return;
diff --git a/src/Umbraco.Core/Migrations/Upgrade/V_8_0_0/MergeDateAndDateTimePropertyEditor.cs b/src/Umbraco.Core/Migrations/Upgrade/V_8_0_0/MergeDateAndDateTimePropertyEditor.cs
index 0d451e8460..37a83bdd67 100644
--- a/src/Umbraco.Core/Migrations/Upgrade/V_8_0_0/MergeDateAndDateTimePropertyEditor.cs
+++ b/src/Umbraco.Core/Migrations/Upgrade/V_8_0_0/MergeDateAndDateTimePropertyEditor.cs
@@ -32,7 +32,7 @@ namespace Umbraco.Core.Migrations.Upgrade.V_8_0_0
if (string.IsNullOrEmpty(dataType.Configuration))
{
config.Format = "YYYY-MM-DD";
- };
+ }
}
catch (Exception ex)
{
diff --git a/src/Umbraco.Core/Migrations/Upgrade/V_8_0_0/Models/ContentTypeDto80.cs b/src/Umbraco.Core/Migrations/Upgrade/V_8_0_0/Models/ContentTypeDto80.cs
new file mode 100644
index 0000000000..bc41e5e32a
--- /dev/null
+++ b/src/Umbraco.Core/Migrations/Upgrade/V_8_0_0/Models/ContentTypeDto80.cs
@@ -0,0 +1,63 @@
+using NPoco;
+using Umbraco.Core.Persistence.DatabaseAnnotations;
+using Umbraco.Core.Persistence.Dtos;
+
+namespace Umbraco.Core.Migrations.Upgrade.V_8_0_0.Models
+{
+
+ ///
+ /// Snapshot of the as it was at version 8.0
+ ///
+ ///
+ /// This is required during migrations the schema of this table changed and running SQL against the new table would result in errors
+ ///
+ [TableName(TableName)]
+ [PrimaryKey("pk")]
+ [ExplicitColumns]
+ internal class ContentTypeDto80
+ {
+ public const string TableName = Constants.DatabaseSchema.Tables.ContentType;
+
+ [Column("pk")]
+ [PrimaryKeyColumn(IdentitySeed = 535)]
+ public int PrimaryKey { get; set; }
+
+ [Column("nodeId")]
+ [ForeignKey(typeof(NodeDto))]
+ [Index(IndexTypes.UniqueNonClustered, Name = "IX_cmsContentType")]
+ public int NodeId { get; set; }
+
+ [Column("alias")]
+ [NullSetting(NullSetting = NullSettings.Null)]
+ public string Alias { get; set; }
+
+ [Column("icon")]
+ [Index(IndexTypes.NonClustered)]
+ [NullSetting(NullSetting = NullSettings.Null)]
+ public string Icon { get; set; }
+
+ [Column("thumbnail")]
+ [Constraint(Default = "folder.png")]
+ public string Thumbnail { get; set; }
+
+ [Column("description")]
+ [NullSetting(NullSetting = NullSettings.Null)]
+ [Length(1500)]
+ public string Description { get; set; }
+
+ [Column("isContainer")]
+ [Constraint(Default = "0")]
+ public bool IsContainer { get; set; }
+
+ [Column("allowAtRoot")]
+ [Constraint(Default = "0")]
+ public bool AllowAtRoot { get; set; }
+
+ [Column("variations")]
+ [Constraint(Default = "1" /*ContentVariation.InvariantNeutral*/)]
+ public byte Variations { get; set; }
+
+ [ResultColumn]
+ public NodeDto NodeDto { get; set; }
+ }
+}
diff --git a/src/Umbraco.Core/Migrations/Upgrade/V_8_0_0/Models/PropertyDataDto80.cs b/src/Umbraco.Core/Migrations/Upgrade/V_8_0_0/Models/PropertyDataDto80.cs
new file mode 100644
index 0000000000..f0a36b223d
--- /dev/null
+++ b/src/Umbraco.Core/Migrations/Upgrade/V_8_0_0/Models/PropertyDataDto80.cs
@@ -0,0 +1,142 @@
+using NPoco;
+using System;
+using Umbraco.Core.Persistence.DatabaseAnnotations;
+using Umbraco.Core.Persistence.Dtos;
+
+namespace Umbraco.Core.Migrations.Upgrade.V_8_0_0.Models
+{
+ ///
+ /// Snapshot of the as it was at version 8.0
+ ///
+ ///
+ /// This is required during migrations the schema of this table changed and running SQL against the new table would result in errors
+ ///
+ [TableName(TableName)]
+ [PrimaryKey("id")]
+ [ExplicitColumns]
+ internal class PropertyDataDto80
+ {
+ public const string TableName = Constants.DatabaseSchema.Tables.PropertyData;
+ public const int VarcharLength = 512;
+ public const int SegmentLength = 256;
+
+ private decimal? _decimalValue;
+
+ // pk, not used at the moment (never updating)
+ [Column("id")]
+ [PrimaryKeyColumn]
+ public int Id { get; set; }
+
+ [Column("versionId")]
+ [ForeignKey(typeof(ContentVersionDto))]
+ [Index(IndexTypes.UniqueNonClustered, Name = "IX_" + TableName + "_VersionId", ForColumns = "versionId,propertyTypeId,languageId,segment")]
+ public int VersionId { get; set; }
+
+ [Column("propertyTypeId")]
+ [ForeignKey(typeof(PropertyTypeDto80))]
+ [Index(IndexTypes.NonClustered, Name = "IX_" + TableName + "_PropertyTypeId")]
+ public int PropertyTypeId { get; set; }
+
+ [Column("languageId")]
+ [ForeignKey(typeof(LanguageDto))]
+ [Index(IndexTypes.NonClustered, Name = "IX_" + TableName + "_LanguageId")]
+ [NullSetting(NullSetting = NullSettings.Null)]
+ public int? LanguageId { get; set; }
+
+ [Column("segment")]
+ [Index(IndexTypes.NonClustered, Name = "IX_" + TableName + "_Segment")]
+ [NullSetting(NullSetting = NullSettings.Null)]
+ [Length(SegmentLength)]
+ public string Segment { get; set; }
+
+ [Column("intValue")]
+ [NullSetting(NullSetting = NullSettings.Null)]
+ public int? IntegerValue { get; set; }
+
+ [Column("decimalValue")]
+ [NullSetting(NullSetting = NullSettings.Null)]
+ public decimal? DecimalValue
+ {
+ get => _decimalValue;
+ set => _decimalValue = value?.Normalize();
+ }
+
+ [Column("dateValue")]
+ [NullSetting(NullSetting = NullSettings.Null)]
+ public DateTime? DateValue { get; set; }
+
+ [Column("varcharValue")]
+ [NullSetting(NullSetting = NullSettings.Null)]
+ [Length(VarcharLength)]
+ public string VarcharValue { get; set; }
+
+ [Column("textValue")]
+ [NullSetting(NullSetting = NullSettings.Null)]
+ [SpecialDbType(SpecialDbTypes.NTEXT)]
+ public string TextValue { get; set; }
+
+ [ResultColumn]
+ [Reference(ReferenceType.OneToOne, ColumnName = "PropertyTypeId")]
+ public PropertyTypeDto80 PropertyTypeDto { get; set; }
+
+ [Ignore]
+ public object Value
+ {
+ get
+ {
+ if (IntegerValue.HasValue)
+ return IntegerValue.Value;
+
+ if (DecimalValue.HasValue)
+ return DecimalValue.Value;
+
+ if (DateValue.HasValue)
+ return DateValue.Value;
+
+ if (!string.IsNullOrEmpty(VarcharValue))
+ return VarcharValue;
+
+ if (!string.IsNullOrEmpty(TextValue))
+ return TextValue;
+
+ return null;
+ }
+ }
+
+ public PropertyDataDto80 Clone(int versionId)
+ {
+ return new PropertyDataDto80
+ {
+ VersionId = versionId,
+ PropertyTypeId = PropertyTypeId,
+ LanguageId = LanguageId,
+ Segment = Segment,
+ IntegerValue = IntegerValue,
+ DecimalValue = DecimalValue,
+ DateValue = DateValue,
+ VarcharValue = VarcharValue,
+ TextValue = TextValue,
+ PropertyTypeDto = PropertyTypeDto
+ };
+ }
+
+ protected bool Equals(PropertyDataDto other)
+ {
+ return Id == other.Id;
+ }
+
+ public override bool Equals(object other)
+ {
+ return
+ !ReferenceEquals(null, other) // other is not null
+ && (ReferenceEquals(this, other) // and either ref-equals, or same id
+ || other is PropertyDataDto pdata && pdata.Id == Id);
+ }
+
+ public override int GetHashCode()
+ {
+ // ReSharper disable once NonReadonlyMemberInGetHashCode
+ return Id;
+ }
+ }
+}
diff --git a/src/Umbraco.Core/Migrations/Upgrade/V_8_0_0/Models/PropertyTypeDto80.cs b/src/Umbraco.Core/Migrations/Upgrade/V_8_0_0/Models/PropertyTypeDto80.cs
new file mode 100644
index 0000000000..6e2bd7371a
--- /dev/null
+++ b/src/Umbraco.Core/Migrations/Upgrade/V_8_0_0/Models/PropertyTypeDto80.cs
@@ -0,0 +1,80 @@
+using NPoco;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using Umbraco.Core.Persistence.DatabaseAnnotations;
+using Umbraco.Core.Persistence.DatabaseModelDefinitions;
+using Umbraco.Core.Persistence.Dtos;
+
+namespace Umbraco.Core.Migrations.Upgrade.V_8_0_0.Models
+{
+ ///
+ /// Snapshot of the as it was at version 8.0
+ ///
+ ///
+ /// This is required during migrations before 8.6 since the schema has changed and running SQL against the new table would result in errors
+ ///
+ [TableName(Constants.DatabaseSchema.Tables.PropertyType)]
+ [PrimaryKey("id")]
+ [ExplicitColumns]
+ internal class PropertyTypeDto80
+ {
+ [Column("id")]
+ [PrimaryKeyColumn(IdentitySeed = 50)]
+ public int Id { get; set; }
+
+ [Column("dataTypeId")]
+ [ForeignKey(typeof(DataTypeDto), Column = "nodeId")]
+ public int DataTypeId { get; set; }
+
+ [Column("contentTypeId")]
+ [ForeignKey(typeof(ContentTypeDto), Column = "nodeId")]
+ public int ContentTypeId { get; set; }
+
+ [Column("propertyTypeGroupId")]
+ [NullSetting(NullSetting = NullSettings.Null)]
+ [ForeignKey(typeof(PropertyTypeGroupDto))]
+ public int? PropertyTypeGroupId { get; set; }
+
+ [Index(IndexTypes.NonClustered, Name = "IX_cmsPropertyTypeAlias")]
+ [Column("Alias")]
+ public string Alias { get; set; }
+
+ [Column("Name")]
+ [NullSetting(NullSetting = NullSettings.Null)]
+ public string Name { get; set; }
+
+ [Column("sortOrder")]
+ [Constraint(Default = "0")]
+ public int SortOrder { get; set; }
+
+ [Column("mandatory")]
+ [Constraint(Default = "0")]
+ public bool Mandatory { get; set; }
+
+ [Column("validationRegExp")]
+ [NullSetting(NullSetting = NullSettings.Null)]
+ public string ValidationRegExp { get; set; }
+
+ [Column("Description")]
+ [NullSetting(NullSetting = NullSettings.Null)]
+ [Length(2000)]
+ public string Description { get; set; }
+
+ [Column("variations")]
+ [Constraint(Default = "1" /*ContentVariation.InvariantNeutral*/)]
+ public byte Variations { get; set; }
+
+ [ResultColumn]
+ [Reference(ReferenceType.OneToOne, ColumnName = "DataTypeId")]
+ public DataTypeDto DataTypeDto { get; set; }
+
+ [Column("UniqueID")]
+ [NullSetting(NullSetting = NullSettings.NotNull)]
+ [Constraint(Default = SystemMethods.NewGuid)]
+ [Index(IndexTypes.UniqueNonClustered, Name = "IX_cmsPropertyTypeUniqueID")]
+ public Guid UniqueId { get; set; }
+ }
+}
diff --git a/src/Umbraco.Core/Migrations/Upgrade/V_8_0_0/RenameMediaVersionTable.cs b/src/Umbraco.Core/Migrations/Upgrade/V_8_0_0/RenameMediaVersionTable.cs
index b60923fcba..2b27bdafe8 100644
--- a/src/Umbraco.Core/Migrations/Upgrade/V_8_0_0/RenameMediaVersionTable.cs
+++ b/src/Umbraco.Core/Migrations/Upgrade/V_8_0_0/RenameMediaVersionTable.cs
@@ -1,4 +1,5 @@
-using Umbraco.Core.Persistence.Dtos;
+using Umbraco.Core.Persistence;
+using Umbraco.Core.Persistence.Dtos;
namespace Umbraco.Core.Migrations.Upgrade.V_8_0_0
{
@@ -17,14 +18,24 @@ namespace Umbraco.Core.Migrations.Upgrade.V_8_0_0
AddColumn("id", out var sqls);
- // SQLCE does not support UPDATE...FROM
- var temp2 = Database.Fetch($@"SELECT v.versionId, v.id
+ if (Database.DatabaseType.IsSqlCe())
+ {
+ // SQLCE does not support UPDATE...FROM
+ var versions = Database.Fetch($@"SELECT v.versionId, v.id
FROM cmsContentVersion v
JOIN umbracoNode n on v.contentId=n.id
WHERE n.nodeObjectType='{Constants.ObjectTypes.Media}'");
- foreach (var t in temp2)
- Execute.Sql($"UPDATE {Constants.DatabaseSchema.Tables.MediaVersion} SET id={t.id} WHERE versionId='{t.versionId}'").Do();
-
+ foreach (var t in versions)
+ Execute.Sql($"UPDATE {Constants.DatabaseSchema.Tables.MediaVersion} SET id={t.id} WHERE versionId='{t.versionId}'").Do();
+ }
+ else
+ {
+ Database.Execute($@"UPDATE {Constants.DatabaseSchema.Tables.MediaVersion} SET id=v.id
+FROM {Constants.DatabaseSchema.Tables.MediaVersion} m
+JOIN cmsContentVersion v on m.versionId = v.versionId
+JOIN umbracoNode n on v.contentId=n.id
+WHERE n.nodeObjectType='{Constants.ObjectTypes.Media}'");
+ }
foreach (var sql in sqls)
Execute.Sql(sql).Do();
diff --git a/src/Umbraco.Core/Migrations/Upgrade/V_8_0_0/VariantsMigration.cs b/src/Umbraco.Core/Migrations/Upgrade/V_8_0_0/VariantsMigration.cs
index 8c60d30680..adc451ef6a 100644
--- a/src/Umbraco.Core/Migrations/Upgrade/V_8_0_0/VariantsMigration.cs
+++ b/src/Umbraco.Core/Migrations/Upgrade/V_8_0_0/VariantsMigration.cs
@@ -1,4 +1,5 @@
using System;
+using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using Umbraco.Core.Migrations.Install;
@@ -19,6 +20,7 @@ namespace Umbraco.Core.Migrations.Upgrade.V_8_0_0
public override void Migrate()
{
MigratePropertyData();
+ CreatePropertyDataIndexes();
MigrateContentAndPropertyTypes();
MigrateContent();
MigrateVersions();
@@ -74,10 +76,20 @@ HAVING COUNT(v2.id) <> 1").Any())
{
Alter.Table(PreTables.PropertyData).AddColumn("versionId2").AsInt32().Nullable().Do();
- // SQLCE does not support UPDATE...FROM
- var temp = Database.Fetch($"SELECT id, versionId FROM {PreTables.ContentVersion}");
- foreach (var t in temp)
- Database.Execute($"UPDATE {PreTables.PropertyData} SET versionId2=@v2 WHERE versionId=@v1", new { v1 = t.versionId, v2 = t.id });
+ if (Database.DatabaseType.IsSqlCe())
+ {
+ // SQLCE does not support UPDATE...FROM
+ var versions = Database.Fetch($"SELECT id, versionId FROM {PreTables.ContentVersion}");
+ foreach (var t in versions)
+ Database.Execute($"UPDATE {PreTables.PropertyData} SET versionId2=@v2 WHERE versionId=@v1", new { v1 = t.versionId, v2 = t.id });
+ }
+ else
+ {
+ Database.Execute($@"UPDATE {PreTables.PropertyData} SET versionId2={PreTables.ContentVersion}.id
+FROM {PreTables.ContentVersion}
+INNER JOIN {PreTables.PropertyData} ON {PreTables.ContentVersion}.versionId = {PreTables.PropertyData}.versionId");
+ }
+
Delete.Column("versionId").FromTable(PreTables.PropertyData).Do();
ReplaceColumn(PreTables.PropertyData, "versionId2", "versionId");
}
@@ -90,6 +102,22 @@ HAVING COUNT(v2.id) <> 1").Any())
Rename.Table(PreTables.PropertyData).To(Constants.DatabaseSchema.Tables.PropertyData).Do();
}
+ private void CreatePropertyDataIndexes()
+ {
+ // Creates a temporary index on umbracoPropertyData to speed up other migrations which update property values.
+ // It will be removed in CreateKeysAndIndexes before the normal indexes for the table are created
+ var tableDefinition = Persistence.DatabaseModelDefinitions.DefinitionFactory.GetTableDefinition(typeof(PropertyDataDto), SqlSyntax);
+ Execute.Sql(SqlSyntax.FormatPrimaryKey(tableDefinition)).Do();
+ Create.Index("IX_umbracoPropertyData_Temp").OnTable(PropertyDataDto.TableName)
+ .WithOptions().Unique()
+ .WithOptions().NonClustered()
+ .OnColumn("versionId").Ascending()
+ .OnColumn("propertyTypeId").Ascending()
+ .OnColumn("languageId").Ascending()
+ .OnColumn("segment").Ascending()
+ .Do();
+ }
+
private void MigrateContentAndPropertyTypes()
{
if (!ColumnExists(PreTables.ContentType, "variations"))
@@ -153,22 +181,40 @@ HAVING COUNT(v2.id) <> 1").Any())
ReplaceColumn(PreTables.ContentVersion, "ContentId", "nodeId");
// populate contentVersion text, current and userId columns for documents
- // SQLCE does not support UPDATE...FROM
- var temp1 = Database.Fetch($"SELECT versionId, text, newest, documentUser FROM {PreTables.Document}");
- foreach (var t in temp1)
- Database.Execute($@"UPDATE {PreTables.ContentVersion} SET text=@text, {SqlSyntax.GetQuotedColumnName("current")}=@current, userId=@userId WHERE versionId=@versionId",
- new { text = t.text, current = t.newest, userId=t.documentUser, versionId=t.versionId });
+ if (Database.DatabaseType.IsSqlCe())
+ {
+ // SQLCE does not support UPDATE...FROM
+ var documents = Database.Fetch($"SELECT versionId, text, published, newest, documentUser FROM {PreTables.Document}");
+ foreach (var t in documents)
+ Database.Execute($@"UPDATE {PreTables.ContentVersion} SET text=@text, {SqlSyntax.GetQuotedColumnName("current")}=@current, userId=@userId WHERE versionId=@versionId",
+ new { text = t.text, current = t.newest && !t.published, userId = t.documentUser, versionId = t.versionId });
+ }
+ else
+ {
+ Database.Execute($@"UPDATE {PreTables.ContentVersion} SET text=d.text, {SqlSyntax.GetQuotedColumnName("current")}=(d.newest & ~d.published), userId=d.documentUser
+FROM {PreTables.ContentVersion} v INNER JOIN {PreTables.Document} d ON d.versionId = v.versionId");
+ }
// populate contentVersion text and current columns for non-documents, userId is default
- // SQLCE does not support UPDATE...FROM
- var temp2 = Database.Fetch($@"SELECT cver.versionId, n.text
+ if (Database.DatabaseType.IsSqlCe())
+ {
+ // SQLCE does not support UPDATE...FROM
+ var otherContent = Database.Fetch($@"SELECT cver.versionId, n.text
FROM {PreTables.ContentVersion} cver
JOIN {SqlSyntax.GetQuotedTableName(Constants.DatabaseSchema.Tables.Node)} n ON cver.nodeId=n.id
WHERE cver.versionId NOT IN (SELECT versionId FROM {SqlSyntax.GetQuotedTableName(PreTables.Document)})");
- foreach (var t in temp2)
- Database.Execute($@"UPDATE {PreTables.ContentVersion} SET text=@text, {SqlSyntax.GetQuotedColumnName("current")}=1, userId=0 WHERE versionId=@versionId",
- new { text = t.text, versionId=t.versionId });
+ foreach (var t in otherContent)
+ Database.Execute($@"UPDATE {PreTables.ContentVersion} SET text=@text, {SqlSyntax.GetQuotedColumnName("current")}=1, userId=0 WHERE versionId=@versionId",
+ new { text = t.text, versionId = t.versionId });
+ }
+ else
+ {
+ Database.Execute($@"UPDATE {PreTables.ContentVersion} SET text=n.text, {SqlSyntax.GetQuotedColumnName("current")}=1, userId=0
+FROM {PreTables.ContentVersion} cver
+JOIN {SqlSyntax.GetQuotedTableName(Constants.DatabaseSchema.Tables.Node)} n ON cver.nodeId=n.id
+WHERE cver.versionId NOT IN (SELECT versionId FROM {SqlSyntax.GetQuotedTableName(PreTables.Document)})");
+ }
// create table
Create.Table(withoutKeysAndIndexes: true).Do();
@@ -179,36 +225,42 @@ SELECT cver.id, doc.templateId, doc.published
FROM {SqlSyntax.GetQuotedTableName(PreTables.ContentVersion)} cver
JOIN {SqlSyntax.GetQuotedTableName(PreTables.Document)} doc ON doc.nodeId=cver.nodeId AND doc.versionId=cver.versionId");
+
// need to add extra rows for where published=newest
// 'cos INSERT above has inserted the 'published' document version
// and v8 always has a 'edited' document version too
- var temp3 = Database.Fetch($@"SELECT doc.nodeId, doc.updateDate, doc.documentUser, doc.text, doc.templateId, cver.id versionId
+ Database.Execute($@"
+INSERT INTO {SqlSyntax.GetQuotedTableName(PreTables.ContentVersion)} (nodeId, versionId, versionDate, userId, {SqlSyntax.GetQuotedColumnName("current")}, text)
+SELECT doc.nodeId, NEWID(), doc.updateDate, doc.documentUser, 1, doc.text
FROM {SqlSyntax.GetQuotedTableName(PreTables.Document)} doc
JOIN {SqlSyntax.GetQuotedTableName(PreTables.ContentVersion)} cver ON doc.nodeId=cver.nodeId AND doc.versionId=cver.versionId
WHERE doc.newest=1 AND doc.published=1");
- var getIdentity = "@@@@IDENTITY";
- foreach (var t in temp3)
- {
- Database.Execute($@"INSERT INTO {SqlSyntax.GetQuotedTableName(PreTables.ContentVersion)} (nodeId, versionId, versionDate, userId, {SqlSyntax.GetQuotedColumnName("current")}, text)
-VALUES (@nodeId, @versionId, @versionDate, @userId, 1, @text)", new { nodeId=t.nodeId, versionId=Guid.NewGuid(), versionDate=t.updateDate, userId=t.documentUser, text=t.text });
- var id = Database.ExecuteScalar("SELECT " + getIdentity);
- Database.Execute($"UPDATE {SqlSyntax.GetQuotedTableName(PreTables.ContentVersion)} SET {SqlSyntax.GetQuotedColumnName("current")}=0 WHERE nodeId=@0 AND id<>@1", (int) t.nodeId, id);
- Database.Execute($@"INSERT INTO {SqlSyntax.GetQuotedTableName(Constants.DatabaseSchema.Tables.DocumentVersion)} (id, templateId, published)
-VALUES (@id, @templateId, 0)", new { id=id, templateId=t.templateId });
- var versionId = (int) t.versionId;
- var pdatas = Database.Fetch(Sql().Select().From().Where(x => x.VersionId == versionId));
- foreach (var pdata in pdatas)
- {
- pdata.VersionId = id;
- Database.Insert(pdata);
- }
- }
+ Database.Execute($@"
+INSERT INTO {SqlSyntax.GetQuotedTableName(Constants.DatabaseSchema.Tables.DocumentVersion)} (id, templateId, published)
+SELECT cverNew.id, doc.templateId, 0
+FROM {SqlSyntax.GetQuotedTableName(PreTables.Document)} doc
+JOIN {SqlSyntax.GetQuotedTableName(PreTables.ContentVersion)} cverNew ON doc.nodeId = cverNew.nodeId
+WHERE doc.newest=1 AND doc.published=1 AND cverNew.{SqlSyntax.GetQuotedColumnName("current")} = 1");
+
+ Database.Execute($@"
+INSERT INTO {SqlSyntax.GetQuotedTableName(PropertyDataDto.TableName)} (propertytypeid,languageId,segment,textValue,varcharValue,decimalValue,intValue,dateValue,versionId)
+SELECT propertytypeid,languageId,segment,textValue,varcharValue,decimalValue,intValue,dateValue,cverNew.id
+FROM {SqlSyntax.GetQuotedTableName(PreTables.Document)} doc
+JOIN {SqlSyntax.GetQuotedTableName(PreTables.ContentVersion)} cver ON doc.nodeId=cver.nodeId AND doc.versionId=cver.versionId
+JOIN {SqlSyntax.GetQuotedTableName(PreTables.ContentVersion)} cverNew ON doc.nodeId = cverNew.nodeId
+JOIN {SqlSyntax.GetQuotedTableName(PropertyDataDto.TableName)} pd ON pd.versionId=cver.id
+WHERE doc.newest=1 AND doc.published=1 AND cverNew.{SqlSyntax.GetQuotedColumnName("current")} = 1");
+
// reduce document to 1 row per content
Database.Execute($@"DELETE FROM {PreTables.Document}
WHERE versionId NOT IN (SELECT (versionId) FROM {PreTables.ContentVersion} WHERE {SqlSyntax.GetQuotedColumnName("current")} = 1) AND (published<>1 OR newest<>1)");
+ // ensure that documents with a published version are marked as published
+ Database.Execute($@"UPDATE {PreTables.Document} SET published=1 WHERE nodeId IN (
+SELECT nodeId FROM {PreTables.ContentVersion} cv INNER JOIN {Constants.DatabaseSchema.Tables.DocumentVersion} dv ON dv.id = cv.id WHERE dv.published=1)");
+
// drop some document columns
Delete.Column("text").FromTable(PreTables.Document).Do();
Delete.Column("templateId").FromTable(PreTables.Document).Do();
@@ -223,7 +275,7 @@ WHERE versionId NOT IN (SELECT (versionId) FROM {PreTables.ContentVersion} WHERE
if (!ColumnExists(PreTables.Document, "edited"))
{
AddColumn(PreTables.Document, "edited", out var sqls);
- Database.Execute($"UPDATE {SqlSyntax.GetQuotedTableName(PreTables.Document)} SET edited=0");
+ Database.Execute($"UPDATE {SqlSyntax.GetQuotedTableName(PreTables.Document)} SET edited=~published");
foreach (var sql in sqls) Database.Execute(sql);
}
@@ -240,11 +292,15 @@ JOIN {Constants.DatabaseSchema.Tables.PropertyData} v1 ON cv1.id=v1.versionId
JOIN {PreTables.ContentVersion} cv2 ON n.id=cv2.nodeId
JOIN {Constants.DatabaseSchema.Tables.DocumentVersion} dv ON cv2.id=dv.id AND dv.published=1
JOIN {Constants.DatabaseSchema.Tables.PropertyData} v2 ON cv2.id=v2.versionId
-WHERE v1.propertyTypeId=v2.propertyTypeId AND v1.languageId=v2.languageId AND v1.segment=v2.segment");
+WHERE v1.propertyTypeId=v2.propertyTypeId
+AND (v1.languageId=v2.languageId OR (v1.languageId IS NULL AND v2.languageId IS NULL))
+AND (v1.segment=v2.segment OR (v1.segment IS NULL AND v2.segment IS NULL))");
+ var updatedIds = new HashSet();
foreach (var t in temp)
if (t.intValue1 != t.intValue2 || t.decimalValue1 != t.decimalValue2 || t.dateValue1 != t.dateValue2 || t.varcharValue1 != t.varcharValue2 || t.textValue1 != t.textValue2)
- Database.Execute("UPDATE {SqlSyntax.GetQuotedTableName(PreTables.Document)} SET edited=1 WHERE nodeId=@nodeIdd", new { t.id });
+ if (updatedIds.Add((int)t.id))
+ Database.Execute($"UPDATE {SqlSyntax.GetQuotedTableName(PreTables.Document)} SET edited=1 WHERE nodeId=@nodeId", new { nodeId = t.id });
// drop more columns
Delete.Column("versionId").FromTable(PreTables.ContentVersion).Do();
diff --git a/src/Umbraco.Core/Migrations/Upgrade/V_8_1_0/ConvertTinyMceAndGridMediaUrlsToLocalLink.cs b/src/Umbraco.Core/Migrations/Upgrade/V_8_1_0/ConvertTinyMceAndGridMediaUrlsToLocalLink.cs
index b68aa23d78..052b72ca26 100644
--- a/src/Umbraco.Core/Migrations/Upgrade/V_8_1_0/ConvertTinyMceAndGridMediaUrlsToLocalLink.cs
+++ b/src/Umbraco.Core/Migrations/Upgrade/V_8_1_0/ConvertTinyMceAndGridMediaUrlsToLocalLink.cs
@@ -5,6 +5,7 @@ using System.Text.RegularExpressions;
using Newtonsoft.Json;
using Newtonsoft.Json.Linq;
using Umbraco.Core.Migrations.PostMigrations;
+using Umbraco.Core.Migrations.Upgrade.V_8_0_0.Models;
using Umbraco.Core.Persistence;
using Umbraco.Core.Persistence.Dtos;
using Umbraco.Core.Services;
@@ -27,15 +28,15 @@ namespace Umbraco.Core.Migrations.Upgrade.V_8_1_0
RegexOptions.Compiled | RegexOptions.IgnoreCase | RegexOptions.IgnorePatternWhitespace);
var sqlPropertyData = Sql()
- .Select(r => r.Select(x => x.PropertyTypeDto, r1 => r1.Select(x => x.DataTypeDto)))
- .From()
- .InnerJoin().On((left, right) => left.PropertyTypeId == right.Id)
- .InnerJoin().On((left, right) => left.DataTypeId == right.NodeId)
+ .Select(r => r.Select(x => x.PropertyTypeDto, r1 => r1.Select(x => x.DataTypeDto)))
+ .From()
+ .InnerJoin().On((left, right) => left.PropertyTypeId == right.Id)
+ .InnerJoin().On((left, right) => left.DataTypeId == right.NodeId)
.Where(x =>
x.EditorAlias == Constants.PropertyEditors.Aliases.TinyMce ||
x.EditorAlias == Constants.PropertyEditors.Aliases.Grid);
- var properties = Database.Fetch(sqlPropertyData);
+ var properties = Database.Fetch(sqlPropertyData);
var exceptions = new List();
foreach (var property in properties)
@@ -43,6 +44,8 @@ namespace Umbraco.Core.Migrations.Upgrade.V_8_1_0
var value = property.TextValue;
if (string.IsNullOrWhiteSpace(value)) continue;
+
+ bool propertyChanged = false;
if (property.PropertyTypeDto.DataTypeDto.EditorAlias == Constants.PropertyEditors.Aliases.Grid)
{
try
@@ -55,7 +58,8 @@ namespace Umbraco.Core.Migrations.Upgrade.V_8_1_0
var controlValue = control["value"];
if (controlValue?.Type == JTokenType.String)
{
- control["value"] = UpdateMediaUrls(mediaLinkPattern, controlValue.Value());
+ control["value"] = UpdateMediaUrls(mediaLinkPattern, controlValue.Value(), out var controlChanged);
+ propertyChanged |= controlChanged;
}
}
@@ -76,10 +80,11 @@ namespace Umbraco.Core.Migrations.Upgrade.V_8_1_0
}
else
{
- property.TextValue = UpdateMediaUrls(mediaLinkPattern, value);
+ property.TextValue = UpdateMediaUrls(mediaLinkPattern, value, out propertyChanged);
}
- Database.Update(property);
+ if (propertyChanged)
+ Database.Update(property);
}
@@ -91,10 +96,14 @@ namespace Umbraco.Core.Migrations.Upgrade.V_8_1_0
Context.AddPostMigration();
}
- private string UpdateMediaUrls(Regex mediaLinkPattern, string value)
+ private string UpdateMediaUrls(Regex mediaLinkPattern, string value, out bool changed)
{
- return mediaLinkPattern.Replace(value, match =>
+ bool matched = false;
+
+ var result = mediaLinkPattern.Replace(value, match =>
{
+ matched = true;
+
// match groups:
// - 1 = from the beginning of the a tag until href attribute value begins
// - 2 = the href attribute value excluding the querystring (if present)
@@ -106,6 +115,10 @@ namespace Umbraco.Core.Migrations.Upgrade.V_8_1_0
? match.Value
: $"{match.Groups[1].Value}/{{localLink:{media.GetUdi()}}}{match.Groups[3].Value}";
});
+
+ changed = matched;
+
+ return result;
}
}
}
diff --git a/src/Umbraco.Core/Migrations/Upgrade/V_8_6_0/AddMainDomLock.cs b/src/Umbraco.Core/Migrations/Upgrade/V_8_6_0/AddMainDomLock.cs
new file mode 100644
index 0000000000..6ca493ac7e
--- /dev/null
+++ b/src/Umbraco.Core/Migrations/Upgrade/V_8_6_0/AddMainDomLock.cs
@@ -0,0 +1,16 @@
+using Umbraco.Core.Persistence.Dtos;
+
+namespace Umbraco.Core.Migrations.Upgrade.V_8_6_0
+{
+ public class AddMainDomLock : MigrationBase
+ {
+ public AddMainDomLock(IMigrationContext context)
+ : base(context)
+ { }
+
+ public override void Migrate()
+ {
+ Database.Insert(Constants.DatabaseSchema.Tables.Lock, "id", false, new LockDto { Id = Constants.Locks.MainDom, Name = "MainDom" });
+ }
+ }
+}
diff --git a/src/Umbraco.Core/Migrations/Upgrade/V_8_6_0/AddNewRelationTypes.cs b/src/Umbraco.Core/Migrations/Upgrade/V_8_6_0/AddNewRelationTypes.cs
new file mode 100644
index 0000000000..2e2e00a9bc
--- /dev/null
+++ b/src/Umbraco.Core/Migrations/Upgrade/V_8_6_0/AddNewRelationTypes.cs
@@ -0,0 +1,33 @@
+using Umbraco.Core.Migrations.Install;
+
+namespace Umbraco.Core.Migrations.Upgrade.V_8_6_0
+{
+ ///
+ /// Ensures the new relation types are created
+ ///
+ public class AddNewRelationTypes : MigrationBase
+ {
+ public AddNewRelationTypes(IMigrationContext context)
+ : base(context)
+ { }
+
+ public override void Migrate()
+ {
+ CreateRelation(
+ Constants.Conventions.RelationTypes.RelatedMediaAlias,
+ Constants.Conventions.RelationTypes.RelatedMediaName);
+
+ CreateRelation(
+ Constants.Conventions.RelationTypes.RelatedDocumentAlias,
+ Constants.Conventions.RelationTypes.RelatedDocumentName);
+ }
+
+ private void CreateRelation(string alias, string name)
+ {
+ var uniqueId = DatabaseDataCreator.CreateUniqueRelationTypeId(alias ,name); //this is the same as how it installs so everything is consistent
+ Insert.IntoTable(Constants.DatabaseSchema.Tables.RelationType)
+ .Row(new { typeUniqueId = uniqueId, dual = 0, name, alias })
+ .Do();
+ }
+ }
+}
diff --git a/src/Umbraco.Core/Migrations/Upgrade/V_8_6_0/AddPropertyTypeValidationMessageColumns.cs b/src/Umbraco.Core/Migrations/Upgrade/V_8_6_0/AddPropertyTypeValidationMessageColumns.cs
index 30eb30109e..f44695da69 100644
--- a/src/Umbraco.Core/Migrations/Upgrade/V_8_6_0/AddPropertyTypeValidationMessageColumns.cs
+++ b/src/Umbraco.Core/Migrations/Upgrade/V_8_6_0/AddPropertyTypeValidationMessageColumns.cs
@@ -3,6 +3,7 @@ using Umbraco.Core.Persistence.Dtos;
namespace Umbraco.Core.Migrations.Upgrade.V_8_6_0
{
+
public class AddPropertyTypeValidationMessageColumns : MigrationBase
{
public AddPropertyTypeValidationMessageColumns(IMigrationContext context)
diff --git a/src/Umbraco.Core/Migrations/Upgrade/V_8_6_0/MissingContentVersionsIndexes.cs b/src/Umbraco.Core/Migrations/Upgrade/V_8_6_0/MissingContentVersionsIndexes.cs
new file mode 100644
index 0000000000..c744409c2f
--- /dev/null
+++ b/src/Umbraco.Core/Migrations/Upgrade/V_8_6_0/MissingContentVersionsIndexes.cs
@@ -0,0 +1,33 @@
+using Umbraco.Core.Persistence.Dtos;
+
+namespace Umbraco.Core.Migrations.Upgrade.V_8_6_0
+{
+ public class MissingContentVersionsIndexes : MigrationBase
+ {
+ private const string IndexName = "IX_" + ContentVersionDto.TableName + "_NodeId";
+
+ public MissingContentVersionsIndexes(IMigrationContext context) : base(context)
+ {
+ }
+
+ public override void Migrate()
+ {
+ // We must check before we create an index because if we are upgrading from v7 we force re-create all
+ // indexes in the whole DB and then this would throw
+
+ if (!IndexExists(IndexName))
+ {
+ Create
+ .Index(IndexName)
+ .OnTable(ContentVersionDto.TableName)
+ .OnColumn("nodeId")
+ .Ascending()
+ .OnColumn("current")
+ .Ascending()
+ .WithOptions().NonClustered()
+ .Do();
+ }
+
+ }
+ }
+}
diff --git a/src/Umbraco.Core/Migrations/Upgrade/V_8_6_0/UpdateRelationTypeTable.cs b/src/Umbraco.Core/Migrations/Upgrade/V_8_6_0/UpdateRelationTypeTable.cs
new file mode 100644
index 0000000000..c79f43d20f
--- /dev/null
+++ b/src/Umbraco.Core/Migrations/Upgrade/V_8_6_0/UpdateRelationTypeTable.cs
@@ -0,0 +1,38 @@
+using Umbraco.Core.Persistence.Dtos;
+
+namespace Umbraco.Core.Migrations.Upgrade.V_8_6_0
+{
+
+ public class UpdateRelationTypeTable : MigrationBase
+ {
+ public UpdateRelationTypeTable(IMigrationContext context)
+ : base(context)
+ { }
+
+ public override void Migrate()
+ {
+
+ Alter.Table(Constants.DatabaseSchema.Tables.RelationType).AlterColumn("parentObjectType").AsGuid().Nullable().Do();
+ Alter.Table(Constants.DatabaseSchema.Tables.RelationType).AlterColumn("childObjectType").AsGuid().Nullable().Do();
+
+ //TODO: We have to update this field to ensure it's not null, we can just copy across the name since that is not nullable
+
+ //drop index before we can alter the column
+ if (IndexExists("IX_umbracoRelationType_alias"))
+ Delete
+ .Index("IX_umbracoRelationType_alias")
+ .OnTable(Constants.DatabaseSchema.Tables.RelationType)
+ .Do();
+ //change the column to non nullable
+ Alter.Table(Constants.DatabaseSchema.Tables.RelationType).AlterColumn("alias").AsString(100).NotNullable().Do();
+ //re-create the index
+ Create
+ .Index("IX_umbracoRelationType_alias")
+ .OnTable(Constants.DatabaseSchema.Tables.RelationType)
+ .OnColumn("alias")
+ .Ascending()
+ .WithOptions().Unique().WithOptions().NonClustered()
+ .Do();
+ }
+ }
+}
diff --git a/src/Umbraco.Core/Migrations/Upgrade/V_8_7_0/MissingDictionaryIndex.cs b/src/Umbraco.Core/Migrations/Upgrade/V_8_7_0/MissingDictionaryIndex.cs
new file mode 100644
index 0000000000..fa5116c990
--- /dev/null
+++ b/src/Umbraco.Core/Migrations/Upgrade/V_8_7_0/MissingDictionaryIndex.cs
@@ -0,0 +1,33 @@
+using Umbraco.Core.Persistence.Dtos;
+
+namespace Umbraco.Core.Migrations.Upgrade.V_8_6_0
+{
+ public class MissingDictionaryIndex : MigrationBase
+ {
+ public MissingDictionaryIndex(IMigrationContext context)
+ : base(context)
+ {
+
+ }
+
+ ///
+ /// Adds an index to the foreign key column parent on DictionaryDto's table
+ /// if it doesn't already exist
+ ///
+ public override void Migrate()
+ {
+ var indexName = "IX_" + DictionaryDto.TableName + "_Parent";
+
+ if (!IndexExists(indexName))
+ {
+ Create
+ .Index(indexName)
+ .OnTable(DictionaryDto.TableName)
+ .OnColumn("parent")
+ .Ascending()
+ .WithOptions().NonClustered()
+ .Do();
+ }
+ }
+ }
+}
diff --git a/src/Umbraco.Core/Models/Editors/ContentPropertyFile.cs b/src/Umbraco.Core/Models/Editors/ContentPropertyFile.cs
index ac236e1fdd..225e29a8a1 100644
--- a/src/Umbraco.Core/Models/Editors/ContentPropertyFile.cs
+++ b/src/Umbraco.Core/Models/Editors/ContentPropertyFile.cs
@@ -1,5 +1,6 @@
namespace Umbraco.Core.Models.Editors
{
+
///
/// Represents an uploaded file for a property.
///
diff --git a/src/Umbraco.Core/Models/Editors/UmbracoEntityReference.cs b/src/Umbraco.Core/Models/Editors/UmbracoEntityReference.cs
new file mode 100644
index 0000000000..31d48e60cf
--- /dev/null
+++ b/src/Umbraco.Core/Models/Editors/UmbracoEntityReference.cs
@@ -0,0 +1,70 @@
+using System;
+using System.Collections.Generic;
+
+namespace Umbraco.Core.Models.Editors
+{
+ ///
+ /// Used to track reference to other entities in a property value
+ ///
+ public struct UmbracoEntityReference : IEquatable
+ {
+ private static readonly UmbracoEntityReference _empty = new UmbracoEntityReference(Udi.UnknownTypeUdi.Instance, string.Empty);
+
+ public UmbracoEntityReference(Udi udi, string relationTypeAlias)
+ {
+ Udi = udi ?? throw new ArgumentNullException(nameof(udi));
+ RelationTypeAlias = relationTypeAlias ?? throw new ArgumentNullException(nameof(relationTypeAlias));
+ }
+
+ public UmbracoEntityReference(Udi udi)
+ {
+ Udi = udi ?? throw new ArgumentNullException(nameof(udi));
+
+ switch (udi.EntityType)
+ {
+ case Constants.UdiEntityType.Media:
+ RelationTypeAlias = Constants.Conventions.RelationTypes.RelatedMediaAlias;
+ break;
+ default:
+ RelationTypeAlias = Constants.Conventions.RelationTypes.RelatedDocumentAlias;
+ break;
+ }
+ }
+
+ public static UmbracoEntityReference Empty() => _empty;
+
+ public static bool IsEmpty(UmbracoEntityReference reference) => reference == Empty();
+
+ public Udi Udi { get; }
+ public string RelationTypeAlias { get; }
+
+ public override bool Equals(object obj)
+ {
+ return obj is UmbracoEntityReference reference && Equals(reference);
+ }
+
+ public bool Equals(UmbracoEntityReference other)
+ {
+ return EqualityComparer.Default.Equals(Udi, other.Udi) &&
+ RelationTypeAlias == other.RelationTypeAlias;
+ }
+
+ public override int GetHashCode()
+ {
+ var hashCode = -487348478;
+ hashCode = hashCode * -1521134295 + EqualityComparer.Default.GetHashCode(Udi);
+ hashCode = hashCode * -1521134295 + EqualityComparer.Default.GetHashCode(RelationTypeAlias);
+ return hashCode;
+ }
+
+ public static bool operator ==(UmbracoEntityReference left, UmbracoEntityReference right)
+ {
+ return left.Equals(right);
+ }
+
+ public static bool operator !=(UmbracoEntityReference left, UmbracoEntityReference right)
+ {
+ return !(left == right);
+ }
+ }
+}
diff --git a/src/Umbraco.Core/Models/Entities/ITreeEntity.cs b/src/Umbraco.Core/Models/Entities/ITreeEntity.cs
index afa3399202..ab63e1e1d8 100644
--- a/src/Umbraco.Core/Models/Entities/ITreeEntity.cs
+++ b/src/Umbraco.Core/Models/Entities/ITreeEntity.cs
@@ -24,7 +24,7 @@
/// Sets the parent entity.
///
/// Use this method to set the parent entity when the parent entity is known, but has not
- /// been persistent and does not yet have an identity. The parent identifier will we retrieved
+ /// been persistent and does not yet have an identity. The parent identifier will be retrieved
/// from the parent entity when needed. If the parent entity still does not have an entity by that
/// time, an exception will be thrown by getter.
void SetParent(ITreeEntity parent);
@@ -53,4 +53,4 @@
///
bool Trashed { get; }
}
-}
\ No newline at end of file
+}
diff --git a/src/Umbraco.Core/Models/Entities/MemberEntitySlim.cs b/src/Umbraco.Core/Models/Entities/MemberEntitySlim.cs
index 335e269467..338f363856 100644
--- a/src/Umbraco.Core/Models/Entities/MemberEntitySlim.cs
+++ b/src/Umbraco.Core/Models/Entities/MemberEntitySlim.cs
@@ -1,13 +1,6 @@
namespace Umbraco.Core.Models.Entities
{
- public class MemberEntitySlim : EntitySlim, IMemberEntitySlim
+ public class MemberEntitySlim : ContentEntitySlim, IMemberEntitySlim
{
- public string ContentTypeAlias { get; set; }
-
- ///
- public string ContentTypeIcon { get; set; }
-
- ///
- public string ContentTypeThumbnail { get; set; }
}
-}
\ No newline at end of file
+}
diff --git a/src/Umbraco.Core/Models/IImageUrlGenerator.cs b/src/Umbraco.Core/Models/IImageUrlGenerator.cs
new file mode 100644
index 0000000000..0dc2933fd9
--- /dev/null
+++ b/src/Umbraco.Core/Models/IImageUrlGenerator.cs
@@ -0,0 +1,7 @@
+namespace Umbraco.Core.Models
+{
+ public interface IImageUrlGenerator
+ {
+ string GetImageUrl(ImageUrlGenerationOptions options);
+ }
+}
diff --git a/src/Umbraco.Core/Models/IRelation.cs b/src/Umbraco.Core/Models/IRelation.cs
index 745216fba1..6bd348d72f 100644
--- a/src/Umbraco.Core/Models/IRelation.cs
+++ b/src/Umbraco.Core/Models/IRelation.cs
@@ -1,4 +1,5 @@
-using System.Runtime.Serialization;
+using System;
+using System.Runtime.Serialization;
using Umbraco.Core.Models.Entities;
namespace Umbraco.Core.Models
@@ -11,12 +12,18 @@ namespace Umbraco.Core.Models
[DataMember]
int ParentId { get; set; }
+ [DataMember]
+ Guid ParentObjectType { get; set; }
+
///
/// Gets or sets the Child Id of the Relation (Destination)
///
[DataMember]
int ChildId { get; set; }
+ [DataMember]
+ Guid ChildObjectType { get; set; }
+
///
/// Gets or sets the for the Relation
///
diff --git a/src/Umbraco.Core/Models/IRelationType.cs b/src/Umbraco.Core/Models/IRelationType.cs
index 8bbe657427..9253fae8ab 100644
--- a/src/Umbraco.Core/Models/IRelationType.cs
+++ b/src/Umbraco.Core/Models/IRelationType.cs
@@ -29,13 +29,13 @@ namespace Umbraco.Core.Models
///
/// Corresponds to the NodeObjectType in the umbracoNode table
[DataMember]
- Guid ParentObjectType { get; set; }
+ Guid? ParentObjectType { get; set; }
///
/// Gets or sets the Childs object type id
///
/// Corresponds to the NodeObjectType in the umbracoNode table
[DataMember]
- Guid ChildObjectType { get; set; }
+ Guid? ChildObjectType { get; set; }
}
}
diff --git a/src/Umbraco.Core/Models/ImageUrlGenerationOptions.cs b/src/Umbraco.Core/Models/ImageUrlGenerationOptions.cs
new file mode 100644
index 0000000000..f87657c33d
--- /dev/null
+++ b/src/Umbraco.Core/Models/ImageUrlGenerationOptions.cs
@@ -0,0 +1,66 @@
+namespace Umbraco.Core.Models
+{
+ ///
+ /// These are options that are passed to the IImageUrlGenerator implementation to determine
+ /// the propery URL that is needed
+ ///
+ public class ImageUrlGenerationOptions
+ {
+ public ImageUrlGenerationOptions (string imageUrl)
+ {
+ ImageUrl = imageUrl;
+ }
+
+ public string ImageUrl { get; }
+ public int? Width { get; set; }
+ public int? Height { get; set; }
+ public decimal? WidthRatio { get; set; }
+ public decimal? HeightRatio { get; set; }
+ public int? Quality { get; set; }
+ public string ImageCropMode { get; set; }
+ public string ImageCropAnchor { get; set; }
+ public bool DefaultCrop { get; set; }
+ public FocalPointPosition FocalPoint { get; set; }
+ public CropCoordinates Crop { get; set; }
+ public string CacheBusterValue { get; set; }
+ public string FurtherOptions { get; set; }
+ public bool UpScale { get; set; } = true;
+ public string AnimationProcessMode { get; set; }
+
+ ///
+ /// The focal point position, in whatever units the registered IImageUrlGenerator uses,
+ /// typically a percentage of the total image from 0.0 to 1.0.
+ ///
+ public class FocalPointPosition
+ {
+ public FocalPointPosition (decimal top, decimal left)
+ {
+ Left = left;
+ Top = top;
+ }
+
+ public decimal Left { get; }
+ public decimal Top { get; }
+ }
+
+ ///
+ /// The bounds of the crop within the original image, in whatever units the registered
+ /// IImageUrlGenerator uses, typically a percentage between 0 and 100.
+ ///
+ public class CropCoordinates
+ {
+ public CropCoordinates (decimal x1, decimal y1, decimal x2, decimal y2)
+ {
+ X1 = x1;
+ Y1 = y1;
+ X2 = x2;
+ Y2 = y2;
+ }
+
+ public decimal X1 { get; }
+ public decimal Y1 { get; }
+ public decimal X2 { get; }
+ public decimal Y2 { get; }
+ }
+ }
+}
diff --git a/src/Umbraco.Core/Models/MediaExtensions.cs b/src/Umbraco.Core/Models/MediaExtensions.cs
index 1166698adb..96f183b6e6 100644
--- a/src/Umbraco.Core/Models/MediaExtensions.cs
+++ b/src/Umbraco.Core/Models/MediaExtensions.cs
@@ -1,10 +1,8 @@
-using System;
-using System.Linq;
-using Newtonsoft.Json;
-using Newtonsoft.Json.Linq;
+using System.Linq;
+using Umbraco.Core.Composing;
using Umbraco.Core.Configuration.UmbracoSettings;
using Umbraco.Core.Logging;
-using Umbraco.Core.PropertyEditors.ValueConverters;
+using Umbraco.Core.PropertyEditors;
namespace Umbraco.Core.Models
{
@@ -18,29 +16,12 @@ namespace Umbraco.Core.Models
if (!media.Properties.TryGetValue(propertyAlias, out var property))
return string.Empty;
- // TODO: would need to be adjusted to variations, when media become variants
- if (!(property.GetValue() is string jsonString))
- return string.Empty;
-
- if (property.PropertyType.PropertyEditorAlias == Constants.PropertyEditors.Aliases.UploadField)
- return jsonString;
-
- if (property.PropertyType.PropertyEditorAlias == Constants.PropertyEditors.Aliases.ImageCropper)
+ if (Current.PropertyEditors.TryGet(property.PropertyType.PropertyEditorAlias, out var editor)
+ && editor is IDataEditorWithMediaPath dataEditor)
{
- if (jsonString.DetectIsJson() == false)
- return jsonString;
-
- try
- {
- var json = JsonConvert.DeserializeObject(jsonString);
- if (json["src"] != null)
- return json["src"].Value();
- }
- catch (Exception ex)
- {
- logger.Error(ex, "Could not parse the string '{JsonString}' to a json object", jsonString);
- return string.Empty;
- }
+ // TODO: would need to be adjusted to variations, when media become variants
+ var value = property.GetValue();
+ return dataEditor.GetMediaPath(value);
}
// Without knowing what it is, just adding a string here might not be very nice
diff --git a/src/Umbraco.Core/Models/MediaTypeExtensions.cs b/src/Umbraco.Core/Models/MediaTypeExtensions.cs
new file mode 100644
index 0000000000..4e2ae5822a
--- /dev/null
+++ b/src/Umbraco.Core/Models/MediaTypeExtensions.cs
@@ -0,0 +1,10 @@
+namespace Umbraco.Core.Models
+{
+ internal static class MediaTypeExtensions
+ {
+ internal static bool IsSystemMediaType(this IMediaType mediaType) =>
+ mediaType.Alias == Constants.Conventions.MediaTypes.File
+ || mediaType.Alias == Constants.Conventions.MediaTypes.Folder
+ || mediaType.Alias == Constants.Conventions.MediaTypes.Image;
+ }
+}
diff --git a/src/Umbraco.Core/Models/ObjectTypes.cs b/src/Umbraco.Core/Models/ObjectTypes.cs
index dd943ee02b..2ddbdca77a 100644
--- a/src/Umbraco.Core/Models/ObjectTypes.cs
+++ b/src/Umbraco.Core/Models/ObjectTypes.cs
@@ -41,7 +41,7 @@ namespace Umbraco.Core.Models
///
public static UmbracoObjectTypes GetUmbracoObjectType(string name)
{
- return (UmbracoObjectTypes) Enum.Parse(typeof (UmbracoObjectTypes), name, false);
+ return (UmbracoObjectTypes) Enum.Parse(typeof (UmbracoObjectTypes), name, true);
}
#region Guid object type utilities
diff --git a/src/Umbraco.Core/Models/PublishedContent/IPublishedContent.cs b/src/Umbraco.Core/Models/PublishedContent/IPublishedContent.cs
index 1c0d39a8b8..4e154bf514 100644
--- a/src/Umbraco.Core/Models/PublishedContent/IPublishedContent.cs
+++ b/src/Umbraco.Core/Models/PublishedContent/IPublishedContent.cs
@@ -63,6 +63,7 @@ namespace Umbraco.Core.Models.PublishedContent
///
/// Gets the name of the user who created the content item.
///
+ [Obsolete("Use CreatorName(IUserService) extension instead")]
string CreatorName { get; }
///
@@ -78,6 +79,7 @@ namespace Umbraco.Core.Models.PublishedContent
///
/// Gets the name of the user who last updated the content item.
///
+ [Obsolete("Use WriterName(IUserService) extension instead")]
string WriterName { get; }
///
@@ -97,6 +99,7 @@ namespace Umbraco.Core.Models.PublishedContent
/// The value of this property is contextual. It depends on the 'current' request uri,
/// if any.
///
+ [Obsolete("Use the Url() extension instead")]
string Url { get; }
///
diff --git a/src/Umbraco.Core/Models/PublishedContent/PublishedContentWrapped.cs b/src/Umbraco.Core/Models/PublishedContent/PublishedContentWrapped.cs
index fb41c95419..b83dc7a013 100644
--- a/src/Umbraco.Core/Models/PublishedContent/PublishedContentWrapped.cs
+++ b/src/Umbraco.Core/Models/PublishedContent/PublishedContentWrapped.cs
@@ -94,6 +94,7 @@ namespace Umbraco.Core.Models.PublishedContent
public virtual DateTime UpdateDate => _content.UpdateDate;
///
+ [Obsolete("Use the Url() extension instead")]
public virtual string Url => _content.Url;
///
diff --git a/src/Umbraco.Core/Models/Relation.cs b/src/Umbraco.Core/Models/Relation.cs
index f5d13c70c4..7afa476226 100644
--- a/src/Umbraco.Core/Models/Relation.cs
+++ b/src/Umbraco.Core/Models/Relation.cs
@@ -17,13 +17,36 @@ namespace Umbraco.Core.Models
private IRelationType _relationType;
private string _comment;
+ ///
+ /// Constructor for constructing the entity to be created
+ ///
+ ///
+ ///
+ ///
public Relation(int parentId, int childId, IRelationType relationType)
{
_parentId = parentId;
_childId = childId;
_relationType = relationType;
}
-
+
+ ///
+ /// Constructor for reconstructing the entity from the data source
+ ///
+ ///
+ ///
+ ///
+ ///
+ ///
+ public Relation(int parentId, int childId, Guid parentObjectType, Guid childObjectType, IRelationType relationType)
+ {
+ _parentId = parentId;
+ _childId = childId;
+ _relationType = relationType;
+ ParentObjectType = parentObjectType;
+ ChildObjectType = childObjectType;
+ }
+
///
/// Gets or sets the Parent Id of the Relation (Source)
@@ -35,6 +58,9 @@ namespace Umbraco.Core.Models
set => SetPropertyValueAndDetectChanges(value, ref _parentId, nameof(ParentId));
}
+ [DataMember]
+ public Guid ParentObjectType { get; set; }
+
///
/// Gets or sets the Child Id of the Relation (Destination)
///
@@ -45,6 +71,9 @@ namespace Umbraco.Core.Models
set => SetPropertyValueAndDetectChanges(value, ref _childId, nameof(ChildId));
}
+ [DataMember]
+ public Guid ChildObjectType { get; set; }
+
///
/// Gets or sets the for the Relation
///
diff --git a/src/Umbraco.Core/Models/RelationType.cs b/src/Umbraco.Core/Models/RelationType.cs
index 725628bf90..1085ecdcdd 100644
--- a/src/Umbraco.Core/Models/RelationType.cs
+++ b/src/Umbraco.Core/Models/RelationType.cs
@@ -14,28 +14,26 @@ namespace Umbraco.Core.Models
private string _name;
private string _alias;
private bool _isBidrectional;
- private Guid _parentObjectType;
- private Guid _childObjectType;
+ private Guid? _parentObjectType;
+ private Guid? _childObjectType;
- public RelationType(Guid childObjectType, Guid parentObjectType, string alias)
+ //TODO: Should we put back the broken ctors with obsolete attributes?
+
+ public RelationType(string alias, string name)
+ : this(name, alias, false, null, null)
{
- if (alias == null) throw new ArgumentNullException(nameof(alias));
- if (string.IsNullOrWhiteSpace(alias)) throw new ArgumentException("Value can't be empty or consist only of white-space characters.", nameof(alias));
+ }
- _childObjectType = childObjectType;
- _parentObjectType = parentObjectType;
+ public RelationType(string name, string alias, bool isBidrectional, Guid? parentObjectType, Guid? childObjectType)
+ {
+ _name = name;
_alias = alias;
- Name = _alias;
+ _isBidrectional = isBidrectional;
+ _parentObjectType = parentObjectType;
+ _childObjectType = childObjectType;
}
- public RelationType(Guid childObjectType, Guid parentObjectType, string alias, string name)
- : this(childObjectType, parentObjectType, alias)
- {
- if (name == null) throw new ArgumentNullException(nameof(name));
- if (string.IsNullOrWhiteSpace(name)) throw new ArgumentException("Value can't be empty or consist only of white-space characters.", nameof(name));
- Name = name;
- }
///
/// Gets or sets the Name of the RelationType
@@ -72,7 +70,7 @@ namespace Umbraco.Core.Models
///
/// Corresponds to the NodeObjectType in the umbracoNode table
[DataMember]
- public Guid ParentObjectType
+ public Guid? ParentObjectType
{
get => _parentObjectType;
set => SetPropertyValueAndDetectChanges(value, ref _parentObjectType, nameof(ParentObjectType));
@@ -83,7 +81,7 @@ namespace Umbraco.Core.Models
///
/// Corresponds to the NodeObjectType in the umbracoNode table
[DataMember]
- public Guid ChildObjectType
+ public Guid? ChildObjectType
{
get => _childObjectType;
set => SetPropertyValueAndDetectChanges(value, ref _childObjectType, nameof(ChildObjectType));
diff --git a/src/Umbraco.Core/Models/UserExtensions.cs b/src/Umbraco.Core/Models/UserExtensions.cs
index e00ac4ba15..5be66bac47 100644
--- a/src/Umbraco.Core/Models/UserExtensions.cs
+++ b/src/Umbraco.Core/Models/UserExtensions.cs
@@ -106,13 +106,14 @@ namespace Umbraco.Core.Models
//use the custom avatar
var avatarUrl = Current.MediaFileSystem.GetUrl(user.Avatar);
+ var urlGenerator = Current.ImageUrlGenerator;
return new[]
{
- avatarUrl + "?width=30&height=30&mode=crop",
- avatarUrl + "?width=60&height=60&mode=crop",
- avatarUrl + "?width=90&height=90&mode=crop",
- avatarUrl + "?width=150&height=150&mode=crop",
- avatarUrl + "?width=300&height=300&mode=crop"
+ urlGenerator.GetImageUrl(new ImageUrlGenerationOptions(avatarUrl) { ImageCropMode = "crop", Width = 30, Height = 30 }),
+ urlGenerator.GetImageUrl(new ImageUrlGenerationOptions(avatarUrl) { ImageCropMode = "crop", Width = 60, Height = 60 }),
+ urlGenerator.GetImageUrl(new ImageUrlGenerationOptions(avatarUrl) { ImageCropMode = "crop", Width = 90, Height = 90 }),
+ urlGenerator.GetImageUrl(new ImageUrlGenerationOptions(avatarUrl) { ImageCropMode = "crop", Width = 150, Height = 150 }),
+ urlGenerator.GetImageUrl(new ImageUrlGenerationOptions(avatarUrl) { ImageCropMode = "crop", Width = 300, Height = 300 })
};
}
diff --git a/src/Umbraco.Core/Packaging/ConflictingPackageData.cs b/src/Umbraco.Core/Packaging/ConflictingPackageData.cs
index 82693677fb..33cb9c40d3 100644
--- a/src/Umbraco.Core/Packaging/ConflictingPackageData.cs
+++ b/src/Umbraco.Core/Packaging/ConflictingPackageData.cs
@@ -7,7 +7,7 @@ using Umbraco.Core.Services;
namespace Umbraco.Core.Packaging
{
- internal class ConflictingPackageData
+ internal class ConflictingPackageData
{
private readonly IMacroService _macroService;
private readonly IFileService _fileService;
@@ -23,7 +23,7 @@ namespace Umbraco.Core.Packaging
return stylesheetNodes
.Select(n =>
{
- var xElement = n.Element("Name") ?? n.Element("name"); ;
+ var xElement = n.Element("Name") ?? n.Element("name");
if (xElement == null)
throw new FormatException("Missing \"Name\" element");
diff --git a/src/Umbraco.Core/Packaging/PackagesRepository.cs b/src/Umbraco.Core/Packaging/PackagesRepository.cs
index 72954b238d..5549b502fa 100644
--- a/src/Umbraco.Core/Packaging/PackagesRepository.cs
+++ b/src/Umbraco.Core/Packaging/PackagesRepository.cs
@@ -82,7 +82,7 @@ namespace Umbraco.Core.Packaging
{
var packagesXml = EnsureStorage(out _);
if (packagesXml?.Root == null)
- yield break;;
+ yield break;
foreach (var packageXml in packagesXml.Root.Elements("package"))
yield return _parser.ToPackageDefinition(packageXml);
@@ -139,7 +139,7 @@ namespace Umbraco.Core.Packaging
var updatedXml = _parser.ToXml(definition);
packageXml.ReplaceWith(updatedXml);
}
-
+
packagesXml.Save(packagesFile);
return true;
@@ -212,7 +212,7 @@ namespace Umbraco.Core.Packaging
compiledPackageXml.Save(packageXmlFileName);
// check if there's a packages directory below media
-
+
if (Directory.Exists(IOHelper.MapPath(_mediaFolderPath)) == false)
Directory.CreateDirectory(IOHelper.MapPath(_mediaFolderPath));
@@ -510,7 +510,6 @@ namespace Umbraco.Core.Packaging
private XElement GetStylesheetXml(string name, bool includeProperties)
{
if (string.IsNullOrWhiteSpace(name)) throw new ArgumentException("Value cannot be null or whitespace.", nameof(name));
-;
var sts = _fileService.GetStylesheetByName(name);
if (sts == null) return null;
var stylesheetXml = new XElement("Stylesheet");
@@ -562,7 +561,7 @@ namespace Umbraco.Core.Packaging
package.Add(new XElement("url", definition.Url));
var requirements = new XElement("requirements");
-
+
requirements.Add(new XElement("major", definition.UmbracoVersion == null ? UmbracoVersion.SemanticVersion.Major.ToInvariantString() : definition.UmbracoVersion.Major.ToInvariantString()));
requirements.Add(new XElement("minor", definition.UmbracoVersion == null ? UmbracoVersion.SemanticVersion.Minor.ToInvariantString() : definition.UmbracoVersion.Minor.ToInvariantString()));
requirements.Add(new XElement("patch", definition.UmbracoVersion == null ? UmbracoVersion.SemanticVersion.Patch.ToInvariantString() : definition.UmbracoVersion.Build.ToInvariantString()));
@@ -589,7 +588,7 @@ namespace Umbraco.Core.Packaging
contributors.Add(new XElement("contributor", contributor));
}
}
-
+
info.Add(contributors);
info.Add(new XElement("readme", new XCData(definition.Readme)));
diff --git a/src/Umbraco.Core/Persistence/Constants-Locks.cs b/src/Umbraco.Core/Persistence/Constants-Locks.cs
index 1dcd2408e7..e64f40ced7 100644
--- a/src/Umbraco.Core/Persistence/Constants-Locks.cs
+++ b/src/Umbraco.Core/Persistence/Constants-Locks.cs
@@ -8,6 +8,11 @@ namespace Umbraco.Core
///
public static class Locks
{
+ ///
+ /// The lock
+ ///
+ public const int MainDom = -1000;
+
///
/// All servers.
///
diff --git a/src/Umbraco.Core/Persistence/Dtos/ContentVersionDto.cs b/src/Umbraco.Core/Persistence/Dtos/ContentVersionDto.cs
index 3c2c3deda4..4b203c128f 100644
--- a/src/Umbraco.Core/Persistence/Dtos/ContentVersionDto.cs
+++ b/src/Umbraco.Core/Persistence/Dtos/ContentVersionDto.cs
@@ -19,6 +19,7 @@ namespace Umbraco.Core.Persistence.Dtos
[Column("nodeId")]
[ForeignKey(typeof(ContentDto))]
+ [Index(IndexTypes.NonClustered, Name = "IX_" + TableName + "_NodeId", ForColumns = "nodeId,current")]
public int NodeId { get; set; }
[Column("versionDate")] // TODO: db rename to 'updateDate'
@@ -30,7 +31,6 @@ namespace Umbraco.Core.Persistence.Dtos
[NullSetting(NullSetting = NullSettings.Null)]
public int? UserId { get => _userId == 0 ? null : _userId; set => _userId = value; } //return null if zero
- // TODO: we need an index on this it is used almost always in querying and sorting
[Column("current")]
public bool Current { get; set; }
diff --git a/src/Umbraco.Core/Persistence/Dtos/DictionaryDto.cs b/src/Umbraco.Core/Persistence/Dtos/DictionaryDto.cs
index 655474b217..d357e9adbc 100644
--- a/src/Umbraco.Core/Persistence/Dtos/DictionaryDto.cs
+++ b/src/Umbraco.Core/Persistence/Dtos/DictionaryDto.cs
@@ -5,11 +5,12 @@ using Umbraco.Core.Persistence.DatabaseAnnotations;
namespace Umbraco.Core.Persistence.Dtos
{
- [TableName(Constants.DatabaseSchema.Tables.DictionaryEntry)]
+ [TableName(TableName)]
[PrimaryKey("pk")]
[ExplicitColumns]
internal class DictionaryDto
{
+ public const string TableName = Constants.DatabaseSchema.Tables.DictionaryEntry;
[Column("pk")]
[PrimaryKeyColumn]
public int PrimaryKey { get; set; }
@@ -21,6 +22,7 @@ namespace Umbraco.Core.Persistence.Dtos
[Column("parent")]
[NullSetting(NullSetting = NullSettings.Null)]
[ForeignKey(typeof(DictionaryDto), Column = "id")]
+ [Index(IndexTypes.NonClustered, Name = "IX_" + TableName + "_Parent")]
public Guid? Parent { get; set; }
[Column("key")]
diff --git a/src/Umbraco.Core/Persistence/Dtos/RelationDto.cs b/src/Umbraco.Core/Persistence/Dtos/RelationDto.cs
index f1fd3007d7..b21866eb8b 100644
--- a/src/Umbraco.Core/Persistence/Dtos/RelationDto.cs
+++ b/src/Umbraco.Core/Persistence/Dtos/RelationDto.cs
@@ -34,5 +34,13 @@ namespace Umbraco.Core.Persistence.Dtos
[Column("comment")]
[Length(1000)]
public string Comment { get; set; }
+
+ [ResultColumn]
+ [Column("parentObjectType")]
+ public Guid ParentObjectType { get; set; }
+
+ [ResultColumn]
+ [Column("childObjectType")]
+ public Guid ChildObjectType { get; set; }
}
}
diff --git a/src/Umbraco.Core/Persistence/Dtos/RelationTypeDto.cs b/src/Umbraco.Core/Persistence/Dtos/RelationTypeDto.cs
index e972192844..d3e107d23f 100644
--- a/src/Umbraco.Core/Persistence/Dtos/RelationTypeDto.cs
+++ b/src/Umbraco.Core/Persistence/Dtos/RelationTypeDto.cs
@@ -9,7 +9,7 @@ namespace Umbraco.Core.Persistence.Dtos
[ExplicitColumns]
internal class RelationTypeDto
{
- public const int NodeIdSeed = 4;
+ public const int NodeIdSeed = 10;
[Column("id")]
[PrimaryKeyColumn(IdentitySeed = NodeIdSeed)]
@@ -23,17 +23,20 @@ namespace Umbraco.Core.Persistence.Dtos
public bool Dual { get; set; }
[Column("parentObjectType")]
- public Guid ParentObjectType { get; set; }
+ [NullSetting(NullSetting = NullSettings.Null)]
+ public Guid? ParentObjectType { get; set; }
[Column("childObjectType")]
- public Guid ChildObjectType { get; set; }
+ [NullSetting(NullSetting = NullSettings.Null)]
+ public Guid? ChildObjectType { get; set; }
[Column("name")]
+ [NullSetting(NullSetting = NullSettings.NotNull)]
[Index(IndexTypes.UniqueNonClustered, Name = "IX_umbracoRelationType_name")]
public string Name { get; set; }
[Column("alias")]
- [NullSetting(NullSetting = NullSettings.Null)]
+ [NullSetting(NullSetting = NullSettings.NotNull)]
[Length(100)]
[Index(IndexTypes.UniqueNonClustered, Name = "IX_umbracoRelationType_alias")]
public string Alias { get; set; }
diff --git a/src/Umbraco.Core/Persistence/Factories/ContentBaseFactory.cs b/src/Umbraco.Core/Persistence/Factories/ContentBaseFactory.cs
index 434e0393cd..2b2bed1d9e 100644
--- a/src/Umbraco.Core/Persistence/Factories/ContentBaseFactory.cs
+++ b/src/Umbraco.Core/Persistence/Factories/ContentBaseFactory.cs
@@ -1,17 +1,15 @@
using System;
using System.Collections.Generic;
using System.Linq;
-using System.Text.RegularExpressions;
using Umbraco.Core.Models;
using Umbraco.Core.Persistence.Dtos;
using Umbraco.Core.Persistence.Repositories;
+using Umbraco.Core.PropertyEditors;
namespace Umbraco.Core.Persistence.Factories
{
internal class ContentBaseFactory
{
- private static readonly Regex MediaPathPattern = new Regex(@"(/media/.+?)(?:['""]|$)", RegexOptions.Compiled);
-
///
/// Builds an IContent item from a dto and content type.
///
@@ -189,7 +187,7 @@ namespace Umbraco.Core.Persistence.Factories
///
/// Builds a dto from an IMedia item.
///
- public static MediaDto BuildDto(IMedia entity)
+ public static MediaDto BuildDto(PropertyEditorCollection propertyEditors, IMedia entity)
{
var contentDto = BuildContentDto(entity, Constants.ObjectTypes.Media);
@@ -197,7 +195,7 @@ namespace Umbraco.Core.Persistence.Factories
{
NodeId = entity.Id,
ContentDto = contentDto,
- MediaVersionDto = BuildMediaVersionDto(entity, contentDto)
+ MediaVersionDto = BuildMediaVersionDto(propertyEditors, entity, contentDto)
};
return dto;
@@ -291,12 +289,20 @@ namespace Umbraco.Core.Persistence.Factories
return dto;
}
- private static MediaVersionDto BuildMediaVersionDto(IMedia entity, ContentDto contentDto)
+ private static MediaVersionDto BuildMediaVersionDto(PropertyEditorCollection propertyEditors, IMedia entity, ContentDto contentDto)
{
// try to get a path from the string being stored for media
// TODO: only considering umbracoFile
- TryMatch(entity.GetValue("umbracoFile"), out var path);
+ string path = null;
+
+ if (entity.Properties.TryGetValue(Constants.Conventions.Media.File, out var property)
+ && propertyEditors.TryGet(property.PropertyType.PropertyEditorAlias, out var editor)
+ && editor is IDataEditorWithMediaPath dataEditor)
+ {
+ var value = property.GetValue();
+ path = dataEditor.GetMediaPath(value);
+ }
var dto = new MediaVersionDto
{
@@ -308,22 +314,5 @@ namespace Umbraco.Core.Persistence.Factories
return dto;
}
-
- // TODO: this should NOT be here?!
- // more dark magic ;-(
- internal static bool TryMatch(string text, out string path)
- {
- // In v8 we should allow exposing this via the property editor in a much nicer way so that the property editor
- // can tell us directly what any URL is for a given property if it contains an asset
-
- path = null;
- if (string.IsNullOrWhiteSpace(text)) return false;
-
- var m = MediaPathPattern.Match(text);
- if (!m.Success || m.Groups.Count != 2) return false;
-
- path = m.Groups[1].Value;
- return true;
- }
}
}
diff --git a/src/Umbraco.Core/Persistence/Factories/RelationFactory.cs b/src/Umbraco.Core/Persistence/Factories/RelationFactory.cs
index 6abb858e94..d8f100cdbe 100644
--- a/src/Umbraco.Core/Persistence/Factories/RelationFactory.cs
+++ b/src/Umbraco.Core/Persistence/Factories/RelationFactory.cs
@@ -3,20 +3,11 @@ using Umbraco.Core.Persistence.Dtos;
namespace Umbraco.Core.Persistence.Factories
{
- internal class RelationFactory
+ internal static class RelationFactory
{
- private readonly IRelationType _relationType;
-
- public RelationFactory(IRelationType relationType)
+ public static IRelation BuildEntity(RelationDto dto, IRelationType relationType)
{
- _relationType = relationType;
- }
-
- #region Implementation of IEntityFactory
-
- public IRelation BuildEntity(RelationDto dto)
- {
- var entity = new Relation(dto.ParentId, dto.ChildId, _relationType);
+ var entity = new Relation(dto.ParentId, dto.ChildId, dto.ParentObjectType, dto.ChildObjectType, relationType);
try
{
@@ -37,7 +28,7 @@ namespace Umbraco.Core.Persistence.Factories
}
}
- public RelationDto BuildDto(IRelation entity)
+ public static RelationDto BuildDto(IRelation entity)
{
var dto = new RelationDto
{
@@ -54,6 +45,5 @@ namespace Umbraco.Core.Persistence.Factories
return dto;
}
- #endregion
}
}
diff --git a/src/Umbraco.Core/Persistence/Factories/RelationTypeFactory.cs b/src/Umbraco.Core/Persistence/Factories/RelationTypeFactory.cs
index ca6928a0a1..edd87fec68 100644
--- a/src/Umbraco.Core/Persistence/Factories/RelationTypeFactory.cs
+++ b/src/Umbraco.Core/Persistence/Factories/RelationTypeFactory.cs
@@ -9,7 +9,7 @@ namespace Umbraco.Core.Persistence.Factories
public static IRelationType BuildEntity(RelationTypeDto dto)
{
- var entity = new RelationType(dto.ChildObjectType, dto.ParentObjectType, dto.Alias);
+ var entity = new RelationType(dto.Name, dto.Alias, dto.Dual, dto.ChildObjectType, dto.ParentObjectType);
try
{
@@ -17,8 +17,6 @@ namespace Umbraco.Core.Persistence.Factories
entity.Id = dto.Id;
entity.Key = dto.UniqueId;
- entity.IsBidirectional = dto.Dual;
- entity.Name = dto.Name;
// reset dirty initial properties (U4-1946)
entity.ResetDirtyProperties(false);
diff --git a/src/Umbraco.Core/Persistence/NPocoDatabaseExtensions-Bulk.cs b/src/Umbraco.Core/Persistence/NPocoDatabaseExtensions-Bulk.cs
index 0574e37c4c..10db1ca18e 100644
--- a/src/Umbraco.Core/Persistence/NPocoDatabaseExtensions-Bulk.cs
+++ b/src/Umbraco.Core/Persistence/NPocoDatabaseExtensions-Bulk.cs
@@ -14,7 +14,21 @@ namespace Umbraco.Core.Persistence
///
public static partial class NPocoDatabaseExtensions
{
- // TODO: review NPoco native InsertBulk to replace the code below
+ ///
+ /// Configures NPoco's SqlBulkCopyHelper to use the correct SqlConnection and SqlTransaction instances from the underlying RetryDbConnection and ProfiledDbTransaction
+ ///
+ ///
+ /// This is required to use NPoco's own method because we use wrapped DbConnection and DbTransaction instances.
+ /// NPoco's InsertBulk method only caters for efficient bulk inserting records for Sql Server, it does not cater for bulk inserting of records for
+ /// any other database type and in which case will just insert records one at a time.
+ /// NPoco's InsertBulk method also deals with updating the passed in entity's PK/ID once it's inserted whereas our own BulkInsertRecords methods
+ /// do not handle this scenario.
+ ///
+ public static void ConfigureNPocoBulkExtensions()
+ {
+ SqlBulkCopyHelper.SqlConnectionResolver = dbConn => GetTypedConnection(dbConn);
+ SqlBulkCopyHelper.SqlTransactionResolver = dbTran => GetTypedTransaction(dbTran);
+ }
///
/// Bulk-inserts records within a transaction.
@@ -235,7 +249,7 @@ namespace Umbraco.Core.Persistence
//we need to add column mappings here because otherwise columns will be matched by their order and if the order of them are different in the DB compared
//to the order in which they are declared in the model then this will not work, so instead we will add column mappings by name so that this explicitly uses
//the names instead of their ordering.
- foreach(var col in bulkReader.ColumnMappings)
+ foreach (var col in bulkReader.ColumnMappings)
{
copy.ColumnMappings.Add(col.DestinationColumn, col.DestinationColumn);
}
diff --git a/src/Umbraco.Core/Persistence/Repositories/IContentTypeRepositoryBase.cs b/src/Umbraco.Core/Persistence/Repositories/IContentTypeRepositoryBase.cs
index 69b0698a96..254e04d2d5 100644
--- a/src/Umbraco.Core/Persistence/Repositories/IContentTypeRepositoryBase.cs
+++ b/src/Umbraco.Core/Persistence/Repositories/IContentTypeRepositoryBase.cs
@@ -26,5 +26,10 @@ namespace Umbraco.Core.Persistence.Repositories
///
///
bool HasContainerInPath(string contentPath);
+
+ ///
+ /// Returns true or false depending on whether content nodes have been created based on the provided content type id.
+ ///
+ bool HasContentNodes(int id);
}
}
diff --git a/src/Umbraco.Core/Persistence/Repositories/IEntityRepository.cs b/src/Umbraco.Core/Persistence/Repositories/IEntityRepository.cs
index 69f6ef4c5f..a0ddcac8e6 100644
--- a/src/Umbraco.Core/Persistence/Repositories/IEntityRepository.cs
+++ b/src/Umbraco.Core/Persistence/Repositories/IEntityRepository.cs
@@ -1,4 +1,5 @@
-using System;
+using NPoco;
+using System;
using System.Collections.Generic;
using Umbraco.Core.Models;
using Umbraco.Core.Models.Entities;
@@ -15,10 +16,22 @@ namespace Umbraco.Core.Persistence.Repositories
IEntitySlim Get(int id, Guid objectTypeId);
IEntitySlim Get(Guid key, Guid objectTypeId);
- IEnumerable GetAll(Guid objectType, params int[] ids);
+ IEnumerable GetAll(Guid objectType, params int[] ids);
IEnumerable GetAll(Guid objectType, params Guid[] keys);
+ ///
+ /// Gets entities for a query
+ ///
+ ///
+ ///
IEnumerable GetByQuery(IQuery query);
+
+ ///
+ /// Gets entities for a query and a specific object type allowing the query to be slightly more optimized
+ ///
+ ///
+ ///
+ ///
IEnumerable GetByQuery(IQuery query, Guid objectType);
UmbracoObjectTypes GetObjectType(int id);
@@ -30,7 +43,41 @@ namespace Umbraco.Core.Persistence.Repositories
bool Exists(int id);
bool Exists(Guid key);
+ ///
+ /// Gets paged entities for a query and a subset of object types
+ ///
+ ///
+ ///
+ ///
+ ///
+ ///
+ ///
+ ///
+ ///
+ /// A callback providing the ability to customize the generated SQL used to retrieve entities
+ ///
+ ///
+ /// A collection of mixed entity types which would be of type , , ,
+ ///
+ ///
+ IEnumerable GetPagedResultsByQuery(
+ IQuery query, Guid[] objectTypes, long pageIndex, int pageSize, out long totalRecords,
+ IQuery filter, Ordering ordering, Action> sqlCustomization = null);
+
+ ///
+ /// Gets paged entities for a query and a specific object type
+ ///
+ ///
+ ///
+ ///
+ ///
+ ///
+ ///
+ ///
+ ///
IEnumerable GetPagedResultsByQuery(IQuery query, Guid objectType, long pageIndex, int pageSize, out long totalRecords,
IQuery filter, Ordering ordering);
+
+
}
}
diff --git a/src/Umbraco.Core/Persistence/Repositories/IRelationRepository.cs b/src/Umbraco.Core/Persistence/Repositories/IRelationRepository.cs
index 51d7656d8a..fc1be20e6f 100644
--- a/src/Umbraco.Core/Persistence/Repositories/IRelationRepository.cs
+++ b/src/Umbraco.Core/Persistence/Repositories/IRelationRepository.cs
@@ -1,9 +1,33 @@
-using Umbraco.Core.Models;
+using System;
+using System.Collections.Generic;
+using Umbraco.Core.Models;
+using Umbraco.Core.Models.Entities;
+using Umbraco.Core.Persistence.Querying;
+using Umbraco.Core.Services;
namespace Umbraco.Core.Persistence.Repositories
{
public interface IRelationRepository : IReadWriteQueryRepository
{
+ IEnumerable GetPagedRelationsByQuery(IQuery query, long pageIndex, int pageSize, out long totalRecords, Ordering ordering);
+ ///
+ /// Persist multiple at once
+ ///
+ ///
+ void Save(IEnumerable relations);
+
+ ///
+ /// Deletes all relations for a parent for any specified relation type alias
+ ///
+ ///
+ ///
+ /// A list of relation types to match for deletion, if none are specified then all relations for this parent id are deleted
+ ///
+ void DeleteByParent(int parentId, params string[] relationTypeAliases);
+
+ IEnumerable GetPagedParentEntitiesByChildId(int childId, long pageIndex, int pageSize, out long totalRecords, params Guid[] entityTypes);
+
+ IEnumerable GetPagedChildEntitiesByParentId(int parentId, long pageIndex, int pageSize, out long totalRecords, params Guid[] entityTypes);
}
}
diff --git a/src/Umbraco.Core/Persistence/Repositories/Implement/AuditRepository.cs b/src/Umbraco.Core/Persistence/Repositories/Implement/AuditRepository.cs
index 0788594e3a..4cb533e86f 100644
--- a/src/Umbraco.Core/Persistence/Repositories/Implement/AuditRepository.cs
+++ b/src/Umbraco.Core/Persistence/Repositories/Implement/AuditRepository.cs
@@ -77,7 +77,8 @@ namespace Umbraco.Core.Persistence.Repositories.Implement
public IEnumerable Get(AuditType type, IQuery query)
{
var sqlClause = GetBaseQuery(false)
- .Where(x => x.Header == type.ToString());
+ .Where("(logHeader=@0)", type.ToString());
+
var translator = new SqlTranslator(sqlClause, query);
var sql = translator.Translate();
diff --git a/src/Umbraco.Core/Persistence/Repositories/Implement/ContentRepositoryBase.cs b/src/Umbraco.Core/Persistence/Repositories/Implement/ContentRepositoryBase.cs
index 7ab73f3f2d..13b687eb4e 100644
--- a/src/Umbraco.Core/Persistence/Repositories/Implement/ContentRepositoryBase.cs
+++ b/src/Umbraco.Core/Persistence/Repositories/Implement/ContentRepositoryBase.cs
@@ -9,6 +9,7 @@ using Umbraco.Core.Composing;
using Umbraco.Core.Events;
using Umbraco.Core.Logging;
using Umbraco.Core.Models;
+using Umbraco.Core.Models.Editors;
using Umbraco.Core.Models.Entities;
using Umbraco.Core.Persistence.DatabaseModelDefinitions;
using Umbraco.Core.Persistence.Dtos;
@@ -24,26 +25,48 @@ namespace Umbraco.Core.Persistence.Repositories.Implement
internal sealed class ContentRepositoryBase
{
///
+ ///
/// This is used for unit tests ONLY
///
public static bool ThrowOnWarning = false;
}
internal abstract class ContentRepositoryBase : NPocoRepositoryBase, IContentRepository
- where TEntity : class, IUmbracoEntity
+ where TEntity : class, IContentBase
where TRepository : class, IRepository
{
- protected ContentRepositoryBase(IScopeAccessor scopeAccessor, AppCaches cache, ILanguageRepository languageRepository, ILogger logger)
+ private readonly Lazy _propertyEditors;
+ private readonly DataValueReferenceFactoryCollection _dataValueReferenceFactories;
+
+ ///
+ ///
+ ///
+ ///
+ ///
+ ///
+ ///
+ ///
+ /// Lazy property value collection - must be lazy because we have a circular dependency since some property editors require services, yet these services require property editors
+ ///
+ protected ContentRepositoryBase(IScopeAccessor scopeAccessor, AppCaches cache, ILogger logger,
+ ILanguageRepository languageRepository, IRelationRepository relationRepository, IRelationTypeRepository relationTypeRepository,
+ Lazy propertyEditors, DataValueReferenceFactoryCollection dataValueReferenceFactories)
: base(scopeAccessor, cache, logger)
{
LanguageRepository = languageRepository;
+ RelationRepository = relationRepository;
+ RelationTypeRepository = relationTypeRepository;
+ _propertyEditors = propertyEditors;
+ _dataValueReferenceFactories = dataValueReferenceFactories;
}
protected abstract TRepository This { get; }
protected ILanguageRepository LanguageRepository { get; }
+ protected IRelationRepository RelationRepository { get; }
+ protected IRelationTypeRepository RelationTypeRepository { get; }
- protected PropertyEditorCollection PropertyEditors => Current.PropertyEditors; // TODO: inject
+ protected PropertyEditorCollection PropertyEditors => _propertyEditors.Value;
#region Versions
@@ -797,5 +820,56 @@ namespace Umbraco.Core.Persistence.Repositories.Implement
}
#endregion
+
+ protected void PersistRelations(TEntity entity)
+ {
+ // Get all references from our core built in DataEditors/Property Editors
+ // Along with seeing if deverlopers want to collect additional references from the DataValueReferenceFactories collection
+ var trackedRelations = new List();
+ trackedRelations.AddRange(_dataValueReferenceFactories.GetAllReferences(entity.Properties, PropertyEditors));
+
+ //First delete all auto-relations for this entity
+ RelationRepository.DeleteByParent(entity.Id, Constants.Conventions.RelationTypes.AutomaticRelationTypes);
+
+ if (trackedRelations.Count == 0) return;
+
+ trackedRelations = trackedRelations.Distinct().ToList();
+ var udiToGuids = trackedRelations.Select(x => x.Udi as GuidUdi)
+ .ToDictionary(x => (Udi)x, x => x.Guid);
+
+ //lookup in the DB all INT ids for the GUIDs and chuck into a dictionary
+ var keyToIds = Database.Fetch(Sql().Select(x => x.NodeId, x => x.UniqueId).From().WhereIn(x => x.UniqueId, udiToGuids.Values))
+ .ToDictionary(x => x.UniqueId, x => x.NodeId);
+
+ var allRelationTypes = RelationTypeRepository.GetMany(Array.Empty())
+ .ToDictionary(x => x.Alias, x => x);
+
+ var toSave = trackedRelations.Select(rel =>
+ {
+ if (!allRelationTypes.TryGetValue(rel.RelationTypeAlias, out var relationType))
+ throw new InvalidOperationException($"The relation type {rel.RelationTypeAlias} does not exist");
+
+ if (!udiToGuids.TryGetValue(rel.Udi, out var guid))
+ return null; // This shouldn't happen!
+
+ if (!keyToIds.TryGetValue(guid, out var id))
+ return null; // This shouldn't happen!
+
+ return new Relation(entity.Id, id, relationType);
+ }).WhereNotNull();
+
+ // Save bulk relations
+ RelationRepository.Save(toSave);
+
+ }
+
+ private class NodeIdKey
+ {
+ [Column("id")]
+ public int NodeId { get; set; }
+
+ [Column("uniqueId")]
+ public Guid UniqueId { get; set; }
+ }
}
}
diff --git a/src/Umbraco.Core/Persistence/Repositories/Implement/ContentTypeRepositoryBase.cs b/src/Umbraco.Core/Persistence/Repositories/Implement/ContentTypeRepositoryBase.cs
index 6385482686..6f714ff187 100644
--- a/src/Umbraco.Core/Persistence/Repositories/Implement/ContentTypeRepositoryBase.cs
+++ b/src/Umbraco.Core/Persistence/Repositories/Implement/ContentTypeRepositoryBase.cs
@@ -16,7 +16,6 @@ using Umbraco.Core.Persistence.Factories;
using Umbraco.Core.Persistence.Querying;
using Umbraco.Core.Scoping;
using Umbraco.Core.Services;
-using static Umbraco.Core.Persistence.NPocoSqlExtensions.Statics;
namespace Umbraco.Core.Persistence.Repositories.Implement
{
@@ -506,7 +505,7 @@ AND umbracoNode.id <> @id",
///
/// Corrects the property type variations for the given entity
/// to make sure the property type variation is compatible with the
- /// variation set on the entity itself.
+ /// variation set on the entity itself.
///
/// Entity to correct properties for
private void CorrectPropertyTypeVariations(IContentTypeComposition entity)
@@ -754,7 +753,7 @@ AND umbracoNode.id <> @id",
//we don't need to move the names! this is because we always keep the invariant names with the name of the default language.
//however, if we were to move names, we could do this: BUT this doesn't work with SQLCE, for that we'd have to update row by row :(
- // if we want these SQL statements back, look into GIT history
+ // if we want these SQL statements back, look into GIT history
}
}
@@ -1033,7 +1032,7 @@ AND umbracoNode.id <> @id",
//keep track of this node/lang to mark or unmark a culture as edited
var editedLanguageVersions = new Dictionary<(int nodeId, int? langId), bool>();
- //keep track of which node to mark or unmark as edited
+ //keep track of which node to mark or unmark as edited
var editedDocument = new Dictionary();
var nodeId = -1;
var propertyTypeId = -1;
@@ -1324,6 +1323,17 @@ WHERE {Constants.DatabaseSchema.Tables.Content}.nodeId IN (@ids) AND cmsContentT
return Database.ExecuteScalar(sql) > 0;
}
+ ///
+ /// Returns true or false depending on whether content nodes have been created based on the provided content type id.
+ ///
+ public bool HasContentNodes(int id)
+ {
+ var sql = new Sql(
+ $"SELECT CASE WHEN EXISTS (SELECT * FROM {Constants.DatabaseSchema.Tables.Content} WHERE contentTypeId = @id) THEN 1 ELSE 0 END",
+ new { id });
+ return Database.ExecuteScalar(sql) == 1;
+ }
+
protected override IEnumerable GetDeleteClauses()
{
// in theory, services should have ensured that content items of the given content type
diff --git a/src/Umbraco.Core/Persistence/Repositories/Implement/DocumentBlueprintRepository.cs b/src/Umbraco.Core/Persistence/Repositories/Implement/DocumentBlueprintRepository.cs
index d137d7ac76..e150b2e632 100644
--- a/src/Umbraco.Core/Persistence/Repositories/Implement/DocumentBlueprintRepository.cs
+++ b/src/Umbraco.Core/Persistence/Repositories/Implement/DocumentBlueprintRepository.cs
@@ -2,6 +2,7 @@
using Umbraco.Core.Cache;
using Umbraco.Core.Configuration.UmbracoSettings;
using Umbraco.Core.Logging;
+using Umbraco.Core.PropertyEditors;
using Umbraco.Core.Scoping;
namespace Umbraco.Core.Persistence.Repositories.Implement
@@ -17,8 +18,10 @@ namespace Umbraco.Core.Persistence.Repositories.Implement
///
internal class DocumentBlueprintRepository : DocumentRepository, IDocumentBlueprintRepository
{
- public DocumentBlueprintRepository(IScopeAccessor scopeAccessor, AppCaches appCaches, ILogger logger, IContentTypeRepository contentTypeRepository, ITemplateRepository templateRepository, ITagRepository tagRepository, ILanguageRepository languageRepository)
- : base(scopeAccessor, appCaches, logger, contentTypeRepository, templateRepository, tagRepository, languageRepository)
+ public DocumentBlueprintRepository(IScopeAccessor scopeAccessor, AppCaches appCaches, ILogger logger,
+ IContentTypeRepository contentTypeRepository, ITemplateRepository templateRepository, ITagRepository tagRepository, ILanguageRepository languageRepository, IRelationRepository relationRepository, IRelationTypeRepository relationTypeRepository,
+ Lazy propertyEditorCollection, DataValueReferenceFactoryCollection dataValueReferenceFactories)
+ : base(scopeAccessor, appCaches, logger, contentTypeRepository, templateRepository, tagRepository, languageRepository, relationRepository, relationTypeRepository, propertyEditorCollection, dataValueReferenceFactories)
{
}
diff --git a/src/Umbraco.Core/Persistence/Repositories/Implement/DocumentRepository.cs b/src/Umbraco.Core/Persistence/Repositories/Implement/DocumentRepository.cs
index dd9c7c93e5..ccfa8209fb 100644
--- a/src/Umbraco.Core/Persistence/Repositories/Implement/DocumentRepository.cs
+++ b/src/Umbraco.Core/Persistence/Repositories/Implement/DocumentRepository.cs
@@ -3,7 +3,6 @@ using System.Collections.Generic;
using System.Linq;
using NPoco;
using Umbraco.Core.Cache;
-using Umbraco.Core.Exceptions;
using Umbraco.Core.Logging;
using Umbraco.Core.Models;
using Umbraco.Core.Models.Entities;
@@ -12,6 +11,7 @@ using Umbraco.Core.Persistence.Dtos;
using Umbraco.Core.Persistence.Factories;
using Umbraco.Core.Persistence.Querying;
using Umbraco.Core.Persistence.SqlSyntax;
+using Umbraco.Core.PropertyEditors;
using Umbraco.Core.Scoping;
using Umbraco.Core.Services;
@@ -30,8 +30,23 @@ namespace Umbraco.Core.Persistence.Repositories.Implement
private readonly ContentByGuidReadRepository _contentByGuidReadRepository;
private readonly IScopeAccessor _scopeAccessor;
- public DocumentRepository(IScopeAccessor scopeAccessor, AppCaches appCaches, ILogger logger, IContentTypeRepository contentTypeRepository, ITemplateRepository templateRepository, ITagRepository tagRepository, ILanguageRepository languageRepository)
- : base(scopeAccessor, appCaches, languageRepository, logger)
+ ///
+ /// Constructor
+ ///
+ ///
+ ///
+ ///
+ ///
+ ///
+ ///
+ ///
+ ///
+ /// Lazy property value collection - must be lazy because we have a circular dependency since some property editors require services, yet these services require property editors
+ ///
+ public DocumentRepository(IScopeAccessor scopeAccessor, AppCaches appCaches, ILogger logger,
+ IContentTypeRepository contentTypeRepository, ITemplateRepository templateRepository, ITagRepository tagRepository, ILanguageRepository languageRepository, IRelationRepository relationRepository, IRelationTypeRepository relationTypeRepository,
+ Lazy propertyEditors, DataValueReferenceFactoryCollection dataValueReferenceFactories)
+ : base(scopeAccessor, appCaches, logger, languageRepository, relationRepository, relationTypeRepository, propertyEditors, dataValueReferenceFactories)
{
_contentTypeRepository = contentTypeRepository ?? throw new ArgumentNullException(nameof(contentTypeRepository));
_templateRepository = templateRepository ?? throw new ArgumentNullException(nameof(templateRepository));
@@ -229,6 +244,21 @@ namespace Umbraco.Core.Persistence.Repositories.Implement
return MapDtosToContent(Database.Fetch(sql), true);
}
+ // TODO: This method needs to return a readonly version of IContent! The content returned
+ // from this method does not contain all of the data required to re-persist it and if that
+ // is attempted some odd things will occur.
+ // Either we create an IContentReadOnly (which ultimately we should for vNext so we can
+ // differentiate between methods that return entities that can be re-persisted or not), or
+ // in the meantime to not break API compatibility, we can add a property to IContentBase
+ // (or go further and have it on IUmbracoEntity): "IsReadOnly" and if that is true we throw
+ // an exception if that entity is passed to a Save method.
+ // Ideally we return "Slim" versions of content for all sorts of methods here and in ContentService.
+ // Perhaps another non-breaking alternative is to have new services like IContentServiceReadOnly
+ // which can return IContentReadOnly.
+ // We have the ability with `MapDtosToContent` to reduce the amount of data looked up for a
+ // content item. Ideally for paged data that populates list views, these would be ultra slim
+ // content items, there's no reason to populate those with really anything apart from property data,
+ // but until we do something like the above, we can't do that since it would be breaking and unclear.
public override IEnumerable GetAllVersionsSlim(int nodeId, int skip, int take)
{
var sql = GetBaseQuery(QueryType.Many, false)
@@ -236,7 +266,9 @@ namespace Umbraco.Core.Persistence.Repositories.Implement
.OrderByDescending(x => x.Current)
.AndByDescending(x => x.VersionDate);
- return MapDtosToContent(Database.Fetch(sql), true, true).Skip(skip).Take(take);
+ return MapDtosToContent(Database.Fetch(sql), true,
+ // load bare minimum, need variants though since this is used to rollback with variants
+ false, false, false, true).Skip(skip).Take(take);
}
public override IContent GetVersion(int versionId)
@@ -468,6 +500,8 @@ namespace Umbraco.Core.Persistence.Repositories.Implement
ClearEntityTags(entity, _tagRepository);
}
+ PersistRelations(entity);
+
entity.ResetDirtyProperties();
// troubleshooting
@@ -671,6 +705,8 @@ namespace Umbraco.Core.Persistence.Repositories.Implement
ClearEntityTags(entity, _tagRepository);
}
+ PersistRelations(entity);
+
// TODO: note re. tags: explicitly unpublished entities have cleared tags, but masked or trashed entities *still* have tags in the db - so what?
entity.ResetDirtyProperties();
@@ -1056,7 +1092,12 @@ namespace Umbraco.Core.Persistence.Repositories.Implement
return base.ApplySystemOrdering(ref sql, ordering);
}
- private IEnumerable MapDtosToContent(List dtos, bool withCache = false, bool slim = false)
+ private IEnumerable MapDtosToContent(List dtos,
+ bool withCache = false,
+ bool loadProperties = true,
+ bool loadTemplates = true,
+ bool loadSchedule = true,
+ bool loadVariants = true)
{
var temps = new List>();
var contentTypes = new Dictionary();
@@ -1089,7 +1130,7 @@ namespace Umbraco.Core.Persistence.Repositories.Implement
var c = content[i] = ContentBaseFactory.BuildEntity(dto, contentType);
- if (!slim)
+ if (loadTemplates)
{
// need templates
var templateId = dto.DocumentVersionDto.TemplateId;
@@ -1114,49 +1155,71 @@ namespace Umbraco.Core.Persistence.Repositories.Implement
temps.Add(temp);
}
- if (!slim)
+ Dictionary templates = null;
+ if (loadTemplates)
{
// load all required templates in 1 query, and index
- var templates = _templateRepository.GetMany(templateIds.ToArray())
+ templates = _templateRepository.GetMany(templateIds.ToArray())
.ToDictionary(x => x.Id, x => x);
+ }
+ IDictionary properties = null;
+ if (loadProperties)
+ {
// load all properties for all documents from database in 1 query - indexed by version id
- var properties = GetPropertyCollections(temps);
- var schedule = GetContentSchedule(temps.Select(x => x.Content.Id).ToArray());
+ properties = GetPropertyCollections(temps);
+ }
- // assign templates and properties
- foreach (var temp in temps)
+ var schedule = GetContentSchedule(temps.Select(x => x.Content.Id).ToArray());
+
+ // assign templates and properties
+ foreach (var temp in temps)
+ {
+ if (loadTemplates)
{
// set the template ID if it matches an existing template
if (temp.Template1Id.HasValue && templates.ContainsKey(temp.Template1Id.Value))
temp.Content.TemplateId = temp.Template1Id;
if (temp.Template2Id.HasValue && templates.ContainsKey(temp.Template2Id.Value))
temp.Content.PublishTemplateId = temp.Template2Id;
+ }
+
- // set properties
+ // set properties
+ if (loadProperties)
+ {
if (properties.ContainsKey(temp.VersionId))
temp.Content.Properties = properties[temp.VersionId];
else
throw new InvalidOperationException($"No property data found for version: '{temp.VersionId}'.");
+ }
+ if (loadSchedule)
+ {
// load in the schedule
if (schedule.TryGetValue(temp.Content.Id, out var s))
temp.Content.ContentSchedule = s;
}
+
}
- // set variations, if varying
- temps = temps.Where(x => x.ContentType.VariesByCulture()).ToList();
- if (temps.Count > 0)
+ if (loadVariants)
{
- // load all variations for all documents from database, in one query
- var contentVariations = GetContentVariations(temps);
- var documentVariations = GetDocumentVariations(temps);
- foreach (var temp in temps)
- SetVariations(temp.Content, contentVariations, documentVariations);
+ // set variations, if varying
+ temps = temps.Where(x => x.ContentType.VariesByCulture()).ToList();
+ if (temps.Count > 0)
+ {
+ // load all variations for all documents from database, in one query
+ var contentVariations = GetContentVariations(temps);
+ var documentVariations = GetDocumentVariations(temps);
+ foreach (var temp in temps)
+ SetVariations(temp.Content, contentVariations, documentVariations);
+ }
}
+
- foreach(var c in content)
+
+ foreach (var c in content)
c.ResetDirtyProperties(false); // reset dirty initial properties (U4-1946)
return content;
diff --git a/src/Umbraco.Core/Persistence/Repositories/Implement/EntityRepository.cs b/src/Umbraco.Core/Persistence/Repositories/Implement/EntityRepository.cs
index 161db543ba..0eafebbfde 100644
--- a/src/Umbraco.Core/Persistence/Repositories/Implement/EntityRepository.cs
+++ b/src/Umbraco.Core/Persistence/Repositories/Implement/EntityRepository.cs
@@ -35,21 +35,33 @@ namespace Umbraco.Core.Persistence.Repositories.Implement
protected ISqlSyntaxProvider SqlSyntax => _scopeAccessor.AmbientScope.SqlContext.SqlSyntax;
#region Repository
-
- // get a page of entities
+
public IEnumerable GetPagedResultsByQuery(IQuery query, Guid objectType, long pageIndex, int pageSize, out long totalRecords,
IQuery filter, Ordering ordering)
{
- var isContent = objectType == Constants.ObjectTypes.Document || objectType == Constants.ObjectTypes.DocumentBlueprint;
- var isMedia = objectType == Constants.ObjectTypes.Media;
- var isMember = objectType == Constants.ObjectTypes.Member;
+ return GetPagedResultsByQuery(query, new[] { objectType }, pageIndex, pageSize, out totalRecords, filter, ordering);
+ }
- var sql = GetBaseWhere(isContent, isMedia, isMember, false, x =>
+ // get a page of entities
+ public IEnumerable GetPagedResultsByQuery(IQuery query, Guid[] objectTypes, long pageIndex, int pageSize, out long totalRecords,
+ IQuery filter, Ordering ordering, Action> sqlCustomization = null)
+ {
+ var isContent = objectTypes.Any(objectType => objectType == Constants.ObjectTypes.Document || objectType == Constants.ObjectTypes.DocumentBlueprint);
+ var isMedia = objectTypes.Any(objectType => objectType == Constants.ObjectTypes.Media);
+ var isMember = objectTypes.Any(objectType => objectType == Constants.ObjectTypes.Member);
+
+ var sql = GetBaseWhere(isContent, isMedia, isMember, false, s =>
{
- if (filter == null) return;
- foreach (var filterClause in filter.GetWhereClauses())
- x.Where(filterClause.Item1, filterClause.Item2);
- }, objectType);
+ sqlCustomization?.Invoke(s);
+
+ if (filter != null)
+ {
+ foreach (var filterClause in filter.GetWhereClauses())
+ s.Where(filterClause.Item1, filterClause.Item2);
+ }
+
+
+ }, objectTypes);
ordering = ordering ?? Ordering.ByDefault();
@@ -70,35 +82,13 @@ namespace Umbraco.Core.Persistence.Repositories.Implement
// for content we must query for ContentEntityDto entities to produce the correct culture variant entity names
var pageIndexToFetch = pageIndex + 1;
IEnumerable dtos;
- if(isContent)
- {
- var page = Database.Page(pageIndexToFetch, pageSize, sql);
- dtos = page.Items;
- totalRecords = page.TotalItems;
- }
- else if (isMedia)
- {
- var page = Database.Page(pageIndexToFetch, pageSize, sql);
- dtos = page.Items;
- totalRecords = page.TotalItems;
- }
- else if (isMember)
- {
- var page = Database.Page(pageIndexToFetch, pageSize, sql);
- dtos = page.Items;
- totalRecords = page.TotalItems;
- }
- else
- {
- var page = Database.Page(pageIndexToFetch, pageSize, sql);
- dtos = page.Items;
- totalRecords = page.TotalItems;
- }
+ var page = Database.Page(pageIndexToFetch, pageSize, sql);
+ dtos = page.Items;
+ totalRecords = page.TotalItems;
- var entities = dtos.Select(x => BuildEntity(isContent, isMedia, isMember, x)).ToArray();
+ var entities = dtos.Select(BuildEntity).ToArray();
- if (isContent)
- BuildVariants(entities.Cast());
+ BuildVariants(entities.OfType());
return entities;
}
@@ -107,7 +97,7 @@ namespace Umbraco.Core.Persistence.Repositories.Implement
{
var sql = GetBaseWhere(false, false, false, false, key);
var dto = Database.FirstOrDefault(sql);
- return dto == null ? null : BuildEntity(false, false, false, dto);
+ return dto == null ? null : BuildEntity(dto);
}
@@ -116,7 +106,7 @@ namespace Umbraco.Core.Persistence.Repositories.Implement
//isContent is going to return a 1:M result now with the variants so we need to do different things
if (isContent)
{
- var cdtos = Database.Fetch(sql);
+ var cdtos = Database.Fetch(sql);
return cdtos.Count == 0 ? null : BuildVariants(BuildDocumentEntity(cdtos[0]));
}
@@ -127,7 +117,7 @@ namespace Umbraco.Core.Persistence.Repositories.Implement
if (dto == null) return null;
- var entity = BuildEntity(false, isMedia, isMember, dto);
+ var entity = BuildEntity(dto);
return entity;
}
@@ -146,7 +136,7 @@ namespace Umbraco.Core.Persistence.Repositories.Implement
{
var sql = GetBaseWhere(false, false, false, false, id);
var dto = Database.FirstOrDefault(sql);
- return dto == null ? null : BuildEntity(false, false, false, dto);
+ return dto == null ? null : BuildEntity(dto);
}
public IEntitySlim Get(int id, Guid objectTypeId)
@@ -178,7 +168,7 @@ namespace Umbraco.Core.Persistence.Repositories.Implement
//isContent is going to return a 1:M result now with the variants so we need to do different things
if (isContent)
{
- var cdtos = Database.Fetch(sql);
+ var cdtos = Database.Fetch(sql);
return cdtos.Count == 0
? Enumerable.Empty()
@@ -189,7 +179,7 @@ namespace Umbraco.Core.Persistence.Repositories.Implement
? (IEnumerable)Database.Fetch(sql)
: Database.Fetch(sql);
- var entities = dtos.Select(x => BuildEntity(false, isMedia, isMember, x)).ToArray();
+ var entities = dtos.Select(BuildEntity).ToArray();
return entities;
}
@@ -233,7 +223,7 @@ namespace Umbraco.Core.Persistence.Repositories.Implement
var sql = translator.Translate();
sql = AddGroupBy(false, false, false, sql, true);
var dtos = Database.Fetch(sql);
- return dtos.Select(x => BuildEntity(false, false, false, x)).ToList();
+ return dtos.Select(BuildEntity).ToList();
}
public IEnumerable GetByQuery(IQuery query, Guid objectType)
@@ -242,7 +232,7 @@ namespace Umbraco.Core.Persistence.Repositories.Implement
var isMedia = objectType == Constants.ObjectTypes.Media;
var isMember = objectType == Constants.ObjectTypes.Member;
- var sql = GetBaseWhere(isContent, isMedia, isMember, false, null, objectType);
+ var sql = GetBaseWhere(isContent, isMedia, isMember, false, null, new[] { objectType });
var translator = new SqlTranslator(sql, query);
sql = translator.Translate();
@@ -356,14 +346,14 @@ namespace Umbraco.Core.Persistence.Repositories.Implement
// gets the full sql for a given object type, with a given filter
protected Sql GetFullSqlForEntityType(bool isContent, bool isMedia, bool isMember, Guid objectType, Action> filter)
{
- var sql = GetBaseWhere(isContent, isMedia, isMember, false, filter, objectType);
+ var sql = GetBaseWhere(isContent, isMedia, isMember, false, filter, new[] { objectType });
return AddGroupBy(isContent, isMedia, isMember, sql, true);
}
// gets the base SELECT + FROM [+ filter] sql
// always from the 'current' content version
protected Sql GetBase(bool isContent, bool isMedia, bool isMember, Action> filter, bool isCount = false)
- {
+ {
var sql = Sql();
if (isCount)
@@ -401,15 +391,15 @@ namespace Umbraco.Core.Persistence.Repositories.Implement
if (isContent || isMedia || isMember)
{
sql
- .InnerJoin().On((left, right) => left.NodeId == right.NodeId && right.Current)
- .InnerJoin().On((left, right) => left.NodeId == right.NodeId)
- .InnerJoin().On((left, right) => left.ContentTypeId == right.NodeId);
+ .LeftJoin().On((left, right) => left.NodeId == right.NodeId && right.Current)
+ .LeftJoin().On((left, right) => left.NodeId == right.NodeId)
+ .LeftJoin().On((left, right) => left.ContentTypeId == right.NodeId);
}
if (isContent)
{
sql
- .InnerJoin().On((left, right) => left.NodeId == right.NodeId);
+ .LeftJoin().On((left, right) => left.NodeId == right.NodeId);
}
if (isMedia)
@@ -433,10 +423,14 @@ namespace Umbraco.Core.Persistence.Repositories.Implement
// gets the base SELECT + FROM [+ filter] + WHERE sql
// for a given object type, with a given filter
- protected Sql GetBaseWhere(bool isContent, bool isMedia, bool isMember, bool isCount, Action> filter, Guid objectType)
+ protected Sql GetBaseWhere(bool isContent, bool isMedia, bool isMember, bool isCount, Action> filter, Guid[] objectTypes)
{
- return GetBase(isContent, isMedia, isMember, filter, isCount)
- .Where(x => x.NodeObjectType == objectType);
+ var sql = GetBase(isContent, isMedia, isMember, filter, isCount);
+ if (objectTypes.Length > 0)
+ {
+ sql.WhereIn(x => x.NodeObjectType, objectTypes);
+ }
+ return sql;
}
// gets the base SELECT + FROM + WHERE sql
@@ -510,8 +504,19 @@ namespace Umbraco.Core.Persistence.Repositories.Implement
if (sql == null) throw new ArgumentNullException(nameof(sql));
if (ordering == null) throw new ArgumentNullException(nameof(ordering));
- // TODO: although this works for name, it probably doesn't work for others without an alias of some sort
- var orderBy = ordering.OrderBy;
+ // TODO: although the default ordering string works for name, it wont work for others without a table or an alias of some sort
+ // As more things are attempted to be sorted we'll prob have to add more expressions here
+ string orderBy;
+ switch (ordering.OrderBy.ToUpperInvariant())
+ {
+ case "PATH":
+ orderBy = SqlSyntax.GetQuotedColumn(NodeDto.TableName, "path");
+ break;
+
+ default:
+ orderBy = ordering.OrderBy;
+ break;
+ }
if (ordering.Direction == Direction.Ascending)
sql.OrderBy(orderBy);
@@ -524,9 +529,17 @@ namespace Umbraco.Core.Persistence.Repositories.Implement
#region Classes
///
- /// The DTO used to fetch results for a content item with its variation info
+ /// The DTO used to fetch results for a generic content item which could be either a document, media or a member
///
- private class ContentEntityDto : BaseDto
+ private class GenericContentEntityDto : DocumentEntityDto
+ {
+ public string MediaPath { get; set; }
+ }
+
+ ///
+ /// The DTO used to fetch results for a document item with its variation info
+ ///
+ private class DocumentEntityDto : BaseDto
{
public ContentVariation Variations { get; set; }
@@ -534,11 +547,17 @@ namespace Umbraco.Core.Persistence.Repositories.Implement
public bool Edited { get; set; }
}
+ ///
+ /// The DTO used to fetch results for a media item with its media path info
+ ///
private class MediaEntityDto : BaseDto
{
public string MediaPath { get; set; }
}
+ ///
+ /// The DTO used to fetch results for a member item
+ ///
private class MemberEntityDto : BaseDto
{
}
@@ -589,13 +608,13 @@ namespace Umbraco.Core.Persistence.Repositories.Implement
#region Factory
- private EntitySlim BuildEntity(bool isContent, bool isMedia, bool isMember, BaseDto dto)
+ private EntitySlim BuildEntity(BaseDto dto)
{
- if (isContent)
+ if (dto.NodeObjectType == Constants.ObjectTypes.Document)
return BuildDocumentEntity(dto);
- if (isMedia)
+ if (dto.NodeObjectType == Constants.ObjectTypes.Media)
return BuildMediaEntity(dto);
- if (isMember)
+ if (dto.NodeObjectType == Constants.ObjectTypes.Member)
return BuildMemberEntity(dto);
// EntitySlim does not track changes
@@ -650,7 +669,7 @@ namespace Umbraco.Core.Persistence.Repositories.Implement
var entity = new DocumentEntitySlim();
BuildContentEntity(entity, dto);
- if (dto is ContentEntityDto contentDto)
+ if (dto is DocumentEntityDto contentDto)
{
// fill in the invariant info
entity.Edited = contentDto.Edited;
diff --git a/src/Umbraco.Core/Persistence/Repositories/Implement/MacroRepository.cs b/src/Umbraco.Core/Persistence/Repositories/Implement/MacroRepository.cs
index f0044e225d..1f0b45614b 100644
--- a/src/Umbraco.Core/Persistence/Repositories/Implement/MacroRepository.cs
+++ b/src/Umbraco.Core/Persistence/Repositories/Implement/MacroRepository.cs
@@ -40,7 +40,7 @@ namespace Umbraco.Core.Persistence.Repositories.Implement
if (macroDto == null)
return null;
-
+
var entity = MacroFactory.BuildEntity(macroDto);
// reset dirty initial properties (U4-1946)
@@ -153,7 +153,6 @@ namespace Umbraco.Core.Persistence.Repositories.Implement
protected override void PersistUpdatedItem(IMacro entity)
{
entity.UpdatingEntity();
-;
var dto = MacroFactory.BuildDto(entity);
Database.Update(dto);
diff --git a/src/Umbraco.Core/Persistence/Repositories/Implement/MediaRepository.cs b/src/Umbraco.Core/Persistence/Repositories/Implement/MediaRepository.cs
index 3947773a76..081efcfdf6 100644
--- a/src/Umbraco.Core/Persistence/Repositories/Implement/MediaRepository.cs
+++ b/src/Umbraco.Core/Persistence/Repositories/Implement/MediaRepository.cs
@@ -12,6 +12,7 @@ using Umbraco.Core.Models.Entities;
using Umbraco.Core.Persistence.Dtos;
using Umbraco.Core.Persistence.Factories;
using Umbraco.Core.Persistence.Querying;
+using Umbraco.Core.PropertyEditors;
using Umbraco.Core.Scoping;
using Umbraco.Core.Services;
using static Umbraco.Core.Persistence.NPocoSqlExtensions.Statics;
@@ -27,8 +28,9 @@ namespace Umbraco.Core.Persistence.Repositories.Implement
private readonly ITagRepository _tagRepository;
private readonly MediaByGuidReadRepository _mediaByGuidReadRepository;
- public MediaRepository(IScopeAccessor scopeAccessor, AppCaches cache, ILogger logger, IMediaTypeRepository mediaTypeRepository, ITagRepository tagRepository, ILanguageRepository languageRepository)
- : base(scopeAccessor, cache, languageRepository, logger)
+ public MediaRepository(IScopeAccessor scopeAccessor, AppCaches cache, ILogger logger, IMediaTypeRepository mediaTypeRepository, ITagRepository tagRepository, ILanguageRepository languageRepository, IRelationRepository relationRepository, IRelationTypeRepository relationTypeRepository,
+ Lazy propertyEditorCollection, DataValueReferenceFactoryCollection dataValueReferenceFactories)
+ : base(scopeAccessor, cache, logger, languageRepository, relationRepository, relationTypeRepository, propertyEditorCollection, dataValueReferenceFactories)
{
_mediaTypeRepository = mediaTypeRepository ?? throw new ArgumentNullException(nameof(mediaTypeRepository));
_tagRepository = tagRepository ?? throw new ArgumentNullException(nameof(tagRepository));
@@ -228,7 +230,7 @@ namespace Umbraco.Core.Persistence.Repositories.Implement
entity.SanitizeEntityPropertiesForXmlStorage();
// create the dto
- var dto = ContentBaseFactory.BuildDto(entity);
+ var dto = ContentBaseFactory.BuildDto(PropertyEditors, entity);
// derive path and level from parent
var parent = GetParentNodeDto(entity.ParentId);
@@ -287,6 +289,8 @@ namespace Umbraco.Core.Persistence.Repositories.Implement
// set tags
SetEntityTags(entity, _tagRepository);
+ PersistRelations(entity);
+
OnUowRefreshedEntity(new ScopedEntityEventArgs(AmbientScope, entity));
entity.ResetDirtyProperties();
@@ -317,7 +321,7 @@ namespace Umbraco.Core.Persistence.Repositories.Implement
}
// create the dto
- var dto = ContentBaseFactory.BuildDto(entity);
+ var dto = ContentBaseFactory.BuildDto(PropertyEditors, entity);
// update the node dto
var nodeDto = dto.ContentDto.NodeDto;
@@ -343,6 +347,8 @@ namespace Umbraco.Core.Persistence.Repositories.Implement
SetEntityTags(entity, _tagRepository);
+ PersistRelations(entity);
+
OnUowRefreshedEntity(new ScopedEntityEventArgs(AmbientScope, entity));
entity.ResetDirtyProperties();
@@ -542,6 +548,6 @@ namespace Umbraco.Core.Persistence.Repositories.Implement
media.ResetDirtyProperties(false);
return media;
}
-
+
}
}
diff --git a/src/Umbraco.Core/Persistence/Repositories/Implement/MemberRepository.cs b/src/Umbraco.Core/Persistence/Repositories/Implement/MemberRepository.cs
index 892122dff9..42e7d1c32f 100644
--- a/src/Umbraco.Core/Persistence/Repositories/Implement/MemberRepository.cs
+++ b/src/Umbraco.Core/Persistence/Repositories/Implement/MemberRepository.cs
@@ -10,6 +10,7 @@ using Umbraco.Core.Models.Entities;
using Umbraco.Core.Persistence.Dtos;
using Umbraco.Core.Persistence.Factories;
using Umbraco.Core.Persistence.Querying;
+using Umbraco.Core.PropertyEditors;
using Umbraco.Core.Scoping;
using Umbraco.Core.Services;
using static Umbraco.Core.Persistence.NPocoSqlExtensions.Statics;
@@ -25,8 +26,10 @@ namespace Umbraco.Core.Persistence.Repositories.Implement
private readonly ITagRepository _tagRepository;
private readonly IMemberGroupRepository _memberGroupRepository;
- public MemberRepository(IScopeAccessor scopeAccessor, AppCaches cache, ILogger logger, IMemberTypeRepository memberTypeRepository, IMemberGroupRepository memberGroupRepository, ITagRepository tagRepository, ILanguageRepository languageRepository)
- : base(scopeAccessor, cache, languageRepository, logger)
+ public MemberRepository(IScopeAccessor scopeAccessor, AppCaches cache, ILogger logger,
+ IMemberTypeRepository memberTypeRepository, IMemberGroupRepository memberGroupRepository, ITagRepository tagRepository, ILanguageRepository languageRepository, IRelationRepository relationRepository, IRelationTypeRepository relationTypeRepository,
+ Lazy propertyEditors, DataValueReferenceFactoryCollection dataValueReferenceFactories)
+ : base(scopeAccessor, cache, logger, languageRepository, relationRepository, relationTypeRepository, propertyEditors, dataValueReferenceFactories)
{
_memberTypeRepository = memberTypeRepository ?? throw new ArgumentNullException(nameof(memberTypeRepository));
_tagRepository = tagRepository ?? throw new ArgumentNullException(nameof(tagRepository));
@@ -321,6 +324,8 @@ namespace Umbraco.Core.Persistence.Repositories.Implement
SetEntityTags(entity, _tagRepository);
+ PersistRelations(entity);
+
OnUowRefreshedEntity(new ScopedEntityEventArgs(AmbientScope, entity));
entity.ResetDirtyProperties();
@@ -386,6 +391,8 @@ namespace Umbraco.Core.Persistence.Repositories.Implement
SetEntityTags(entity, _tagRepository);
+ PersistRelations(entity);
+
OnUowRefreshedEntity(new ScopedEntityEventArgs(AmbientScope, entity));
entity.ResetDirtyProperties();
diff --git a/src/Umbraco.Core/Persistence/Repositories/Implement/RelationRepository.cs b/src/Umbraco.Core/Persistence/Repositories/Implement/RelationRepository.cs
index 4b4af505b8..56a6336f75 100644
--- a/src/Umbraco.Core/Persistence/Repositories/Implement/RelationRepository.cs
+++ b/src/Umbraco.Core/Persistence/Repositories/Implement/RelationRepository.cs
@@ -6,10 +6,14 @@ using Umbraco.Core.Cache;
using Umbraco.Core.Logging;
using Umbraco.Core.Models;
using Umbraco.Core.Models.Entities;
+using Umbraco.Core.Persistence.DatabaseModelDefinitions;
using Umbraco.Core.Persistence.Dtos;
using Umbraco.Core.Persistence.Factories;
using Umbraco.Core.Persistence.Querying;
+using Umbraco.Core.Persistence.SqlSyntax;
using Umbraco.Core.Scoping;
+using Umbraco.Core.Services;
+using static Umbraco.Core.Persistence.NPocoSqlExtensions.Statics;
namespace Umbraco.Core.Persistence.Repositories.Implement
{
@@ -19,11 +23,13 @@ namespace Umbraco.Core.Persistence.Repositories.Implement
internal class RelationRepository : NPocoRepositoryBase, IRelationRepository
{
private readonly IRelationTypeRepository _relationTypeRepository;
+ private readonly IEntityRepository _entityRepository;
- public RelationRepository(IScopeAccessor scopeAccessor, ILogger logger, IRelationTypeRepository relationTypeRepository)
+ public RelationRepository(IScopeAccessor scopeAccessor, ILogger logger, IRelationTypeRepository relationTypeRepository, IEntityRepository entityRepository)
: base(scopeAccessor, AppCaches.NoCache, logger)
{
_relationTypeRepository = relationTypeRepository;
+ _entityRepository = entityRepository;
}
#region Overrides of RepositoryBase
@@ -39,10 +45,9 @@ namespace Umbraco.Core.Persistence.Repositories.Implement
var relationType = _relationTypeRepository.Get(dto.RelationType);
if (relationType == null)
- throw new Exception(string.Format("RelationType with Id: {0} doesn't exist", dto.RelationType));
+ throw new InvalidOperationException(string.Format("RelationType with Id: {0} doesn't exist", dto.RelationType));
- var factory = new RelationFactory(relationType);
- return DtoToEntity(dto, factory);
+ return DtoToEntity(dto, relationType);
}
protected override IEnumerable PerformGetAll(params int[] ids)
@@ -67,26 +72,17 @@ namespace Umbraco.Core.Persistence.Repositories.Implement
private IEnumerable DtosToEntities(IEnumerable dtos)
{
- // in most cases, the relation type will be the same for all of them,
- // plus we've ordered the relations by type, so try to allocate as few
- // factories as possible - bearing in mind that relation types are cached
- RelationFactory factory = null;
- var relationTypeId = -1;
+ //NOTE: This is N+1, BUT ALL relation types are cached so shouldn't matter
- return dtos.Select(x =>
- {
- if (relationTypeId != x.RelationType)
- factory = new RelationFactory(_relationTypeRepository.Get(relationTypeId = x.RelationType));
- return DtoToEntity(x, factory);
- }).ToList();
+ return dtos.Select(x => DtoToEntity(x, _relationTypeRepository.Get(x.RelationType))).ToList();
}
- private static IRelation DtoToEntity(RelationDto dto, RelationFactory factory)
+ private static IRelation DtoToEntity(RelationDto dto, IRelationType relationType)
{
- var entity = factory.BuildEntity(dto);
+ var entity = RelationFactory.BuildEntity(dto, relationType);
// reset dirty initial properties (U4-1946)
- ((BeingDirtyBase)entity).ResetDirtyProperties(false);
+ entity.ResetDirtyProperties(false);
return entity;
}
@@ -97,14 +93,18 @@ namespace Umbraco.Core.Persistence.Repositories.Implement
protected override Sql GetBaseQuery(bool isCount)
{
- var sql = Sql();
+ if (isCount)
+ {
+ return Sql().SelectCount().From();
+ }
- sql = isCount
- ? sql.SelectCount()
- : sql.Select();
+ var sql = Sql().Select()
+ .AndSelect("uchild", x => Alias(x.NodeObjectType, "childObjectType"))
+ .AndSelect("uparent", x => Alias(x.NodeObjectType, "parentObjectType"))
+ .From()
+ .InnerJoin("uchild").On((rel, node) => rel.ChildId == node.NodeId, aliasRight: "uchild")
+ .InnerJoin("uparent").On((rel, node) => rel.ParentId == node.NodeId, aliasRight: "uparent");
- sql
- .From();
return sql;
}
@@ -136,11 +136,12 @@ namespace Umbraco.Core.Persistence.Repositories.Implement
{
entity.AddingEntity();
- var factory = new RelationFactory(entity.RelationType);
- var dto = factory.BuildDto(entity);
+ var dto = RelationFactory.BuildDto(entity);
var id = Convert.ToInt32(Database.Insert(dto));
+
entity.Id = id;
+ PopulateObjectTypes(entity);
entity.ResetDirtyProperties();
}
@@ -149,13 +150,192 @@ namespace Umbraco.Core.Persistence.Repositories.Implement
{
entity.UpdatingEntity();
- var factory = new RelationFactory(entity.RelationType);
- var dto = factory.BuildDto(entity);
+ var dto = RelationFactory.BuildDto(entity);
Database.Update(dto);
+ PopulateObjectTypes(entity);
+
entity.ResetDirtyProperties();
}
#endregion
+
+ ///
+ /// Used for joining the entity query with relations for the paging methods
+ ///
+ ///
+ private void SqlJoinRelations(Sql sql)
+ {
+ // add left joins for relation tables (this joins on both child or parent, so beware that this will normally return entities for
+ // both sides of the relation type unless the IUmbracoEntity query passed in filters one side out).
+ sql.LeftJoin().On((left, right) => left.NodeId == right.ChildId || left.NodeId == right.ParentId);
+ sql.LeftJoin().On((left, right) => left.RelationType == right.Id);
+ }
+
+ public IEnumerable GetPagedParentEntitiesByChildId(int childId, long pageIndex, int pageSize, out long totalRecords, params Guid[] entityTypes)
+ {
+ // var contentObjectTypes = new[] { Constants.ObjectTypes.Document, Constants.ObjectTypes.Media, Constants.ObjectTypes.Member }
+ // we could pass in the contentObjectTypes so that the entity repository sql is configured to do full entity lookups so that we get the full data
+ // required to populate content, media or members, else we get the bare minimum data needed to populate an entity. BUT if we do this it
+ // means that the SQL is less efficient and returns data that is probably not needed for what we need this lookup for. For the time being we
+ // will just return the bare minimum entity data.
+
+ return _entityRepository.GetPagedResultsByQuery(Query(), entityTypes, pageIndex, pageSize, out totalRecords, null, null, sql =>
+ {
+ SqlJoinRelations(sql);
+
+ sql.Where(rel => rel.ChildId == childId);
+ sql.Where((rel, node) => rel.ParentId == childId || node.NodeId != childId);
+ });
+ }
+
+ public IEnumerable GetPagedChildEntitiesByParentId(int parentId, long pageIndex, int pageSize, out long totalRecords, params Guid[] entityTypes)
+ {
+ // var contentObjectTypes = new[] { Constants.ObjectTypes.Document, Constants.ObjectTypes.Media, Constants.ObjectTypes.Member }
+ // we could pass in the contentObjectTypes so that the entity repository sql is configured to do full entity lookups so that we get the full data
+ // required to populate content, media or members, else we get the bare minimum data needed to populate an entity. BUT if we do this it
+ // means that the SQL is less efficient and returns data that is probably not needed for what we need this lookup for. For the time being we
+ // will just return the bare minimum entity data.
+
+ return _entityRepository.GetPagedResultsByQuery(Query(), entityTypes, pageIndex, pageSize, out totalRecords, null, null, sql =>
+ {
+ SqlJoinRelations(sql);
+
+ sql.Where(rel => rel.ParentId == parentId);
+ sql.Where((rel, node) => rel.ChildId == parentId || node.NodeId != parentId);
+ });
+ }
+
+ public void Save(IEnumerable relations)
+ {
+ foreach (var hasIdentityGroup in relations.GroupBy(r => r.HasIdentity))
+ {
+ if (hasIdentityGroup.Key)
+ {
+ // Do updates, we can't really do a bulk update so this is still a 1 by 1 operation
+ // however we can bulk populate the object types. It might be possible to bulk update
+ // with SQL but would be pretty ugly and we're not really too worried about that for perf,
+ // it's the bulk inserts we care about.
+ var asArray = hasIdentityGroup.ToArray();
+ foreach (var relation in hasIdentityGroup)
+ {
+ relation.UpdatingEntity();
+ var dto = RelationFactory.BuildDto(relation);
+ Database.Update(dto);
+ }
+ PopulateObjectTypes(asArray);
+ }
+ else
+ {
+ // Do bulk inserts
+ var entitiesAndDtos = hasIdentityGroup.ToDictionary(
+ r => // key = entity
+ {
+ r.AddingEntity();
+ return r;
+ },
+ RelationFactory.BuildDto); // value = DTO
+
+ // Use NPoco's own InsertBulk command which will automatically re-populate the new Ids on the entities, our own
+ // BulkInsertRecords does not cater for this.
+ Database.InsertBulk(entitiesAndDtos.Values);
+
+ // All dtos now have IDs assigned
+ foreach (var de in entitiesAndDtos)
+ {
+ // re-assign ID to the entity
+ de.Key.Id = de.Value.Id;
+ }
+
+ PopulateObjectTypes(entitiesAndDtos.Keys.ToArray());
+ }
+ }
+ }
+
+ public IEnumerable GetPagedRelationsByQuery(IQuery query, long pageIndex, int pageSize, out long totalRecords, Ordering ordering)
+ {
+ var sql = GetBaseQuery(false);
+
+ if (ordering == null || ordering.IsEmpty)
+ ordering = Ordering.By(SqlSyntax.GetQuotedColumn(Constants.DatabaseSchema.Tables.Relation, "id"));
+
+ var translator = new SqlTranslator(sql, query);
+ sql = translator.Translate();
+
+ // apply ordering
+ ApplyOrdering(ref sql, ordering);
+
+ var pageIndexToFetch = pageIndex + 1;
+ var page = Database.Page(pageIndexToFetch, pageSize, sql);
+ var dtos = page.Items;
+ totalRecords = page.TotalItems;
+
+ var relTypes = _relationTypeRepository.GetMany(dtos.Select(x => x.RelationType).Distinct().ToArray())
+ .ToDictionary(x => x.Id, x => x);
+
+ var result = dtos.Select(r =>
+ {
+ if (!relTypes.TryGetValue(r.RelationType, out var relType))
+ throw new InvalidOperationException(string.Format("RelationType with Id: {0} doesn't exist", r.RelationType));
+ return DtoToEntity(r, relType);
+ }).ToList();
+
+ return result;
+ }
+
+
+ public void DeleteByParent(int parentId, params string[] relationTypeAliases)
+ {
+ var subQuery = Sql().Select(x => x.Id)
+ .From()
+ .InnerJoin().On(x => x.RelationType, x => x.Id)
+ .Where(x => x.ParentId == parentId);
+
+ if (relationTypeAliases.Length > 0)
+ {
+ subQuery.WhereIn(x => x.Alias, relationTypeAliases);
+ }
+
+ Database.Execute(Sql().Delete().WhereIn(x => x.Id, subQuery));
+ }
+
+ ///
+ /// Used to populate the object types after insert/update
+ ///
+ ///
+ private void PopulateObjectTypes(params IRelation[] entities)
+ {
+ var entityIds = entities.Select(x => x.ParentId).Concat(entities.Select(y => y.ChildId)).Distinct();
+
+ var nodes = Database.Fetch(Sql().Select().From()
+ .WhereIn(x => x.NodeId, entityIds))
+ .ToDictionary(x => x.NodeId, x => x.NodeObjectType);
+
+ foreach (var e in entities)
+ {
+ if (nodes.TryGetValue(e.ParentId, out var parentObjectType))
+ {
+ e.ParentObjectType = parentObjectType.GetValueOrDefault();
+ }
+ if (nodes.TryGetValue(e.ChildId, out var childObjectType))
+ {
+ e.ChildObjectType = childObjectType.GetValueOrDefault();
+ }
+ }
+ }
+
+ private void ApplyOrdering(ref Sql sql, Ordering ordering)
+ {
+ if (sql == null) throw new ArgumentNullException(nameof(sql));
+ if (ordering == null) throw new ArgumentNullException(nameof(ordering));
+
+ // TODO: although this works for name, it probably doesn't work for others without an alias of some sort
+ var orderBy = ordering.OrderBy;
+
+ if (ordering.Direction == Direction.Ascending)
+ sql.OrderBy(orderBy);
+ else
+ sql.OrderByDescending(orderBy);
+ }
}
}
diff --git a/src/Umbraco.Core/Persistence/Repositories/Implement/RelationTypeRepository.cs b/src/Umbraco.Core/Persistence/Repositories/Implement/RelationTypeRepository.cs
index 075d4aa769..623b55b6f8 100644
--- a/src/Umbraco.Core/Persistence/Repositories/Implement/RelationTypeRepository.cs
+++ b/src/Umbraco.Core/Persistence/Repositories/Implement/RelationTypeRepository.cs
@@ -134,7 +134,9 @@ namespace Umbraco.Core.Persistence.Repositories.Implement
protected override void PersistNewItem(IRelationType entity)
{
entity.AddingEntity();
-
+
+ CheckNullObjectTypeValues(entity);
+
var dto = RelationTypeFactory.BuildDto(entity);
var id = Convert.ToInt32(Database.Insert(dto));
@@ -146,7 +148,9 @@ namespace Umbraco.Core.Persistence.Repositories.Implement
protected override void PersistUpdatedItem(IRelationType entity)
{
entity.UpdatingEntity();
-
+
+ CheckNullObjectTypeValues(entity);
+
var dto = RelationTypeFactory.BuildDto(entity);
Database.Update(dto);
@@ -154,5 +158,13 @@ namespace Umbraco.Core.Persistence.Repositories.Implement
}
#endregion
+
+ private void CheckNullObjectTypeValues(IRelationType entity)
+ {
+ if (entity.ParentObjectType.HasValue && entity.ParentObjectType == Guid.Empty)
+ entity.ParentObjectType = null;
+ if (entity.ChildObjectType.HasValue && entity.ChildObjectType == Guid.Empty)
+ entity.ChildObjectType = null;
+ }
}
}
diff --git a/src/Umbraco.Core/Persistence/Repositories/Implement/TemplateRepository.cs b/src/Umbraco.Core/Persistence/Repositories/Implement/TemplateRepository.cs
index b348317989..2175780916 100644
--- a/src/Umbraco.Core/Persistence/Repositories/Implement/TemplateRepository.cs
+++ b/src/Umbraco.Core/Persistence/Repositories/Implement/TemplateRepository.cs
@@ -215,7 +215,6 @@ namespace Umbraco.Core.Persistence.Repositories.Implement
//Save updated entity to db
template.UpdateDate = DateTime.Now;
- ;
var dto = TemplateFactory.BuildDto(template, NodeObjectTypeId, templateDto.PrimaryKey);
Database.Update(dto.NodeDto);
diff --git a/src/Umbraco.Core/Persistence/Repositories/Implement/UserRepository.cs b/src/Umbraco.Core/Persistence/Repositories/Implement/UserRepository.cs
index 96abc37662..3be5102b83 100644
--- a/src/Umbraco.Core/Persistence/Repositories/Implement/UserRepository.cs
+++ b/src/Umbraco.Core/Persistence/Repositories/Implement/UserRepository.cs
@@ -557,6 +557,16 @@ ORDER BY colName";
}
}
+ // If userlogin or the email has changed then need to reset security stamp
+ if (changedCols.Contains("userLogin") || changedCols.Contains("userEmail"))
+ {
+ userDto.EmailConfirmedDate = null;
+ userDto.SecurityStampToken = entity.SecurityStamp = Guid.NewGuid().ToString();
+
+ changedCols.Add("emailConfirmedDate");
+ changedCols.Add("securityStampToken");
+ }
+
//only update the changed cols
if (changedCols.Count > 0)
{
diff --git a/src/Umbraco.Core/Persistence/SqlSyntax/SqlServerSyntaxProvider.cs b/src/Umbraco.Core/Persistence/SqlSyntax/SqlServerSyntaxProvider.cs
index 3d0adf175e..bb50fa98a1 100644
--- a/src/Umbraco.Core/Persistence/SqlSyntax/SqlServerSyntaxProvider.cs
+++ b/src/Umbraco.Core/Persistence/SqlSyntax/SqlServerSyntaxProvider.cs
@@ -250,6 +250,11 @@ where tbl.[name]=@0 and col.[name]=@1;", tableName, columnName)
}
public override void WriteLock(IDatabase db, params int[] lockIds)
+ {
+ WriteLock(db, TimeSpan.FromMilliseconds(1800), lockIds);
+ }
+
+ public void WriteLock(IDatabase db, TimeSpan timeout, params int[] lockIds)
{
// soon as we get Database, a transaction is started
@@ -260,7 +265,7 @@ where tbl.[name]=@0 and col.[name]=@1;", tableName, columnName)
// *not* using a unique 'WHERE IN' query here because the *order* of lockIds is important to avoid deadlocks
foreach (var lockId in lockIds)
{
- db.Execute(@"SET LOCK_TIMEOUT 1800;");
+ db.Execute($"SET LOCK_TIMEOUT {timeout.TotalMilliseconds};");
var i = db.Execute(@"UPDATE umbracoLock WITH (REPEATABLEREAD) SET value = (CASE WHEN (value=1) THEN -1 ELSE 1 END) WHERE id=@id", new { id = lockId });
if (i == 0) // ensure we are actually locking!
throw new ArgumentException($"LockObject with id={lockId} does not exist.");
diff --git a/src/Umbraco.Core/Persistence/SqlSyntax/SqlSyntaxProviderExtensions.cs b/src/Umbraco.Core/Persistence/SqlSyntax/SqlSyntaxProviderExtensions.cs
index f7cf480830..b829f1fbc5 100644
--- a/src/Umbraco.Core/Persistence/SqlSyntax/SqlSyntaxProviderExtensions.cs
+++ b/src/Umbraco.Core/Persistence/SqlSyntax/SqlSyntaxProviderExtensions.cs
@@ -35,6 +35,8 @@ namespace Umbraco.Core.Persistence.SqlSyntax
///
public static Sql GetDeleteSubquery(this ISqlSyntaxProvider sqlProvider, string tableName, string columnName, Sql subQuery, WhereInType whereInType = WhereInType.In)
{
+ //TODO: This is no longer necessary since this used to be a specific requirement for MySql!
+ // Now we can do a Delete + sub query, see RelationRepository.DeleteByParent for example
return
new Sql(string.Format(
diff --git a/src/Umbraco.Core/Persistence/UmbracoDatabase.cs b/src/Umbraco.Core/Persistence/UmbracoDatabase.cs
index 072813b4e6..a95d95ea08 100644
--- a/src/Umbraco.Core/Persistence/UmbracoDatabase.cs
+++ b/src/Umbraco.Core/Persistence/UmbracoDatabase.cs
@@ -44,6 +44,8 @@ namespace Umbraco.Core.Persistence
_commandRetryPolicy = commandRetryPolicy;
EnableSqlTrace = EnableSqlTraceDefault;
+
+ NPocoDatabaseExtensions.ConfigureNPocoBulkExtensions();
}
///
@@ -57,6 +59,8 @@ namespace Umbraco.Core.Persistence
_logger = logger;
EnableSqlTrace = EnableSqlTraceDefault;
+
+ NPocoDatabaseExtensions.ConfigureNPocoBulkExtensions();
}
#endregion
diff --git a/src/Umbraco.Core/Properties/AssemblyInfo.cs b/src/Umbraco.Core/Properties/AssemblyInfo.cs
index afd602cfc9..87e0732d47 100644
--- a/src/Umbraco.Core/Properties/AssemblyInfo.cs
+++ b/src/Umbraco.Core/Properties/AssemblyInfo.cs
@@ -14,6 +14,7 @@ using System.Runtime.InteropServices;
[assembly: InternalsVisibleTo("Umbraco.Web")]
[assembly: InternalsVisibleTo("Umbraco.Web.UI")]
[assembly: InternalsVisibleTo("Umbraco.Examine")]
+[assembly: InternalsVisibleTo("Umbraco.ModelsBuilder.Embedded")]
[assembly: InternalsVisibleTo("Umbraco.Tests")]
[assembly: InternalsVisibleTo("Umbraco.Tests.Benchmarks")]
diff --git a/src/Umbraco.Core/PropertyEditors/DataEditor.cs b/src/Umbraco.Core/PropertyEditors/DataEditor.cs
index dbb2fc467e..7dc260e4c7 100644
--- a/src/Umbraco.Core/PropertyEditors/DataEditor.cs
+++ b/src/Umbraco.Core/PropertyEditors/DataEditor.cs
@@ -19,6 +19,7 @@ namespace Umbraco.Core.PropertyEditors
public class DataEditor : IDataEditor
{
private IDictionary _defaultConfiguration;
+ private IDataValueEditor _dataValueEditor;
///
/// Initializes a new instance of the class.
@@ -90,7 +91,7 @@ namespace Umbraco.Core.PropertyEditors
/// simple enough for now.
///
// TODO: point of that one? shouldn't we always configure?
- public IDataValueEditor GetValueEditor() => ExplicitValueEditor ?? CreateValueEditor();
+ public IDataValueEditor GetValueEditor() => ExplicitValueEditor ?? (_dataValueEditor ?? (_dataValueEditor = CreateValueEditor()));
///
///
@@ -113,7 +114,7 @@ namespace Umbraco.Core.PropertyEditors
return ExplicitValueEditor;
var editor = CreateValueEditor();
- ((DataValueEditor) editor).Configuration = configuration; // TODO: casting is bad
+ ((DataValueEditor)editor).Configuration = configuration; // TODO: casting is bad
return editor;
}
@@ -163,7 +164,7 @@ namespace Umbraco.Core.PropertyEditors
protected virtual IDataValueEditor CreateValueEditor()
{
if (Attribute == null)
- throw new InvalidOperationException("The editor does not specify a view.");
+ throw new InvalidOperationException($"The editor is not attributed with {nameof(DataEditorAttribute)}");
return new DataValueEditor(Attribute);
}
@@ -175,7 +176,7 @@ namespace Umbraco.Core.PropertyEditors
{
var editor = new ConfigurationEditor();
// pass the default configuration if this is not a property value editor
- if((Type & EditorType.PropertyValue) == 0)
+ if ((Type & EditorType.PropertyValue) == 0)
{
editor.DefaultConfiguration = _defaultConfiguration;
}
diff --git a/src/Umbraco.Core/PropertyEditors/DataValueReferenceFactoryCollection.cs b/src/Umbraco.Core/PropertyEditors/DataValueReferenceFactoryCollection.cs
new file mode 100644
index 0000000000..386ab6a8f3
--- /dev/null
+++ b/src/Umbraco.Core/PropertyEditors/DataValueReferenceFactoryCollection.cs
@@ -0,0 +1,50 @@
+using System.Collections.Generic;
+using Umbraco.Core.Composing;
+using Umbraco.Core.Models;
+using Umbraco.Core.Models.Editors;
+
+namespace Umbraco.Core.PropertyEditors
+{
+ public class DataValueReferenceFactoryCollection : BuilderCollectionBase
+ {
+ public DataValueReferenceFactoryCollection(IEnumerable items)
+ : base(items)
+ { }
+
+ public IEnumerable GetAllReferences(PropertyCollection properties, PropertyEditorCollection propertyEditors)
+ {
+ var trackedRelations = new List();
+
+ foreach (var p in properties)
+ {
+ if (!propertyEditors.TryGet(p.PropertyType.PropertyEditorAlias, out var editor)) continue;
+
+ //TODO: Support variants/segments! This is not required for this initial prototype which is why there is a check here
+ if (!p.PropertyType.VariesByNothing()) continue;
+ var val = p.GetValue(); // get the invariant value
+
+ var valueEditor = editor.GetValueEditor();
+ if (valueEditor is IDataValueReference reference)
+ {
+ var refs = reference.GetReferences(val);
+ trackedRelations.AddRange(refs);
+ }
+
+ // Loop over collection that may be add to existing property editors
+ // implementation of GetReferences in IDataValueReference.
+ // Allows developers to add support for references by a
+ // package /property editor that did not implement IDataValueReference themselves
+ foreach (var item in this)
+ {
+ // Check if this value reference is for this datatype/editor
+ // Then call it's GetReferences method - to see if the value stored
+ // in the dataeditor/property has referecnes to media/content items
+ if (item.IsForEditor(editor))
+ trackedRelations.AddRange(item.GetDataValueReference().GetReferences(val));
+ }
+ }
+
+ return trackedRelations;
+ }
+ }
+}
diff --git a/src/Umbraco.Core/PropertyEditors/DataValueReferenceFactoryCollectionBuilder.cs b/src/Umbraco.Core/PropertyEditors/DataValueReferenceFactoryCollectionBuilder.cs
new file mode 100644
index 0000000000..2cf76712c8
--- /dev/null
+++ b/src/Umbraco.Core/PropertyEditors/DataValueReferenceFactoryCollectionBuilder.cs
@@ -0,0 +1,9 @@
+using Umbraco.Core.Composing;
+
+namespace Umbraco.Core.PropertyEditors
+{
+ public class DataValueReferenceFactoryCollectionBuilder : OrderedCollectionBuilderBase
+ {
+ protected override DataValueReferenceFactoryCollectionBuilder This => this;
+ }
+}
diff --git a/src/Umbraco.Core/PropertyEditors/IDataEditorWithMediaPath.cs b/src/Umbraco.Core/PropertyEditors/IDataEditorWithMediaPath.cs
new file mode 100644
index 0000000000..e8af1b0ac3
--- /dev/null
+++ b/src/Umbraco.Core/PropertyEditors/IDataEditorWithMediaPath.cs
@@ -0,0 +1,19 @@
+namespace Umbraco.Core.PropertyEditors
+{
+ ///
+ /// Must be implemented by property editors that store media and return media paths
+ ///
+ ///
+ /// Currently there are only 2x core editors that do this: upload and image cropper.
+ /// It would be possible for developers to know implement their own media property editors whereas previously this was not possible.
+ ///
+ public interface IDataEditorWithMediaPath
+ {
+ ///
+ /// Returns the media path for the value stored for a property
+ ///
+ ///
+ ///
+ string GetMediaPath(object value);
+ }
+}
diff --git a/src/Umbraco.Core/PropertyEditors/IDataValueEditor.cs b/src/Umbraco.Core/PropertyEditors/IDataValueEditor.cs
index cb68531cc7..a02fa71ec7 100644
--- a/src/Umbraco.Core/PropertyEditors/IDataValueEditor.cs
+++ b/src/Umbraco.Core/PropertyEditors/IDataValueEditor.cs
@@ -7,6 +7,7 @@ using Umbraco.Core.Services;
namespace Umbraco.Core.PropertyEditors
{
+
///
/// Represents an editor for editing data values.
///
@@ -63,8 +64,26 @@ namespace Umbraco.Core.PropertyEditors
// TODO: / deal with this when unplugging the xml cache
// why property vs propertyType? services should be injected! etc...
+
+ ///
+ /// Used for serializing an item for packaging
+ ///
+ ///
+ ///
+ ///
+ ///
+ ///
IEnumerable ConvertDbToXml(Property property, IDataTypeService dataTypeService, ILocalizationService localizationService, bool published);
+
+ ///
+ /// Used for serializing an item for packaging
+ ///
+ ///
+ ///
+ ///
+ ///
XNode ConvertDbToXml(PropertyType propertyType, object value, IDataTypeService dataTypeService);
+
string ConvertDbToString(PropertyType propertyType, object value, IDataTypeService dataTypeService);
}
}
diff --git a/src/Umbraco.Core/PropertyEditors/IDataValueReference.cs b/src/Umbraco.Core/PropertyEditors/IDataValueReference.cs
new file mode 100644
index 0000000000..6377098bfc
--- /dev/null
+++ b/src/Umbraco.Core/PropertyEditors/IDataValueReference.cs
@@ -0,0 +1,18 @@
+using System.Collections.Generic;
+using Umbraco.Core.Models.Editors;
+
+namespace Umbraco.Core.PropertyEditors
+{
+ ///
+ /// Resolve references from values
+ ///
+ public interface IDataValueReference
+ {
+ ///
+ /// Returns any references contained in the value
+ ///
+ ///
+ ///
+ IEnumerable GetReferences(object value);
+ }
+}
diff --git a/src/Umbraco.Core/PropertyEditors/IDataValueReferenceFactory.cs b/src/Umbraco.Core/PropertyEditors/IDataValueReferenceFactory.cs
new file mode 100644
index 0000000000..6587e071bf
--- /dev/null
+++ b/src/Umbraco.Core/PropertyEditors/IDataValueReferenceFactory.cs
@@ -0,0 +1,18 @@
+namespace Umbraco.Core.PropertyEditors
+{
+ public interface IDataValueReferenceFactory
+ {
+ ///
+ /// Gets a value indicating whether the DataValueReference lookup supports a datatype (data editor).
+ ///
+ /// The datatype.
+ /// A value indicating whether the converter supports a datatype.
+ bool IsForEditor(IDataEditor dataEditor);
+
+ ///
+ ///
+ ///
+ ///
+ IDataValueReference GetDataValueReference();
+ }
+}
diff --git a/src/Umbraco.Core/PropertyEditors/PropertyEditorCollection.cs b/src/Umbraco.Core/PropertyEditors/PropertyEditorCollection.cs
index 712a66e55d..21854b63c1 100644
--- a/src/Umbraco.Core/PropertyEditors/PropertyEditorCollection.cs
+++ b/src/Umbraco.Core/PropertyEditors/PropertyEditorCollection.cs
@@ -4,6 +4,8 @@ using Umbraco.Core.Manifest;
namespace Umbraco.Core.PropertyEditors
{
+
+
public class PropertyEditorCollection : BuilderCollectionBase
{
public PropertyEditorCollection(DataEditorCollection dataEditors, ManifestParser manifestParser)
@@ -27,4 +29,4 @@ namespace Umbraco.Core.PropertyEditors
return editor != null;
}
}
-}
\ No newline at end of file
+}
diff --git a/src/Umbraco.Core/PropertyEditors/ValueConverters/ImageCropperValue.cs b/src/Umbraco.Core/PropertyEditors/ValueConverters/ImageCropperValue.cs
index b211272b51..ab217d3870 100644
--- a/src/Umbraco.Core/PropertyEditors/ValueConverters/ImageCropperValue.cs
+++ b/src/Umbraco.Core/PropertyEditors/ValueConverters/ImageCropperValue.cs
@@ -7,6 +7,8 @@ using System.Runtime.Serialization;
using System.Text;
using System.Web;
using Newtonsoft.Json;
+using Umbraco.Core.Composing;
+using Umbraco.Core.Models;
using Umbraco.Core.Serialization;
namespace Umbraco.Core.PropertyEditors.ValueConverters
@@ -59,38 +61,34 @@ namespace Umbraco.Core.PropertyEditors.ValueConverters
: Crops.FirstOrDefault(x => x.Alias.InvariantEquals(alias));
}
- internal void AppendCropBaseUrl(StringBuilder url, ImageCropperCrop crop, bool defaultCrop, bool preferFocalPoint)
+ internal ImageUrlGenerationOptions GetCropBaseOptions(string url, ImageCropperCrop crop, bool defaultCrop, bool preferFocalPoint)
{
if (preferFocalPoint && HasFocalPoint()
|| crop != null && crop.Coordinates == null && HasFocalPoint()
|| defaultCrop && HasFocalPoint())
{
- url.Append("?center=");
- url.Append(FocalPoint.Top.ToString(CultureInfo.InvariantCulture));
- url.Append(",");
- url.Append(FocalPoint.Left.ToString(CultureInfo.InvariantCulture));
- url.Append("&mode=crop");
+ return new ImageUrlGenerationOptions(url) { FocalPoint = new ImageUrlGenerationOptions.FocalPointPosition(FocalPoint.Top, FocalPoint.Left) };
}
else if (crop != null && crop.Coordinates != null && preferFocalPoint == false)
{
- url.Append("?crop=");
- url.Append(crop.Coordinates.X1.ToString(CultureInfo.InvariantCulture)).Append(",");
- url.Append(crop.Coordinates.Y1.ToString(CultureInfo.InvariantCulture)).Append(",");
- url.Append(crop.Coordinates.X2.ToString(CultureInfo.InvariantCulture)).Append(",");
- url.Append(crop.Coordinates.Y2.ToString(CultureInfo.InvariantCulture));
- url.Append("&cropmode=percentage");
+ return new ImageUrlGenerationOptions(url) { Crop = new ImageUrlGenerationOptions.CropCoordinates(crop.Coordinates.X1, crop.Coordinates.Y1, crop.Coordinates.X2, crop.Coordinates.Y2) };
}
else
{
- url.Append("?anchor=center");
- url.Append("&mode=crop");
+ return new ImageUrlGenerationOptions(url) { DefaultCrop = true };
}
}
///
/// Gets the value image url for a specified crop.
///
- public string GetCropUrl(string alias, bool useCropDimensions = true, bool useFocalPoint = false, string cacheBusterValue = null)
+ [Obsolete("Use the overload that takes an IImageUrlGenerator")]
+ public string GetCropUrl(string alias, bool useCropDimensions = true, bool useFocalPoint = false, string cacheBusterValue = null) => GetCropUrl(alias, Current.ImageUrlGenerator, useCropDimensions, useFocalPoint, cacheBusterValue);
+
+ ///
+ /// Gets the value image url for a specified crop.
+ ///
+ public string GetCropUrl(string alias, IImageUrlGenerator imageUrlGenerator, bool useCropDimensions = true, bool useFocalPoint = false, string cacheBusterValue = null)
{
var crop = GetCrop(alias);
@@ -98,38 +96,37 @@ namespace Umbraco.Core.PropertyEditors.ValueConverters
if (crop == null && !string.IsNullOrWhiteSpace(alias))
return null;
- var url = new StringBuilder();
-
- AppendCropBaseUrl(url, crop, string.IsNullOrWhiteSpace(alias), useFocalPoint);
+ var options = GetCropBaseOptions(string.Empty, crop, string.IsNullOrWhiteSpace(alias), useFocalPoint);
if (crop != null && useCropDimensions)
{
- url.Append("&width=").Append(crop.Width);
- url.Append("&height=").Append(crop.Height);
+ options.Width = crop.Width;
+ options.Height = crop.Height;
}
- if (cacheBusterValue != null)
- url.Append("&rnd=").Append(cacheBusterValue);
+ options.CacheBusterValue = cacheBusterValue;
- return url.ToString();
+ return imageUrlGenerator.GetImageUrl(options);
}
///
/// Gets the value image url for a specific width and height.
///
- public string GetCropUrl(int width, int height, bool useFocalPoint = false, string cacheBusterValue = null)
+ [Obsolete("Use the overload that takes an IImageUrlGenerator")]
+ public string GetCropUrl(int width, int height, bool useFocalPoint = false, string cacheBusterValue = null) => GetCropUrl(width, height, Current.ImageUrlGenerator, useFocalPoint, cacheBusterValue);
+
+ ///
+ /// Gets the value image url for a specific width and height.
+ ///
+ public string GetCropUrl(int width, int height, IImageUrlGenerator imageUrlGenerator, bool useFocalPoint = false, string cacheBusterValue = null)
{
- var url = new StringBuilder();
+ var options = GetCropBaseOptions(string.Empty, null, true, useFocalPoint);
- AppendCropBaseUrl(url, null, true, useFocalPoint);
+ options.Width = width;
+ options.Height = height;
+ options.CacheBusterValue = cacheBusterValue;
- url.Append("&width=").Append(width);
- url.Append("&height=").Append(height);
-
- if (cacheBusterValue != null)
- url.Append("&rnd=").Append(cacheBusterValue);
-
- return url.ToString();
+ return imageUrlGenerator.GetImageUrl(options);
}
///
diff --git a/src/Umbraco.Core/Runtime/CoreInitialComposer.cs b/src/Umbraco.Core/Runtime/CoreInitialComposer.cs
index 1f004846d0..d95ada499b 100644
--- a/src/Umbraco.Core/Runtime/CoreInitialComposer.cs
+++ b/src/Umbraco.Core/Runtime/CoreInitialComposer.cs
@@ -43,7 +43,7 @@ namespace Umbraco.Core.Runtime
// register persistence mappers - required by database factory so needs to be done here
// means the only place the collection can be modified is in a runtime - afterwards it
// has been frozen and it is too late
- composition.WithCollectionBuilder().AddCoreMappers();
+ composition.Mappers().AddCoreMappers();
// register the scope provider
composition.RegisterUnique(); // implements both IScopeProvider and IScopeAccessor
@@ -70,11 +70,15 @@ namespace Umbraco.Core.Runtime
composition.ManifestFilters();
// properties and parameters derive from data editors
- composition.WithCollectionBuilder()
+ composition.DataEditors()
.Add(() => composition.TypeLoader.GetDataEditors());
composition.RegisterUnique();
composition.RegisterUnique();
+ // Used to determine if a datatype/editor should be storing/tracking
+ // references to media item/s
+ composition.DataValueReferenceFactories();
+
// register a server registrar, by default it's the db registrar
composition.RegisterUnique(f =>
{
@@ -101,13 +105,13 @@ namespace Umbraco.Core.Runtime
factory.GetInstance(),
true, new DatabaseServerMessengerOptions()));
- composition.WithCollectionBuilder()
+ composition.CacheRefreshers()
.Add(() => composition.TypeLoader.GetCacheRefreshers());
- composition.WithCollectionBuilder()
+ composition.PackageActions()
.Add(() => composition.TypeLoader.GetPackageActions());
- composition.WithCollectionBuilder()
+ composition.PropertyValueConverters()
.Append(composition.TypeLoader.GetTypes());
composition.RegisterUnique();
@@ -115,7 +119,7 @@ namespace Umbraco.Core.Runtime
composition.RegisterUnique(factory
=> new DefaultShortStringHelper(new DefaultShortStringHelperConfig().WithDefault(factory.GetInstance())));
- composition.WithCollectionBuilder()
+ composition.UrlSegmentProviders()
.Append();
composition.RegisterUnique(factory => new MigrationBuilder(factory));
diff --git a/src/Umbraco.Core/Runtime/CoreRuntime.cs b/src/Umbraco.Core/Runtime/CoreRuntime.cs
index 5b069641c4..b852aff2ff 100644
--- a/src/Umbraco.Core/Runtime/CoreRuntime.cs
+++ b/src/Umbraco.Core/Runtime/CoreRuntime.cs
@@ -27,6 +27,17 @@ namespace Umbraco.Core.Runtime
private IFactory _factory;
private RuntimeState _state;
+ [Obsolete("Use the ctor with all parameters instead")]
+ public CoreRuntime()
+ {
+ }
+
+ public CoreRuntime(ILogger logger, IMainDom mainDom)
+ {
+ MainDom = mainDom;
+ Logger = logger;
+ }
+
///
/// Gets the logger.
///
@@ -45,14 +56,22 @@ namespace Umbraco.Core.Runtime
///
public IRuntimeState State => _state;
+ public IMainDom MainDom { get; private set; }
+
///
public virtual IFactory Boot(IRegister register)
{
// create and register the essential services
// ie the bare minimum required to boot
+#pragma warning disable CS0618 // Type or member is obsolete
// loggers
- var logger = Logger = GetLogger();
+ // TODO: Removes this in netcore, this is purely just backwards compat ugliness
+ var logger = GetLogger();
+ if (logger != Logger)
+ Logger = logger;
+#pragma warning restore CS0618 // Type or member is obsolete
+
var profiler = Profiler = GetProfiler();
var profilingLogger = ProfilingLogger = new ProfilingLogger(logger, profiler);
@@ -125,12 +144,16 @@ namespace Umbraco.Core.Runtime
Level = RuntimeLevel.Boot
};
- // main dom
- var mainDom = new MainDom(Logger);
+ // TODO: remove this in netcore, this is purely backwards compat hacks with the empty ctor
+ if (MainDom == null)
+ {
+ MainDom = new MainDom(Logger, new MainDomSemaphoreLock(Logger));
+ }
+
// create the composition
composition = new Composition(register, typeLoader, ProfilingLogger, _state, configs);
- composition.RegisterEssentials(Logger, Profiler, ProfilingLogger, mainDom, appCaches, databaseFactory, typeLoader, _state);
+ composition.RegisterEssentials(Logger, Profiler, ProfilingLogger, MainDom, appCaches, databaseFactory, typeLoader, _state);
// run handlers
RuntimeOptions.DoRuntimeEssentials(composition, appCaches, typeLoader, databaseFactory);
@@ -140,15 +163,21 @@ namespace Umbraco.Core.Runtime
Compose(composition);
// acquire the main domain - if this fails then anything that should be registered with MainDom will not operate
- AcquireMainDom(mainDom);
+ AcquireMainDom(MainDom);
// determine our runtime level
DetermineRuntimeLevel(databaseFactory, ProfilingLogger);
// get composers, and compose
var composerTypes = ResolveComposerTypes(typeLoader);
- composition.WithCollectionBuilder();
- var composers = new Composers(composition, composerTypes, ProfilingLogger);
+
+ IEnumerable enableDisableAttributes;
+ using (ProfilingLogger.DebugDuration("Scanning enable/disable composer attributes"))
+ {
+ enableDisableAttributes = typeLoader.GetAssemblyAttributes(typeof(EnableComposerAttribute), typeof(DisableComposerAttribute));
+ }
+
+ var composers = new Composers(composition, composerTypes, enableDisableAttributes, ProfilingLogger);
composers.Compose();
// create the factory
@@ -157,6 +186,8 @@ namespace Umbraco.Core.Runtime
// create & initialize the components
_components = _factory.GetInstance();
_components.Initialize();
+
+
}
catch (Exception e)
{
@@ -218,13 +249,13 @@ namespace Umbraco.Core.Runtime
IOHelper.SetRootDirectory(path);
}
- private bool AcquireMainDom(MainDom mainDom)
+ private bool AcquireMainDom(IMainDom mainDom)
{
using (var timer = ProfilingLogger.DebugDuration("Acquiring MainDom.", "Acquired."))
{
try
{
- return mainDom.Acquire();
+ return mainDom.IsMainDom;
}
catch
{
@@ -301,11 +332,9 @@ namespace Umbraco.Core.Runtime
protected virtual IEnumerable GetComposerTypes(TypeLoader typeLoader)
=> typeLoader.GetTypes();
- ///
- /// Gets a logger.
- ///
+ [Obsolete("Don't use this method, the logger should be injected into the " + nameof(CoreRuntime))]
protected virtual ILogger GetLogger()
- => SerilogLogger.CreateWithDefaultConfiguration();
+ => Logger ?? SerilogLogger.CreateWithDefaultConfiguration(); // TODO: Remove this in netcore, this purely just backwards compat ugliness
///
/// Gets a profiler.
diff --git a/src/Umbraco.Core/IMainDom.cs b/src/Umbraco.Core/Runtime/IMainDom.cs
similarity index 88%
rename from src/Umbraco.Core/IMainDom.cs
rename to src/Umbraco.Core/Runtime/IMainDom.cs
index 3a8cd13ff1..444fc1c7d0 100644
--- a/src/Umbraco.Core/IMainDom.cs
+++ b/src/Umbraco.Core/Runtime/IMainDom.cs
@@ -1,5 +1,6 @@
using System;
+// TODO: Can't change namespace due to breaking changes, change in netcore
namespace Umbraco.Core
{
///
@@ -14,6 +15,9 @@ namespace Umbraco.Core
///
/// Gets a value indicating whether the current domain is the main domain.
///
+ ///
+ /// When the first call is made to this there will generally be some logic executed to acquire a distributed lock lease.
+ ///
bool IsMainDom { get; }
///
@@ -35,4 +39,4 @@ namespace Umbraco.Core
/// is guaranteed to execute before the AppDomain releases the main domain status.
bool Register(Action install, Action release, int weight = 100);
}
-}
\ No newline at end of file
+}
diff --git a/src/Umbraco.Core/Runtime/IMainDomLock.cs b/src/Umbraco.Core/Runtime/IMainDomLock.cs
new file mode 100644
index 0000000000..6a62f48194
--- /dev/null
+++ b/src/Umbraco.Core/Runtime/IMainDomLock.cs
@@ -0,0 +1,29 @@
+using System;
+using System.Threading.Tasks;
+
+namespace Umbraco.Core.Runtime
+{
+ ///
+ /// An application-wide distributed lock
+ ///
+ ///
+ /// Disposing releases the lock
+ ///
+ public interface IMainDomLock : IDisposable
+ {
+ ///
+ /// Acquires an application-wide distributed lock
+ ///
+ ///
+ ///
+ /// An awaitable boolean value which will be false if the elapsed millsecondsTimeout value is exceeded
+ ///
+ Task AcquireLockAsync(int millisecondsTimeout);
+
+ ///
+ /// Wait on a background thread to receive a signal from another AppDomain
+ ///
+ ///
+ Task ListenAsync();
+ }
+}
diff --git a/src/Umbraco.Core/MainDom.cs b/src/Umbraco.Core/Runtime/MainDom.cs
similarity index 50%
rename from src/Umbraco.Core/MainDom.cs
rename to src/Umbraco.Core/Runtime/MainDom.cs
index 5da1062275..e6780ec876 100644
--- a/src/Umbraco.Core/MainDom.cs
+++ b/src/Umbraco.Core/Runtime/MainDom.cs
@@ -4,10 +4,13 @@ using System.Linq;
using System.Security.Cryptography;
using System.Threading;
using System.Web.Hosting;
+using Umbraco.Core;
using Umbraco.Core.Logging;
+using Umbraco.Core.Persistence;
-namespace Umbraco.Core
+namespace Umbraco.Core.Runtime
{
+
///
/// Provides the full implementation of .
///
@@ -15,63 +18,37 @@ namespace Umbraco.Core
/// When an AppDomain starts, it tries to acquire the main domain status.
/// When an AppDomain stops (eg the application is restarting) it should release the main domain status.
///
- internal class MainDom : IMainDom, IRegisteredObject
+ internal class MainDom : IMainDom, IRegisteredObject, IDisposable
{
#region Vars
private readonly ILogger _logger;
+ private readonly IMainDomLock _mainDomLock;
// our own lock for local consistency
- private readonly object _locko = new object();
-
- // async lock representing the main domain lock
- private readonly AsyncLock _asyncLock;
- private IDisposable _asyncLocker;
-
- // event wait handle used to notify current main domain that it should
- // release the lock because a new domain wants to be the main domain
- private readonly EventWaitHandle _signal;
+ private object _locko = new object();
+ private bool _isInitialized;
// indicates whether...
- private volatile bool _isMainDom; // we are the main domain
+ private bool _isMainDom; // we are the main domain
private volatile bool _signaled; // we have been signaled
// actions to run before releasing the main domain
private readonly List> _callbacks = new List>();
- private const int LockTimeoutMilliseconds = 90000; // (1.5 * 60 * 1000) == 1 min 30 seconds
+ private const int LockTimeoutMilliseconds = 40000; // 40 seconds
#endregion
#region Ctor
// initializes a new instance of MainDom
- public MainDom(ILogger logger)
+ public MainDom(ILogger logger, IMainDomLock systemLock)
{
+ HostingEnvironment.RegisterObject(this);
+
_logger = logger;
-
- var appId = string.Empty;
- // HostingEnvironment.ApplicationID is null in unit tests, making ReplaceNonAlphanumericChars fail
- if (HostingEnvironment.ApplicationID != null)
- appId = HostingEnvironment.ApplicationID.ReplaceNonAlphanumericChars(string.Empty);
-
- // combining with the physical path because if running on eg IIS Express,
- // two sites could have the same appId even though they are different.
- //
- // now what could still collide is... two sites, running in two different processes
- // and having the same appId, and running on the same app physical path
- //
- // we *cannot* use the process ID here because when an AppPool restarts it is
- // a new process for the same application path
-
- var appPath = HostingEnvironment.ApplicationPhysicalPath;
- var hash = (appId + ":::" + appPath).GenerateHash();
-
- var lockName = "UMBRACO-" + hash + "-MAINDOM-LCK";
- _asyncLock = new AsyncLock(lockName);
-
- var eventName = "UMBRACO-" + hash + "-MAINDOM-EVT";
- _signal = new EventWaitHandle(false, EventResetMode.AutoReset, eventName);
+ _mainDomLock = systemLock;
}
#endregion
@@ -99,6 +76,12 @@ namespace Umbraco.Core
lock (_locko)
{
if (_signaled) return false;
+ if (_isMainDom == false)
+ {
+ _logger.Warn("Register called when MainDom has not been acquired");
+ return false;
+ }
+
install?.Invoke();
if (release != null)
_callbacks.Add(new KeyValuePair(weight, release));
@@ -118,100 +101,145 @@ namespace Umbraco.Core
if (_signaled) return;
if (_isMainDom == false) return; // probably not needed
_signaled = true;
- }
- try
- {
- _logger.Info("Stopping ({SignalSource})", source);
- foreach (var callback in _callbacks.OrderBy(x => x.Key).Select(x => x.Value))
+ try
{
- try
+ _logger.Info("Stopping ({SignalSource})", source);
+ foreach (var callback in _callbacks.OrderBy(x => x.Key).Select(x => x.Value))
{
- callback(); // no timeout on callbacks
+ try
+ {
+ callback(); // no timeout on callbacks
+ }
+ catch (Exception e)
+ {
+ _logger.Error(e, "Error while running callback");
+ continue;
+ }
}
- catch (Exception e)
- {
- _logger.Error(e, "Error while running callback, remaining callbacks will not run.");
- throw;
- }
-
+
+ _logger.Debug("Stopped ({SignalSource})", source);
}
- _logger.Debug("Stopped ({SignalSource})", source);
- }
- finally
- {
- // in any case...
- _isMainDom = false;
- _asyncLocker.Dispose();
- _logger.Info("Released ({SignalSource})", source);
+ finally
+ {
+ // in any case...
+ _isMainDom = false;
+ _mainDomLock.Dispose();
+ _logger.Info("Released ({SignalSource})", source);
+ }
+
}
}
// acquires the main domain
- internal bool Acquire()
+ private bool Acquire()
{
- lock (_locko) // we don't want the hosting environment to interfere by signaling
+ // if signaled, too late to acquire, give up
+ // the handler is not installed so that would be the hosting environment
+ if (_signaled)
{
- // if signaled, too late to acquire, give up
- // the handler is not installed so that would be the hosting environment
- if (_signaled)
- {
- _logger.Info("Cannot acquire (signaled).");
- return false;
- }
-
- _logger.Info("Acquiring.");
-
- // signal other instances that we want the lock, then wait one the lock,
- // which may timeout, and this is accepted - see comments below
-
- // signal, then wait for the lock, then make sure the event is
- // reset (maybe there was noone listening..)
- _signal.Set();
-
- // if more than 1 instance reach that point, one will get the lock
- // and the other one will timeout, which is accepted
-
- //TODO: This can throw a TimeoutException - in which case should this be in a try/finally to ensure the signal is always reset?
- _asyncLocker = _asyncLock.Lock(LockTimeoutMilliseconds);
- _isMainDom = true;
-
- // we need to reset the event, because otherwise we would end up
- // signaling ourselves and committing suicide immediately.
- // only 1 instance can reach that point, but other instances may
- // have started and be trying to get the lock - they will timeout,
- // which is accepted
-
- _signal.Reset();
-
- //WaitOneAsync (ext method) will wait for a signal without blocking the main thread, the waiting is done on a background thread
-
- _signal.WaitOneAsync()
- .ContinueWith(_ => OnSignal("signal"));
-
- HostingEnvironment.RegisterObject(this);
-
- _logger.Info("Acquired.");
- return true;
+ _logger.Info("Cannot acquire (signaled).");
+ return false;
}
+
+ _logger.Info("Acquiring.");
+
+ // Get the lock
+ var acquired = _mainDomLock.AcquireLockAsync(LockTimeoutMilliseconds).GetAwaiter().GetResult();
+
+ if (!acquired)
+ {
+ _logger.Info("Cannot acquire (timeout).");
+
+ // In previous versions we'd let a TimeoutException be thrown
+ // and the appdomain would not start. We have the opportunity to allow it to
+ // start without having MainDom? This would mean that it couldn't write
+ // to nucache/examine and would only be ok if this was a super short lived appdomain.
+ // maybe safer to just keep throwing in this case.
+
+ throw new TimeoutException("Cannot acquire MainDom");
+ // return false;
+ }
+
+ try
+ {
+ // Listen for the signal from another AppDomain coming online to release the lock
+ _mainDomLock.ListenAsync().ContinueWith(_ => OnSignal("signal"));
+ }
+ catch (OperationCanceledException ex)
+ {
+ // the waiting task could be canceled if this appdomain is naturally shutting down, we'll just swallow this exception
+ _logger.Warn(ex, ex.Message);
+ }
+
+ _logger.Info("Acquired.");
+ return true;
}
///
/// Gets a value indicating whether the current domain is the main domain.
///
- public bool IsMainDom => _isMainDom;
+ ///
+ /// The lazy initializer call will only call the Acquire callback when it's not been initialized, else it will just return
+ /// the value from _isMainDom which means when we set _isMainDom to false again after being signaled, this will return false;
+ ///
+ public bool IsMainDom => LazyInitializer.EnsureInitialized(ref _isMainDom, ref _isInitialized, ref _locko, () => Acquire());
// IRegisteredObject
void IRegisteredObject.Stop(bool immediate)
{
- try
+ OnSignal("environment"); // will run once
+
+ // The web app is stopping, need to wind down
+ Dispose(true);
+
+ HostingEnvironment.UnregisterObject(this);
+ }
+
+ #region IDisposable Support
+
+ // This code added to correctly implement the disposable pattern.
+
+ private bool disposedValue = false; // To detect redundant calls
+
+ protected virtual void Dispose(bool disposing)
+ {
+ if (!disposedValue)
{
- OnSignal("environment"); // will run once
- }
- finally
- {
- HostingEnvironment.UnregisterObject(this);
+ if (disposing)
+ {
+ _mainDomLock.Dispose();
+ }
+
+ disposedValue = true;
}
}
+
+ public void Dispose()
+ {
+ Dispose(true);
+ }
+
+ #endregion
+
+ public static string GetMainDomId()
+ {
+ // HostingEnvironment.ApplicationID is null in unit tests, making ReplaceNonAlphanumericChars fail
+ var appId = HostingEnvironment.ApplicationID?.ReplaceNonAlphanumericChars(string.Empty) ?? string.Empty;
+
+ // combining with the physical path because if running on eg IIS Express,
+ // two sites could have the same appId even though they are different.
+ //
+ // now what could still collide is... two sites, running in two different processes
+ // and having the same appId, and running on the same app physical path
+ //
+ // we *cannot* use the process ID here because when an AppPool restarts it is
+ // a new process for the same application path
+
+ var appPath = HostingEnvironment.ApplicationPhysicalPath?.ToLowerInvariant() ?? string.Empty;
+ var hash = (appId + ":::" + appPath).GenerateHash();
+
+ return hash;
+ }
}
}
diff --git a/src/Umbraco.Core/Runtime/MainDomSemaphoreLock.cs b/src/Umbraco.Core/Runtime/MainDomSemaphoreLock.cs
new file mode 100644
index 0000000000..2dcc37e25f
--- /dev/null
+++ b/src/Umbraco.Core/Runtime/MainDomSemaphoreLock.cs
@@ -0,0 +1,95 @@
+using System;
+using System.Threading;
+using System.Threading.Tasks;
+using Umbraco.Core.Logging;
+
+namespace Umbraco.Core.Runtime
+{
+ ///
+ /// Uses a system-wide Semaphore and EventWaitHandle to synchronize the current AppDomain
+ ///
+ internal class MainDomSemaphoreLock : IMainDomLock
+ {
+ private readonly SystemLock _systemLock;
+
+ // event wait handle used to notify current main domain that it should
+ // release the lock because a new domain wants to be the main domain
+ private readonly EventWaitHandle _signal;
+ private readonly ILogger _logger;
+ private IDisposable _lockRelease;
+
+ public MainDomSemaphoreLock(ILogger logger)
+ {
+ var lockName = "UMBRACO-" + MainDom.GetMainDomId() + "-MAINDOM-LCK";
+ _systemLock = new SystemLock(lockName);
+
+ var eventName = "UMBRACO-" + MainDom.GetMainDomId() + "-MAINDOM-EVT";
+ _signal = new EventWaitHandle(false, EventResetMode.AutoReset, eventName);
+ _logger = logger;
+ }
+
+ //WaitOneAsync (ext method) will wait for a signal without blocking the main thread, the waiting is done on a background thread
+ public Task ListenAsync() => _signal.WaitOneAsync();
+
+ public Task AcquireLockAsync(int millisecondsTimeout)
+ {
+ // signal other instances that we want the lock, then wait on the lock,
+ // which may timeout, and this is accepted - see comments below
+
+ // signal, then wait for the lock, then make sure the event is
+ // reset (maybe there was noone listening..)
+ _signal.Set();
+
+ // if more than 1 instance reach that point, one will get the lock
+ // and the other one will timeout, which is accepted
+
+ //This can throw a TimeoutException - in which case should this be in a try/finally to ensure the signal is always reset.
+ try
+ {
+ _lockRelease = _systemLock.Lock(millisecondsTimeout);
+ return Task.FromResult(true);
+ }
+ catch (TimeoutException ex)
+ {
+ _logger.Error(ex);
+ return Task.FromResult(false);
+ }
+ finally
+ {
+ // we need to reset the event, because otherwise we would end up
+ // signaling ourselves and committing suicide immediately.
+ // only 1 instance can reach that point, but other instances may
+ // have started and be trying to get the lock - they will timeout,
+ // which is accepted
+
+ _signal.Reset();
+ }
+ }
+
+ #region IDisposable Support
+ private bool disposedValue = false; // To detect redundant calls
+
+ protected virtual void Dispose(bool disposing)
+ {
+ if (!disposedValue)
+ {
+ if (disposing)
+ {
+ _lockRelease?.Dispose();
+ _signal.Close();
+ _signal.Dispose();
+ }
+
+ disposedValue = true;
+ }
+ }
+
+ // This code added to correctly implement the disposable pattern.
+ public void Dispose()
+ {
+ // Do not change this code. Put cleanup code in Dispose(bool disposing) above.
+ Dispose(true);
+ }
+ #endregion
+ }
+}
diff --git a/src/Umbraco.Core/Runtime/SqlMainDomLock.cs b/src/Umbraco.Core/Runtime/SqlMainDomLock.cs
new file mode 100644
index 0000000000..4433a8e307
--- /dev/null
+++ b/src/Umbraco.Core/Runtime/SqlMainDomLock.cs
@@ -0,0 +1,413 @@
+using System;
+using System.Data;
+using System.Data.SqlClient;
+using System.Diagnostics;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using Umbraco.Core.Logging;
+using Umbraco.Core.Persistence;
+using Umbraco.Core.Persistence.Dtos;
+using Umbraco.Core.Persistence.Mappers;
+using Umbraco.Core.Persistence.SqlSyntax;
+
+namespace Umbraco.Core.Runtime
+{
+ internal class SqlMainDomLock : IMainDomLock
+ {
+ private string _lockId;
+ private const string MainDomKey = "Umbraco.Core.Runtime.SqlMainDom";
+ private const string UpdatedSuffix = "_updated";
+ private readonly ILogger _logger;
+ private IUmbracoDatabase _db;
+ private CancellationTokenSource _cancellationTokenSource = new CancellationTokenSource();
+ private SqlServerSyntaxProvider _sqlServerSyntax = new SqlServerSyntaxProvider();
+ private bool _mainDomChanging = false;
+ private readonly UmbracoDatabaseFactory _dbFactory;
+ private bool _hasError;
+ private object _locker = new object();
+
+ public SqlMainDomLock(ILogger logger)
+ {
+ // unique id for our appdomain, this is more unique than the appdomain id which is just an INT counter to its safer
+ _lockId = Guid.NewGuid().ToString();
+ _logger = logger;
+ _dbFactory = new UmbracoDatabaseFactory(
+ Constants.System.UmbracoConnectionName,
+ _logger,
+ new Lazy(() => new Persistence.Mappers.MapperCollection(Enumerable.Empty())));
+ }
+
+ public async Task AcquireLockAsync(int millisecondsTimeout)
+ {
+ if (!(_dbFactory.SqlContext.SqlSyntax is SqlServerSyntaxProvider sqlServerSyntaxProvider))
+ throw new NotSupportedException("SqlMainDomLock is only supported for Sql Server");
+
+ _sqlServerSyntax = sqlServerSyntaxProvider;
+
+ _logger.Debug("Acquiring lock...");
+
+ var db = GetDatabase();
+
+ var tempId = Guid.NewGuid().ToString();
+
+ try
+ {
+ db.BeginTransaction(IsolationLevel.ReadCommitted);
+
+ try
+ {
+ // wait to get a write lock
+ _sqlServerSyntax.WriteLock(db, TimeSpan.FromMilliseconds(millisecondsTimeout), Constants.Locks.MainDom);
+ }
+ catch (Exception ex)
+ {
+ if (IsLockTimeoutException(ex))
+ {
+ _logger.Error(ex, "Sql timeout occurred, could not acquire MainDom.");
+ _hasError = true;
+ return false;
+ }
+
+ // unexpected (will be caught below)
+ throw;
+ }
+
+ var result = InsertLockRecord(tempId); //we change the row to a random Id to signal other MainDom to shutdown
+ if (result == RecordPersistenceType.Insert)
+ {
+ // if we've inserted, then there was no MainDom so we can instantly acquire
+
+ // TODO: see the other TODO, could we just delete the row and that would indicate that we
+ // are MainDom? then we don't leave any orphan rows behind.
+
+ InsertLockRecord(_lockId); // so update with our appdomain id
+ _logger.Debug("Acquired with ID {LockId}", _lockId);
+ return true;
+ }
+
+ // if we've updated, this means there is an active MainDom, now we need to wait to
+ // for the current MainDom to shutdown which also requires releasing our write lock
+ }
+ catch (Exception ex)
+ {
+ ResetDatabase();
+ // unexpected
+ _logger.Error(ex, "Unexpected error, cannot acquire MainDom");
+ _hasError = true;
+ return false;
+ }
+ finally
+ {
+ db?.CompleteTransaction();
+ }
+
+ return await WaitForExistingAsync(tempId, millisecondsTimeout);
+ }
+
+ public Task ListenAsync()
+ {
+ if (_hasError)
+ {
+ _logger.Warn("Could not acquire MainDom, listening is canceled.");
+ return Task.CompletedTask;
+ }
+
+ // Create a long running task (dedicated thread)
+ // to poll to check if we are still the MainDom registered in the DB
+ return Task.Factory.StartNew(ListeningLoop, _cancellationTokenSource.Token, TaskCreationOptions.LongRunning, TaskScheduler.Default);
+
+ }
+
+ private void ListeningLoop()
+ {
+ while (true)
+ {
+ // poll every 1 second
+ Thread.Sleep(1000);
+
+ lock (_locker)
+ {
+ // If cancellation has been requested we will just exit. Depending on timing of the shutdown,
+ // we will have already flagged _mainDomChanging = true, or we're shutting down faster than
+ // the other MainDom is taking to startup. In this case the db row will just be deleted and the
+ // new MainDom will just take over.
+ if (_cancellationTokenSource.IsCancellationRequested)
+ return;
+
+ var db = GetDatabase();
+
+ try
+ {
+ db.BeginTransaction(IsolationLevel.ReadCommitted);
+
+ // get a read lock
+ _sqlServerSyntax.ReadLock(db, Constants.Locks.MainDom);
+
+ // TODO: We could in theory just check if the main dom row doesn't exist, that could indicate that
+ // we are still the maindom. An empty value might be better because then we won't have any orphan rows
+ // if the app is terminated. Could that work?
+
+ if (!IsMainDomValue(_lockId))
+ {
+ // we are no longer main dom, another one has come online, exit
+ _mainDomChanging = true;
+ _logger.Debug("Detected new booting application, releasing MainDom lock.");
+ return;
+ }
+ }
+ catch (Exception ex)
+ {
+ ResetDatabase();
+ // unexpected
+ _logger.Error(ex, "Unexpected error, listening is canceled.");
+ _hasError = true;
+ return;
+ }
+ finally
+ {
+ db?.CompleteTransaction();
+ }
+ }
+
+ }
+ }
+
+ private void ResetDatabase()
+ {
+ if (_db.InTransaction)
+ _db.AbortTransaction();
+ _db.Dispose();
+ _db = null;
+ }
+
+ private IUmbracoDatabase GetDatabase()
+ {
+ if (_db != null)
+ return _db;
+
+ _db = _dbFactory.CreateDatabase();
+ return _db;
+ }
+
+ ///
+ /// Wait for any existing MainDom to release so we can continue booting
+ ///
+ ///
+ ///
+ ///
+ private Task WaitForExistingAsync(string tempId, int millisecondsTimeout)
+ {
+ var updatedTempId = tempId + UpdatedSuffix;
+
+ return Task.Run(() =>
+ {
+ var db = GetDatabase();
+ var watch = new Stopwatch();
+ watch.Start();
+ while(true)
+ {
+ // poll very often, we need to take over as fast as we can
+ Thread.Sleep(100);
+
+ try
+ {
+ db.BeginTransaction(IsolationLevel.ReadCommitted);
+
+ // get a read lock
+ _sqlServerSyntax.ReadLock(db, Constants.Locks.MainDom);
+
+ // the row
+ var mainDomRows = db.Fetch("SELECT * FROM umbracoKeyValue WHERE [key] = @key", new { key = MainDomKey });
+
+ if (mainDomRows.Count == 0 || mainDomRows[0].Value == updatedTempId)
+ {
+ // the other main dom has updated our record
+ // Or the other maindom shutdown super fast and just deleted the record
+ // which indicates that we
+ // can acquire it and it has shutdown.
+
+ _sqlServerSyntax.WriteLock(db, Constants.Locks.MainDom);
+
+ // so now we update the row with our appdomain id
+ InsertLockRecord(_lockId);
+ _logger.Debug("Acquired with ID {LockId}", _lockId);
+ return true;
+ }
+ else if (mainDomRows.Count == 1 && !mainDomRows[0].Value.StartsWith(tempId))
+ {
+ // in this case, the prefixed ID is different which means
+ // another new AppDomain has come online and is wanting to take over. In that case, we will not
+ // acquire.
+
+ _logger.Debug("Cannot acquire, another booting application detected.");
+
+ return false;
+ }
+ }
+ catch (Exception ex)
+ {
+ ResetDatabase();
+
+ if (IsLockTimeoutException(ex))
+ {
+ _logger.Error(ex, "Sql timeout occurred, waiting for existing MainDom is canceled.");
+ _hasError = true;
+ return false;
+ }
+ // unexpected
+ _logger.Error(ex, "Unexpected error, waiting for existing MainDom is canceled.");
+ _hasError = true;
+ return false;
+ }
+ finally
+ {
+ db?.CompleteTransaction();
+ }
+
+ if (watch.ElapsedMilliseconds >= millisecondsTimeout)
+ {
+ // if the timeout has elapsed, it either means that the other main dom is taking too long to shutdown,
+ // or it could mean that the previous appdomain was terminated and didn't clear out the main dom SQL row
+ // and it's just been left as an orphan row.
+ // There's really know way of knowing unless we are constantly updating the row for the current maindom
+ // which isn't ideal.
+ // So... we're going to 'just' take over, if the writelock works then we'll assume we're ok
+
+ _logger.Debug("Timeout elapsed, assuming orphan row, acquiring MainDom.");
+
+ try
+ {
+ db.BeginTransaction(IsolationLevel.ReadCommitted);
+
+ _sqlServerSyntax.WriteLock(db, Constants.Locks.MainDom);
+
+ // so now we update the row with our appdomain id
+ InsertLockRecord(_lockId);
+ _logger.Debug("Acquired with ID {LockId}", _lockId);
+ return true;
+ }
+ catch (Exception ex)
+ {
+ ResetDatabase();
+
+ if (IsLockTimeoutException(ex))
+ {
+ // something is wrong, we cannot acquire, not much we can do
+ _logger.Error(ex, "Sql timeout occurred, could not forcibly acquire MainDom.");
+ _hasError = true;
+ return false;
+ }
+ _logger.Error(ex, "Unexpected error, could not forcibly acquire MainDom.");
+ _hasError = true;
+ return false;
+ }
+ finally
+ {
+ db?.CompleteTransaction();
+ }
+ }
+ }
+ }, _cancellationTokenSource.Token);
+ }
+
+ ///
+ /// Inserts or updates the key/value row
+ ///
+ private RecordPersistenceType InsertLockRecord(string id)
+ {
+ var db = GetDatabase();
+ return db.InsertOrUpdate(new KeyValueDto
+ {
+ Key = MainDomKey,
+ Value = id,
+ Updated = DateTime.Now
+ });
+ }
+
+ ///
+ /// Checks if the DB row value is equals the value
+ ///
+ ///
+ private bool IsMainDomValue(string val)
+ {
+ var db = GetDatabase();
+ return db.ExecuteScalar("SELECT COUNT(*) FROM umbracoKeyValue WHERE [key] = @key AND [value] = @val",
+ new { key = MainDomKey, val = val }) == 1;
+ }
+
+ ///
+ /// Checks if the exception is an SQL timeout
+ ///
+ ///
+ ///
+ private bool IsLockTimeoutException(Exception exception) => exception is SqlException sqlException && sqlException.Number == 1222;
+
+ #region IDisposable Support
+ private bool _disposedValue = false; // To detect redundant calls
+
+ protected virtual void Dispose(bool disposing)
+ {
+ if (!_disposedValue)
+ {
+ if (disposing)
+ {
+ lock (_locker)
+ {
+ // immediately cancel all sub-tasks, we don't want them to keep querying
+ _cancellationTokenSource.Cancel();
+ _cancellationTokenSource.Dispose();
+
+ var db = GetDatabase();
+ try
+ {
+ db.BeginTransaction(IsolationLevel.ReadCommitted);
+
+ // get a write lock
+ _sqlServerSyntax.WriteLock(db, Constants.Locks.MainDom);
+
+ // When we are disposed, it means we have released the MainDom lock
+ // and called all MainDom release callbacks, in this case
+ // if another maindom is actually coming online we need
+ // to signal to the MainDom coming online that we have shutdown.
+ // To do that, we update the existing main dom DB record with a suffixed "_updated" string.
+ // Otherwise, if we are just shutting down, we want to just delete the row.
+ if (_mainDomChanging)
+ {
+ _logger.Debug("Releasing MainDom, updating row, new application is booting.");
+ db.Execute($"UPDATE umbracoKeyValue SET [value] = [value] + '{UpdatedSuffix}' WHERE [key] = @key", new { key = MainDomKey });
+ }
+ else
+ {
+ _logger.Debug("Releasing MainDom, deleting row, application is shutting down.");
+ db.Execute("DELETE FROM umbracoKeyValue WHERE [key] = @key", new { key = MainDomKey });
+ }
+ }
+ catch (Exception ex)
+ {
+ ResetDatabase();
+ _logger.Error(ex, "Unexpected error during dipsose.");
+ _hasError = true;
+ }
+ finally
+ {
+ db?.CompleteTransaction();
+ ResetDatabase();
+ }
+ }
+ }
+
+ _disposedValue = true;
+ }
+ }
+
+ // This code added to correctly implement the disposable pattern.
+ public void Dispose()
+ {
+ // Do not change this code. Put cleanup code in Dispose(bool disposing) above.
+ Dispose(true);
+ }
+ #endregion
+
+ }
+}
diff --git a/src/Umbraco.Core/RuntimeState.cs b/src/Umbraco.Core/RuntimeState.cs
index 5d34fe70a1..74ec70828b 100644
--- a/src/Umbraco.Core/RuntimeState.cs
+++ b/src/Umbraco.Core/RuntimeState.cs
@@ -1,8 +1,8 @@
using System;
-using System.Collections.Generic;
using System.Threading;
using System.Web;
using Semver;
+using Umbraco.Core.Collections;
using Umbraco.Core.Configuration;
using Umbraco.Core.Configuration.UmbracoSettings;
using Umbraco.Core.Exceptions;
@@ -22,7 +22,7 @@ namespace Umbraco.Core
private readonly ILogger _logger;
private readonly IUmbracoSettingsSection _settings;
private readonly IGlobalSettings _globalSettings;
- private readonly HashSet _applicationUrls = new HashSet();
+ private readonly ConcurrentHashSet _applicationUrls = new ConcurrentHashSet();
private readonly Lazy _mainDom;
private readonly Lazy _serverRegistrar;
diff --git a/src/Umbraco.Core/Scoping/IScopeProvider.cs b/src/Umbraco.Core/Scoping/IScopeProvider.cs
index 6c9eb63ba0..96bb939f8e 100644
--- a/src/Umbraco.Core/Scoping/IScopeProvider.cs
+++ b/src/Umbraco.Core/Scoping/IScopeProvider.cs
@@ -13,7 +13,7 @@ namespace Umbraco.Core.Scoping
/// Provides scopes.
///
public interface IScopeProvider
- {
+ {
///
/// Creates an ambient scope.
///
diff --git a/src/Umbraco.Core/Services/IContentTypeServiceBase.cs b/src/Umbraco.Core/Services/IContentTypeServiceBase.cs
index 51e5d756eb..6ed3c85e91 100644
--- a/src/Umbraco.Core/Services/IContentTypeServiceBase.cs
+++ b/src/Umbraco.Core/Services/IContentTypeServiceBase.cs
@@ -39,6 +39,11 @@ namespace Umbraco.Core.Services
int Count();
+ ///
+ /// Returns true or false depending on whether content nodes have been created based on the provided content type id.
+ ///
+ bool HasContentNodes(int id);
+
IEnumerable GetAll(params int[] ids);
IEnumerable GetAll(IEnumerable ids);
diff --git a/src/Umbraco.Core/Services/IRelationService.cs b/src/Umbraco.Core/Services/IRelationService.cs
index ef22632d6e..bf8bcd5b2a 100644
--- a/src/Umbraco.Core/Services/IRelationService.cs
+++ b/src/Umbraco.Core/Services/IRelationService.cs
@@ -8,136 +8,162 @@ namespace Umbraco.Core.Services
public interface IRelationService : IService
{
///
- /// Gets a by its Id
+ /// Gets a by its Id
///
- /// Id of the
- /// A object
+ /// Id of the
+ /// A object
IRelation GetById(int id);
///
- /// Gets a by its Id
+ /// Gets a by its Id
///
- /// Id of the
- /// A object
+ /// Id of the
+ /// A object
IRelationType GetRelationTypeById(int id);
///
- /// Gets a by its Id
+ /// Gets a by its Id
///
- /// Id of the
- /// A object
+ /// Id of the
+ /// A object
IRelationType GetRelationTypeById(Guid id);
///
- /// Gets a by its Alias
+ /// Gets a by its Alias
///
- /// Alias of the
- /// A object
+ /// Alias of the
+ /// A object
IRelationType GetRelationTypeByAlias(string alias);
///
- /// Gets all objects
+ /// Gets all objects
///
/// Optional array of integer ids to return relations for
- /// An enumerable list of objects
+ /// An enumerable list of objects
IEnumerable GetAllRelations(params int[] ids);
///
- /// Gets all objects by their
+ /// Gets all objects by their
///
- /// to retrieve Relations for
- /// An enumerable list of objects
- IEnumerable GetAllRelationsByRelationType(RelationType relationType);
+ /// to retrieve Relations for
+ /// An enumerable list of objects
+ IEnumerable GetAllRelationsByRelationType(IRelationType relationType);
///
- /// Gets all objects by their 's Id
+ /// Gets all objects by their 's Id
///
- /// Id of the to retrieve Relations for
- /// An enumerable list of objects
+ /// Id of the to retrieve Relations for
+ /// An enumerable list of objects
IEnumerable GetAllRelationsByRelationType(int relationTypeId);
///
- /// Gets all objects
+ /// Gets all objects
///
/// Optional array of integer ids to return relationtypes for
- /// An enumerable list of objects
+ /// An enumerable list of objects
IEnumerable GetAllRelationTypes(params int[] ids);
///
- /// Gets a list of objects by their parent Id
+ /// Gets a list of objects by their parent Id
///
/// Id of the parent to retrieve relations for
- /// An enumerable list of objects
+ /// An enumerable list of objects
IEnumerable GetByParentId(int id);
///
- /// Gets a list of objects by their parent entity
+ /// Gets a list of objects by their parent Id
+ ///
+ /// Id of the parent to retrieve relations for
+ /// Alias of the type of relation to retrieve
+ /// An enumerable list of objects
+ IEnumerable GetByParentId(int id, string relationTypeAlias);
+
+ ///
+ /// Gets a list of objects by their parent entity
///
/// Parent Entity to retrieve relations for
- /// An enumerable list of objects
+ /// An enumerable list of objects
IEnumerable GetByParent(IUmbracoEntity parent);
///
- /// Gets a list of objects by their parent entity
+ /// Gets a list of objects by their parent entity
///
/// Parent Entity to retrieve relations for
/// Alias of the type of relation to retrieve
- /// An enumerable list of objects
+ /// An enumerable list of objects
IEnumerable GetByParent(IUmbracoEntity parent, string relationTypeAlias);
///
- /// Gets a list of objects by their child Id
+ /// Gets a list of objects by their child Id
///
/// Id of the child to retrieve relations for
- /// An enumerable list of objects
+ /// An enumerable list of objects
IEnumerable GetByChildId(int id);
///
- /// Gets a list of objects by their child Entity
+ /// Gets a list of objects by their child Id
+ ///
+ /// Id of the child to retrieve relations for
+ /// Alias of the type of relation to retrieve
+ /// An enumerable list of objects
+ IEnumerable GetByChildId(int id, string relationTypeAlias);
+
+ ///
+ /// Gets a list of objects by their child Entity
///
/// Child Entity to retrieve relations for
- /// An enumerable list of objects
+ /// An enumerable list of objects
IEnumerable GetByChild(IUmbracoEntity child);
///
- /// Gets a list of objects by their child Entity
+ /// Gets a list of objects by their child Entity
///
/// Child Entity to retrieve relations for
/// Alias of the type of relation to retrieve
- /// An enumerable list of objects
+ /// An enumerable list of objects
IEnumerable GetByChild(IUmbracoEntity child, string relationTypeAlias);
///
- /// Gets a list of objects by their child or parent Id.
+ /// Gets a list of objects by their child or parent Id.
/// Using this method will get you all relations regards of it being a child or parent relation.
///
/// Id of the child or parent to retrieve relations for
- /// An enumerable list of objects
+ /// An enumerable list of objects
IEnumerable GetByParentOrChildId(int id);
IEnumerable GetByParentOrChildId(int id, string relationTypeAlias);
///
- /// Gets a list of objects by the Name of the
+ /// Gets a list of objects by the Name of the
///
- /// Name of the to retrieve Relations for
- /// An enumerable list of objects
+ /// Name of the to retrieve Relations for
+ /// An enumerable list of objects
IEnumerable GetByRelationTypeName(string relationTypeName);
///
- /// Gets a list of objects by the Alias of the
+ /// Gets a list of objects by the Alias of the
///
- /// Alias of the to retrieve Relations for
- /// An enumerable list of objects
+ /// Alias of the to retrieve Relations for
+ /// An enumerable list of objects
IEnumerable GetByRelationTypeAlias(string relationTypeAlias);
///
- /// Gets a list of objects by the Id of the
+ /// Gets a list of objects by the Id of the
///
- /// Id of the to retrieve Relations for
- /// An enumerable list of objects
+ /// Id of the to retrieve Relations for
+ /// An enumerable list of objects
IEnumerable GetByRelationTypeId(int relationTypeId);
+ ///
+ /// Gets a paged result of
+ ///
+ ///
+ ///
+ ///
+ ///
+ ///
+ IEnumerable GetPagedByRelationTypeId(int relationTypeId, long pageIndex, int pageSize, out long totalRecords, Ordering ordering = null);
+
///
/// Gets the Child object from a Relation as an
///
@@ -173,6 +199,26 @@ namespace Umbraco.Core.Services
/// An enumerable list of
IEnumerable GetParentEntitiesFromRelations(IEnumerable relations);
+ ///
+ /// Returns paged parent entities for a related child id
+ ///
+ ///
+ ///
+ ///
+ ///
+ ///
+ IEnumerable GetPagedParentEntitiesByChildId(int id, long pageIndex, int pageSize, out long totalChildren, params UmbracoObjectTypes[] entityTypes);
+
+ ///
+ /// Returns paged child entities for a related parent id
+ ///
+ ///
+ ///
+ ///
+ ///
+ ///
+ IEnumerable GetPagedChildEntitiesByParentId(int id, long pageIndex, int pageSize, out long totalChildren, params UmbracoObjectTypes[] entityTypes);
+
///
/// Gets the Parent and Child objects from a list of Relations as a list of objects.
///
@@ -186,7 +232,7 @@ namespace Umbraco.Core.Services
/// Id of the parent
/// Id of the child
/// The type of relation to create
- /// The created
+ /// The created
IRelation Relate(int parentId, int childId, IRelationType relationType);
///
@@ -195,7 +241,7 @@ namespace Umbraco.Core.Services
/// Parent entity
/// Child entity
/// The type of relation to create
- /// The created
+ /// The created
IRelation Relate(IUmbracoEntity parent, IUmbracoEntity child, IRelationType relationType);
///
@@ -204,7 +250,7 @@ namespace Umbraco.Core.Services
/// Id of the parent
/// Id of the child
/// Alias of the type of relation to create
- /// The created
+ /// The created
IRelation Relate(int parentId, int childId, string relationTypeAlias);
///
@@ -213,14 +259,14 @@ namespace Umbraco.Core.Services
/// Parent entity
/// Child entity
/// Alias of the type of relation to create
- /// The created
+ /// The created
IRelation Relate(IUmbracoEntity parent, IUmbracoEntity child, string relationTypeAlias);
///
- /// Checks whether any relations exists for the passed in .
+ /// Checks whether any relations exists for the passed in .
///
- /// to check for relations
- /// Returns True if any relations exists for the given , otherwise False
+ /// to check for relations
+ /// Returns True if any relations exists for the given , otherwise False
bool HasRelations(IRelationType relationType);
///
@@ -265,33 +311,35 @@ namespace Umbraco.Core.Services
bool AreRelated(int parentId, int childId, string relationTypeAlias);
///
- /// Saves a
+ /// Saves a
///
/// Relation to save
void Save(IRelation relation);
+ void Save(IEnumerable relations);
+
///
- /// Saves a
+ /// Saves a
///
/// RelationType to Save
void Save(IRelationType relationType);
///
- /// Deletes a
+ /// Deletes a
///
/// Relation to Delete
void Delete(IRelation relation);
///
- /// Deletes a
+ /// Deletes a
///
/// RelationType to Delete
void Delete(IRelationType relationType);
///
- /// Deletes all objects based on the passed in
+ /// Deletes all objects based on the passed in
///
- /// to Delete Relations for
+ /// to Delete Relations for
void DeleteRelationsOfType(IRelationType relationType);
}
}
diff --git a/src/Umbraco.Core/Services/Implement/AuditService.cs b/src/Umbraco.Core/Services/Implement/AuditService.cs
index 5eb08f2dea..7d3be1d52b 100644
--- a/src/Umbraco.Core/Services/Implement/AuditService.cs
+++ b/src/Umbraco.Core/Services/Implement/AuditService.cs
@@ -142,7 +142,7 @@ namespace Umbraco.Core.Services.Implement
if (pageIndex < 0) throw new ArgumentOutOfRangeException(nameof(pageIndex));
if (pageSize <= 0) throw new ArgumentOutOfRangeException(nameof(pageSize));
- if (userId < 0)
+ if (userId < Constants.Security.SuperUserId)
{
totalRecords = 0;
return Enumerable.Empty();
diff --git a/src/Umbraco.Core/Services/Implement/ContentTypeServiceBaseOfTRepositoryTItemTService.cs b/src/Umbraco.Core/Services/Implement/ContentTypeServiceBaseOfTRepositoryTItemTService.cs
index 7ae330f8f1..da532e2765 100644
--- a/src/Umbraco.Core/Services/Implement/ContentTypeServiceBaseOfTRepositoryTItemTService.cs
+++ b/src/Umbraco.Core/Services/Implement/ContentTypeServiceBaseOfTRepositoryTItemTService.cs
@@ -372,6 +372,15 @@ namespace Umbraco.Core.Services.Implement
}
}
+ public bool HasContentNodes(int id)
+ {
+ using (var scope = ScopeProvider.CreateScope(autoComplete: true))
+ {
+ scope.ReadLock(ReadLockIds);
+ return Repository.HasContentNodes(id);
+ }
+ }
+
#endregion
#region Save
diff --git a/src/Umbraco.Core/Services/Implement/RelationService.cs b/src/Umbraco.Core/Services/Implement/RelationService.cs
index 405c3a2800..4b53709de9 100644
--- a/src/Umbraco.Core/Services/Implement/RelationService.cs
+++ b/src/Umbraco.Core/Services/Implement/RelationService.cs
@@ -25,11 +25,7 @@ namespace Umbraco.Core.Services.Implement
_entityService = entityService ?? throw new ArgumentNullException(nameof(entityService));
}
- ///
- /// Gets a by its Id
- ///
- /// Id of the
- /// A object
+ ///
public IRelation GetById(int id)
{
using (var scope = ScopeProvider.CreateScope(autoComplete: true))
@@ -38,11 +34,7 @@ namespace Umbraco.Core.Services.Implement
}
}
- ///
- /// Gets a by its Id
- ///
- /// Id of the
- /// A object
+ ///
public IRelationType GetRelationTypeById(int id)
{
using (var scope = ScopeProvider.CreateScope(autoComplete: true))
@@ -51,11 +43,7 @@ namespace Umbraco.Core.Services.Implement
}
}
- ///
- /// Gets a by its Id
- ///
- /// Id of the
- /// A object
+ ///
public IRelationType GetRelationTypeById(Guid id)
{
using (var scope = ScopeProvider.CreateScope(autoComplete: true))
@@ -64,25 +52,10 @@ namespace Umbraco.Core.Services.Implement
}
}
- ///
- /// Gets a by its Alias
- ///
- /// Alias of the
- /// A object
- public IRelationType GetRelationTypeByAlias(string alias)
- {
- using (var scope = ScopeProvider.CreateScope(autoComplete: true))
- {
- var query = Query().Where(x => x.Alias == alias);
- return _relationTypeRepository.Get(query).FirstOrDefault();
- }
- }
+ ///
+ public IRelationType GetRelationTypeByAlias(string alias) => GetRelationType(alias);
- ///
- /// Gets all objects
- ///
- /// Optional array of integer ids to return relations for
- /// An enumerable list of objects
+ ///
public IEnumerable GetAllRelations(params int[] ids)
{
using (var scope = ScopeProvider.CreateScope(autoComplete: true))
@@ -91,21 +64,13 @@ namespace Umbraco.Core.Services.Implement
}
}
- ///
- /// Gets all objects by their
- ///
- /// to retrieve Relations for
- /// An enumerable list of objects
- public IEnumerable GetAllRelationsByRelationType(RelationType relationType)
+ ///
+ public IEnumerable GetAllRelationsByRelationType(IRelationType relationType)
{
return GetAllRelationsByRelationType(relationType.Id);
}
- ///
- /// Gets all objects by their 's Id
- ///
- /// Id of the to retrieve Relations for
- /// An enumerable list of objects
+ ///
public IEnumerable GetAllRelationsByRelationType(int relationTypeId)
{
using (var scope = ScopeProvider.CreateScope(autoComplete: true))
@@ -115,11 +80,7 @@ namespace Umbraco.Core.Services.Implement
}
}
- ///
- /// Gets all objects
- ///
- /// Optional array of integer ids to return relationtypes for
- /// An enumerable list of objects
+ ///
public IEnumerable GetAllRelationTypes(params int[] ids)
{
using (var scope = ScopeProvider.CreateScope(autoComplete: true))
@@ -128,82 +89,65 @@ namespace Umbraco.Core.Services.Implement
}
}
- ///
- /// Gets a list of objects by their parent Id
- ///
- /// Id of the parent to retrieve relations for
- /// An enumerable list of objects
- public IEnumerable GetByParentId(int id)
+ ///
+ public IEnumerable GetByParentId(int id) => GetByParentId(id, null);
+
+ ///
+ public IEnumerable GetByParentId(int id, string relationTypeAlias)
{
using (var scope = ScopeProvider.CreateScope(autoComplete: true))
{
- var query = Query().Where(x => x.ParentId == id);
- return _relationRepository.Get(query);
+ if (relationTypeAlias.IsNullOrWhiteSpace())
+ {
+ var qry1 = Query().Where(x => x.ParentId == id);
+ return _relationRepository.Get(qry1);
+ }
+
+ var relationType = GetRelationType(relationTypeAlias);
+ if (relationType == null)
+ return Enumerable.Empty();
+
+ var qry2 = Query().Where(x => x.ParentId == id && x.RelationTypeId == relationType.Id);
+ return _relationRepository.Get(qry2);
}
}
- ///
- /// Gets a list of objects by their parent entity
- ///
- /// Parent Entity to retrieve relations for
- /// An enumerable list of objects
- public IEnumerable GetByParent(IUmbracoEntity parent)
- {
- return GetByParentId(parent.Id);
- }
+ ///
+ public IEnumerable GetByParent(IUmbracoEntity parent) => GetByParentId(parent.Id);
- ///
- /// Gets a list of objects by their parent entity
- ///
- /// Parent Entity to retrieve relations for
- /// Alias of the type of relation to retrieve
- /// An enumerable list of objects
- public IEnumerable GetByParent(IUmbracoEntity parent, string relationTypeAlias)
- {
- return GetByParent(parent).Where(relation => relation.RelationType.Alias == relationTypeAlias);
- }
+ ///
+ public IEnumerable GetByParent(IUmbracoEntity parent, string relationTypeAlias) => GetByParentId(parent.Id, relationTypeAlias);
- ///
- /// Gets a list of objects by their child Id
- ///
- /// Id of the child to retrieve relations for
- /// An enumerable list of objects
- public IEnumerable GetByChildId(int id)
+ ///
+ public IEnumerable GetByChildId(int id) => GetByChildId(id, null);
+
+ ///
+ public IEnumerable GetByChildId(int id, string relationTypeAlias)
{
using (var scope = ScopeProvider.CreateScope(autoComplete: true))
{
- var query = Query().Where(x => x.ChildId == id);
- return _relationRepository.Get(query);
+ if (relationTypeAlias.IsNullOrWhiteSpace())
+ {
+ var qry1 = Query().Where(x => x.ChildId == id);
+ return _relationRepository.Get(qry1);
+ }
+
+ var relationType = GetRelationType(relationTypeAlias);
+ if (relationType == null)
+ return Enumerable.Empty();
+
+ var qry2 = Query().Where(x => x.ChildId == id && x.RelationTypeId == relationType.Id);
+ return _relationRepository.Get(qry2);
}
}
- ///
- /// Gets a list of objects by their child Entity
- ///
- /// Child Entity to retrieve relations for
- /// An enumerable list of objects
- public IEnumerable GetByChild(IUmbracoEntity child)
- {
- return GetByChildId(child.Id);
- }
+ ///
+ public IEnumerable GetByChild(IUmbracoEntity child) => GetByChildId(child.Id);
- ///
- /// Gets a list of objects by their child Entity
- ///
- /// Child Entity to retrieve relations for
- /// Alias of the type of relation to retrieve
- /// An enumerable list of objects
- public IEnumerable GetByChild(IUmbracoEntity child, string relationTypeAlias)
- {
- return GetByChild(child).Where(relation => relation.RelationType.Alias == relationTypeAlias);
- }
+ ///
+ public IEnumerable GetByChild(IUmbracoEntity child, string relationTypeAlias) => GetByChildId(child.Id, relationTypeAlias);
- ///
- /// Gets a list of objects by their child or parent Id.
- /// Using this method will get you all relations regards of it being a child or parent relation.
- ///
- /// Id of the child or parent to retrieve relations for
- /// An enumerable list of objects
+ ///
public IEnumerable GetByParentOrChildId(int id)
{
using (var scope = ScopeProvider.CreateScope(autoComplete: true))
@@ -217,8 +161,7 @@ namespace Umbraco.Core.Services.Implement
{
using (var scope = ScopeProvider.CreateScope(autoComplete: true))
{
- var rtQuery = Query().Where(x => x.Alias == relationTypeAlias);
- var relationType = _relationTypeRepository.Get(rtQuery).FirstOrDefault();
+ var relationType = GetRelationType(relationTypeAlias);
if (relationType == null)
return Enumerable.Empty();
@@ -227,16 +170,13 @@ namespace Umbraco.Core.Services.Implement
}
}
- ///
- /// Gets a list of objects by the Name of the
- ///
- /// Name of the to retrieve Relations for
- /// An enumerable list of objects
+ ///
public IEnumerable GetByRelationTypeName(string relationTypeName)
{
List relationTypeIds;
using (var scope = ScopeProvider.CreateScope(autoComplete: true))
{
+ //This is a silly query - but i guess it's needed in case someone has more than one relation with the same Name (not alias), odd.
var query = Query().Where(x => x.Name == relationTypeName);
var relationTypes = _relationTypeRepository.Get(query);
relationTypeIds = relationTypes.Select(x => x.Id).ToList();
@@ -247,31 +187,17 @@ namespace Umbraco.Core.Services.Implement
: GetRelationsByListOfTypeIds(relationTypeIds);
}
- ///
- /// Gets a list of objects by the Alias of the
- ///
- /// Alias of the to retrieve Relations for
- /// An enumerable list of objects
+ ///
public IEnumerable GetByRelationTypeAlias(string relationTypeAlias)
{
- List relationTypeIds;
- using (var scope = ScopeProvider.CreateScope(autoComplete: true))
- {
- var query = Query().Where(x => x.Alias == relationTypeAlias);
- var relationTypes = _relationTypeRepository.Get(query);
- relationTypeIds = relationTypes.Select(x => x.Id).ToList();
- }
-
- return relationTypeIds.Count == 0
+ var relationType = GetRelationType(relationTypeAlias);
+
+ return relationType == null
? Enumerable.Empty()
- : GetRelationsByListOfTypeIds(relationTypeIds);
+ : GetRelationsByListOfTypeIds(new[] { relationType.Id });
}
- ///
- /// Gets a list of objects by the Id of the
- ///
- /// Id of the to retrieve Relations for
- /// An enumerable list of objects
+ ///
public IEnumerable GetByRelationTypeId(int relationTypeId)
{
using (var scope = ScopeProvider.CreateScope(autoComplete: true))
@@ -281,37 +207,35 @@ namespace Umbraco.Core.Services.Implement
}
}
- ///
- /// Gets the Child object from a Relation as an
- ///
- /// Relation to retrieve child object from
- /// An
+ ///
+ public IEnumerable GetPagedByRelationTypeId(int relationTypeId, long pageIndex, int pageSize, out long totalRecords, Ordering ordering = null)
+ {
+ using (var scope = ScopeProvider.CreateScope(autoComplete: true))
+ {
+ var query = Query().Where(x => x.RelationTypeId == relationTypeId);
+ return _relationRepository.GetPagedRelationsByQuery(query, pageIndex, pageSize, out totalRecords, ordering);
+ }
+ }
+
+ ///
public IUmbracoEntity GetChildEntityFromRelation(IRelation relation)
{
- var objectType = ObjectTypes.GetUmbracoObjectType(relation.RelationType.ChildObjectType);
+ var objectType = ObjectTypes.GetUmbracoObjectType(relation.ChildObjectType);
return _entityService.Get(relation.ChildId, objectType);
}
- ///
- /// Gets the Parent object from a Relation as an
- ///
- /// Relation to retrieve parent object from
- /// An
+ ///
public IUmbracoEntity GetParentEntityFromRelation(IRelation relation)
{
- var objectType = ObjectTypes.GetUmbracoObjectType(relation.RelationType.ParentObjectType);
+ var objectType = ObjectTypes.GetUmbracoObjectType(relation.ParentObjectType);
return _entityService.Get(relation.ParentId, objectType);
}
- ///
- /// Gets the Parent and Child objects from a Relation as a "/> with .
- ///
- /// Relation to retrieve parent and child object from
- /// Returns a Tuple with Parent (item1) and Child (item2)
+ ///
public Tuple GetEntitiesFromRelation(IRelation relation)
{
- var childObjectType = ObjectTypes.GetUmbracoObjectType(relation.RelationType.ChildObjectType);
- var parentObjectType = ObjectTypes.GetUmbracoObjectType(relation.RelationType.ParentObjectType);
+ var childObjectType = ObjectTypes.GetUmbracoObjectType(relation.ChildObjectType);
+ var parentObjectType = ObjectTypes.GetUmbracoObjectType(relation.ParentObjectType);
var child = _entityService.Get(relation.ChildId, childObjectType);
var parent = _entityService.Get(relation.ParentId, parentObjectType);
@@ -319,45 +243,63 @@ namespace Umbraco.Core.Services.Implement
return new Tuple(parent, child);
}
- ///
- /// Gets the Child objects from a list of Relations as a list of objects.
- ///
- /// List of relations to retrieve child objects from
- /// An enumerable list of
+ ///
public IEnumerable GetChildEntitiesFromRelations(IEnumerable relations)
{
- foreach (var relation in relations)
+ // Trying to avoid full N+1 lookups, so we'll group by the object type and then use the GetAll
+ // method to lookup batches of entities for each parent object type
+
+ foreach (var groupedRelations in relations.GroupBy(x => ObjectTypes.GetUmbracoObjectType(x.ChildObjectType)))
{
- var objectType = ObjectTypes.GetUmbracoObjectType(relation.RelationType.ChildObjectType);
- yield return _entityService.Get(relation.ChildId, objectType);
+ var objectType = groupedRelations.Key;
+ var ids = groupedRelations.Select(x => x.ChildId).ToArray();
+ foreach (var e in _entityService.GetAll(objectType, ids))
+ yield return e;
}
}
- ///
- /// Gets the Parent objects from a list of Relations as a list of objects.
- ///
- /// List of relations to retrieve parent objects from
- /// An enumerable list of
+ ///
public IEnumerable GetParentEntitiesFromRelations(IEnumerable relations)
{
- foreach (var relation in relations)
+ // Trying to avoid full N+1 lookups, so we'll group by the object type and then use the GetAll
+ // method to lookup batches of entities for each parent object type
+
+ foreach (var groupedRelations in relations.GroupBy(x => ObjectTypes.GetUmbracoObjectType(x.ParentObjectType)))
{
- var objectType = ObjectTypes.GetUmbracoObjectType(relation.RelationType.ParentObjectType);
- yield return _entityService.Get(relation.ParentId, objectType);
+ var objectType = groupedRelations.Key;
+ var ids = groupedRelations.Select(x => x.ParentId).ToArray();
+ foreach (var e in _entityService.GetAll(objectType, ids))
+ yield return e;
}
}
- ///
- /// Gets the Parent and Child objects from a list of Relations as a list of objects.
- ///
- /// List of relations to retrieve parent and child objects from
- /// An enumerable list of with
+ ///
+ public IEnumerable GetPagedParentEntitiesByChildId(int id, long pageIndex, int pageSize, out long totalChildren, params UmbracoObjectTypes[] entityTypes)
+ {
+ using (var scope = ScopeProvider.CreateScope(autoComplete: true))
+ {
+ return _relationRepository.GetPagedParentEntitiesByChildId(id, pageIndex, pageSize, out totalChildren, entityTypes.Select(x => x.GetGuid()).ToArray());
+ }
+ }
+
+ ///
+ public IEnumerable GetPagedChildEntitiesByParentId(int id, long pageIndex, int pageSize, out long totalChildren, params UmbracoObjectTypes[] entityTypes)
+ {
+ using (var scope = ScopeProvider.CreateScope(autoComplete: true))
+ {
+ return _relationRepository.GetPagedChildEntitiesByParentId(id, pageIndex, pageSize, out totalChildren, entityTypes.Select(x => x.GetGuid()).ToArray());
+ }
+ }
+
+ ///
public IEnumerable> GetEntitiesFromRelations(IEnumerable relations)
{
+ //TODO: Argh! N+1
+
foreach (var relation in relations)
{
- var childObjectType = ObjectTypes.GetUmbracoObjectType(relation.RelationType.ChildObjectType);
- var parentObjectType = ObjectTypes.GetUmbracoObjectType(relation.RelationType.ParentObjectType);
+ var childObjectType = ObjectTypes.GetUmbracoObjectType(relation.ChildObjectType);
+ var parentObjectType = ObjectTypes.GetUmbracoObjectType(relation.ParentObjectType);
var child = _entityService.Get(relation.ChildId, childObjectType);
var parent = _entityService.Get(relation.ParentId, parentObjectType);
@@ -366,19 +308,15 @@ namespace Umbraco.Core.Services.Implement
}
}
- ///
- /// Relates two objects by their entity Ids.
- ///
- /// Id of the parent
- /// Id of the child
- /// The type of relation to create
- /// The created