diff --git a/.gitignore b/.gitignore index 0073675d82..ebee9f6ae9 100644 --- a/.gitignore +++ b/.gitignore @@ -129,3 +129,4 @@ src/*.boltdata/ /src/Umbraco.Web.UI/Umbraco/Js/canvasdesigner.front.js src/umbraco.sln.ide/* build/UmbracoCms.*/ +src/.vs/ diff --git a/build/Build.proj b/build/Build.proj index bdaa5b9c0c..051e02de5c 100644 --- a/build/Build.proj +++ b/build/Build.proj @@ -68,6 +68,12 @@ .$(BUILD_RELEASE)-$(BUILD_COMMENT) + + .$(BUILD_RELEASE)-$(BUILD_NIGHTLY) + + + .$(BUILD_RELEASE)-$(BUILD_COMMENT)-$(BUILD_NIGHTLY) + Release @@ -271,9 +277,11 @@ $(BUILD_RELEASE) $(BUILD_RELEASE)-$(BUILD_COMMENT) + $(BUILD_RELEASE)-$(BUILD_NIGHTLY) + $(BUILD_RELEASE)-$(BUILD_COMMENT)-$(BUILD_NIGHTLY) - + + + + + + + + diff --git a/build/UmbracoVersion.txt b/build/UmbracoVersion.txt index 6ce8416610..f767faaa60 100644 --- a/build/UmbracoVersion.txt +++ b/build/UmbracoVersion.txt @@ -1,3 +1,3 @@ # Usage: on line 2 put the release version, on line 3 put the version comment (example: beta) 7.3.0 -beta \ No newline at end of file +beta2 \ No newline at end of file diff --git a/src/SolutionInfo.cs b/src/SolutionInfo.cs index 29ba870d90..e4258e943d 100644 --- a/src/SolutionInfo.cs +++ b/src/SolutionInfo.cs @@ -12,4 +12,4 @@ using System.Resources; [assembly: AssemblyVersion("1.0.*")] [assembly: AssemblyFileVersion("7.3.0")] -[assembly: AssemblyInformationalVersion("7.3.0-beta")] \ No newline at end of file +[assembly: AssemblyInformationalVersion("7.3.0-beta2")] \ No newline at end of file diff --git a/src/Umbraco.Core/ApplicationContext.cs b/src/Umbraco.Core/ApplicationContext.cs index aae174106e..b48d4eb5e9 100644 --- a/src/Umbraco.Core/ApplicationContext.cs +++ b/src/Umbraco.Core/ApplicationContext.cs @@ -10,6 +10,7 @@ using Umbraco.Core.Logging; using Umbraco.Core.ObjectResolution; using Umbraco.Core.Profiling; using Umbraco.Core.Services; +using Umbraco.Core.Sync; namespace Umbraco.Core @@ -220,18 +221,46 @@ namespace Umbraco.Core } /// - /// The original/first url that the web application executes + /// The application url. /// /// - /// we need to set the initial url in our ApplicationContext, this is so our keep alive service works and this must - /// exist on a global context because the keep alive service doesn't run in a web context. - /// we are NOT going to put a lock on this because locking will slow down the application and we don't really care - /// if two threads write to this at the exact same time during first page hit. - /// see: http://issues.umbraco.org/issue/U4-2059 + /// The application url is the url that should be used by services to talk to the application, + /// eg keep alive or scheduled publishing services. It must exist on a global context because + /// some of these services may not run within a web context. + /// The format of the application url is: + /// - has a scheme (http or https) + /// - has the SystemDirectories.Umbraco path + /// - does not end with a slash + /// It is initialized on the first request made to the server, by UmbracoModule.EnsureApplicationUrl: + /// - if umbracoSettings:settings/web.routing/@appUrl is set, use the value (new setting) + /// - if umbracoSettings:settings/scheduledTasks/@baseUrl is set, use the value (backward compatibility) + /// - otherwise, use the url of the (first) request. + /// Not locking, does not matter if several threads write to this. + /// See also issues: + /// - http://issues.umbraco.org/issue/U4-2059 + /// - http://issues.umbraco.org/issue/U4-6788 + /// - http://issues.umbraco.org/issue/U4-5728 + /// - http://issues.umbraco.org/issue/U4-5391 /// - internal string OriginalRequestUrl { get; set; } + internal string UmbracoApplicationUrl { + get + { + // if initialized, return + if (_umbracoApplicationUrl != null) return _umbracoApplicationUrl; + // try settings + ServerEnvironmentHelper.TrySetApplicationUrlFromSettings(this, ProfilingLogger.Logger, UmbracoConfig.For.UmbracoSettings()); + // and return what we have, may be null + return _umbracoApplicationUrl; + } + set + { + _umbracoApplicationUrl = value; + } + } + + internal string _umbracoApplicationUrl; // internal for tests private Lazy _configured; private void Init() @@ -257,14 +286,14 @@ namespace Umbraco.Core { //we haven't executed this migration in this environment, so even though the config versions match, // this db has not been updated. - ProfilingLogger.Logger.Debug("The migration for version: '" + currentVersion + " has not been executed, there is no record in the database"); + ProfilingLogger.Logger.Debug(string.Format("The migration for version: '{0} has not been executed, there is no record in the database", currentVersion.ToSemanticString())); ok = false; } } } else { - ProfilingLogger.Logger.Debug("CurrentVersion different from configStatus: '" + currentVersion + "','" + configStatus + "'"); + ProfilingLogger.Logger.Debug(string.Format("CurrentVersion different from configStatus: '{0}','{1}'", currentVersion.ToSemanticString(), configStatus)); } return ok; diff --git a/src/Umbraco.Core/AsyncLock.cs b/src/Umbraco.Core/AsyncLock.cs index 0a9c79a80e..608b19a700 100644 --- a/src/Umbraco.Core/AsyncLock.cs +++ b/src/Umbraco.Core/AsyncLock.cs @@ -63,13 +63,13 @@ namespace Umbraco.Core // for anonymous semaphore, use the unique releaser, else create a new one return _semaphore != null ? _releaser // (IDisposable)new SemaphoreSlimReleaser(_semaphore) - : (IDisposable)new NamedSemaphoreReleaser(_semaphore2); + : new NamedSemaphoreReleaser(_semaphore2); } public Task LockAsync() { var wait = _semaphore != null - ? _semaphore.WaitAsync() + ? _semaphore.WaitAsync() : WaitOneAsync(_semaphore2); return wait.IsCompleted @@ -79,6 +79,19 @@ namespace Umbraco.Core TaskContinuationOptions.ExecuteSynchronously, TaskScheduler.Default); } + public Task LockAsync(int millisecondsTimeout) + { + var wait = _semaphore != null + ? _semaphore.WaitAsync(millisecondsTimeout) + : WaitOneAsync(_semaphore2, millisecondsTimeout); + + return wait.IsCompleted + ? _releaserTask ?? Task.FromResult(CreateReleaser()) // anonymous vs named + : wait.ContinueWith((_, state) => (((AsyncLock)state).CreateReleaser()), + this, CancellationToken.None, + TaskContinuationOptions.ExecuteSynchronously, TaskScheduler.Default); + } + public IDisposable Lock() { if (_semaphore != null) @@ -174,7 +187,7 @@ namespace Umbraco.Core // F# has a AwaitWaitHandle method that accepts a time out... and seems pretty complex... // version below should be OK - private static Task WaitOneAsync(WaitHandle handle) + private static Task WaitOneAsync(WaitHandle handle, int millisecondsTimeout = Timeout.Infinite) { var tcs = new TaskCompletionSource(); var callbackHandleInitLock = new object(); @@ -197,7 +210,7 @@ namespace Umbraco.Core } }, /*state:*/ null, - /*millisecondsTimeOutInterval:*/ Timeout.Infinite, + /*millisecondsTimeOutInterval:*/ millisecondsTimeout, /*executeOnlyOnce:*/ true); } diff --git a/src/Umbraco.Core/Configuration/GlobalSettings.cs b/src/Umbraco.Core/Configuration/GlobalSettings.cs index 329fa598c1..2c3855727b 100644 --- a/src/Umbraco.Core/Configuration/GlobalSettings.cs +++ b/src/Umbraco.Core/Configuration/GlobalSettings.cs @@ -429,7 +429,7 @@ namespace Umbraco.Core.Configuration try { string configStatus = ConfigurationStatus; - string currentVersion = UmbracoVersion.GetSemanticVersion().ToString(); + string currentVersion = UmbracoVersion.GetSemanticVersion().ToSemanticString(); if (currentVersion != configStatus) @@ -596,7 +596,7 @@ namespace Umbraco.Core.Configuration [Obsolete("Use Umbraco.Core.Configuration.UmbracoVersion.Current instead", false)] public static string CurrentVersion { - get { return UmbracoVersion.GetSemanticVersion().ToString(); } + get { return UmbracoVersion.GetSemanticVersion().ToSemanticString(); } } /// diff --git a/src/Umbraco.Core/Configuration/UmbracoSettings/IWebRoutingSection.cs b/src/Umbraco.Core/Configuration/UmbracoSettings/IWebRoutingSection.cs index f3d42b6904..2998fc2f78 100644 --- a/src/Umbraco.Core/Configuration/UmbracoSettings/IWebRoutingSection.cs +++ b/src/Umbraco.Core/Configuration/UmbracoSettings/IWebRoutingSection.cs @@ -11,6 +11,8 @@ bool DisableFindContentByIdPath { get; } string UrlProviderMode { get; } + + string UmbracoApplicationUrl { get; } } } \ No newline at end of file diff --git a/src/Umbraco.Core/Configuration/UmbracoSettings/WebRoutingElement.cs b/src/Umbraco.Core/Configuration/UmbracoSettings/WebRoutingElement.cs index f5b71eb2c7..1ed9bc034c 100644 --- a/src/Umbraco.Core/Configuration/UmbracoSettings/WebRoutingElement.cs +++ b/src/Umbraco.Core/Configuration/UmbracoSettings/WebRoutingElement.cs @@ -30,8 +30,13 @@ namespace Umbraco.Core.Configuration.UmbracoSettings [ConfigurationProperty("urlProviderMode", DefaultValue = "AutoLegacy")] public string UrlProviderMode { - get { return (string)base["urlProviderMode"]; } + get { return (string) base["urlProviderMode"]; } } + [ConfigurationProperty("umbracoApplicationUrl", DefaultValue = null)] + public string UmbracoApplicationUrl + { + get { return (string)base["umbracoApplicationUrl"]; } + } } } \ No newline at end of file diff --git a/src/Umbraco.Core/Configuration/UmbracoVersion.cs b/src/Umbraco.Core/Configuration/UmbracoVersion.cs index d96b9f146b..49bea68719 100644 --- a/src/Umbraco.Core/Configuration/UmbracoVersion.cs +++ b/src/Umbraco.Core/Configuration/UmbracoVersion.cs @@ -24,7 +24,7 @@ namespace Umbraco.Core.Configuration /// Gets the version comment (like beta or RC). /// /// The version comment. - public static string CurrentComment { get { return "beta.2"; } } + public static string CurrentComment { get { return "beta2"; } } // Get the version of the umbraco.dll by looking at a class in that dll // Had to do it like this due to medium trust issues, see: http://haacked.com/archive/2010/11/04/assembly-location-and-medium-trust.aspx diff --git a/src/Umbraco.Core/Constants-Conventions.cs b/src/Umbraco.Core/Constants-Conventions.cs index c1d5bd35e3..3456ff1cfa 100644 --- a/src/Umbraco.Core/Constants-Conventions.cs +++ b/src/Umbraco.Core/Constants-Conventions.cs @@ -27,6 +27,7 @@ namespace Umbraco.Core /// /// The root id for all top level dictionary items /// + [Obsolete("There is no dictionary root item id anymore, it is simply null")] public const string DictionaryItemRootId = "41c7638d-f529-4bff-853e-59a0c2fb1bde"; } diff --git a/src/Umbraco.Core/Constants-Web.cs b/src/Umbraco.Core/Constants-Web.cs index 0d7c2f41da..13dee96b97 100644 --- a/src/Umbraco.Core/Constants-Web.cs +++ b/src/Umbraco.Core/Constants-Web.cs @@ -26,6 +26,7 @@ public const string BackOfficeExternalAuthenticationType = "UmbracoExternalCookie"; public const string BackOfficeExternalCookieName = "UMB_EXTLOGIN"; public const string BackOfficeTokenAuthenticationType = "UmbracoBackOfficeToken"; + public const string BackOfficeTwoFactorAuthenticationType = "UmbracoTwoFactorCookie"; /// /// The prefix used for external identity providers for their authentication type diff --git a/src/Umbraco.Core/CoreBootManager.cs b/src/Umbraco.Core/CoreBootManager.cs index 8f09fbc2bf..998bda32f2 100644 --- a/src/Umbraco.Core/CoreBootManager.cs +++ b/src/Umbraco.Core/CoreBootManager.cs @@ -76,7 +76,9 @@ namespace Umbraco.Core _profilingLogger = new ProfilingLogger(LoggerResolver.Current.Logger, ProfilerResolver.Current.Profiler); - _timer = _profilingLogger.TraceDuration("Umbraco application starting", "Umbraco application startup complete"); + _timer = _profilingLogger.TraceDuration( + string.Format("Umbraco application ({0}) starting", UmbracoVersion.GetSemanticVersion().ToSemanticString()), + "Umbraco application startup complete"); CreateApplicationCache(); diff --git a/src/Umbraco.Core/Logging/AppDomainTokenFormatter.cs b/src/Umbraco.Core/Logging/AppDomainTokenConverter.cs similarity index 100% rename from src/Umbraco.Core/Logging/AppDomainTokenFormatter.cs rename to src/Umbraco.Core/Logging/AppDomainTokenConverter.cs diff --git a/src/Umbraco.Core/Logging/AsyncForwardingAppenderBase.cs b/src/Umbraco.Core/Logging/AsyncForwardingAppenderBase.cs new file mode 100644 index 0000000000..74a1de81f4 --- /dev/null +++ b/src/Umbraco.Core/Logging/AsyncForwardingAppenderBase.cs @@ -0,0 +1,105 @@ +using System; +using log4net.Appender; +using log4net.Core; +using log4net.Util; + +namespace Umbraco.Core.Logging +{ + /// + /// Based on https://github.com/cjbhaines/Log4Net.Async + /// + public abstract class AsyncForwardingAppenderBase : ForwardingAppender + { + #region Private Members + + private const FixFlags DefaultFixFlags = FixFlags.Partial; + private FixFlags _fixFlags = DefaultFixFlags; + private LoggingEventHelper _loggingEventHelper; + + #endregion Private Members + + #region Properties + + public FixFlags Fix + { + get { return _fixFlags; } + set { SetFixFlags(value); } + } + + /// + /// The logger name that will be used for logging internal errors. + /// + protected abstract string InternalLoggerName { get; } + + public abstract int? BufferSize { get; set; } + + #endregion Properties + + public override void ActivateOptions() + { + base.ActivateOptions(); + _loggingEventHelper = new LoggingEventHelper(InternalLoggerName, DefaultFixFlags); + InitializeAppenders(); + } + + #region Appender Management + + public override void AddAppender(IAppender newAppender) + { + base.AddAppender(newAppender); + SetAppenderFixFlags(newAppender); + } + + private void SetFixFlags(FixFlags newFixFlags) + { + if (newFixFlags != _fixFlags) + { + _loggingEventHelper.Fix = newFixFlags; + _fixFlags = newFixFlags; + InitializeAppenders(); + } + } + + private void InitializeAppenders() + { + foreach (var appender in Appenders) + { + SetAppenderFixFlags(appender); + } + } + + private void SetAppenderFixFlags(IAppender appender) + { + var bufferingAppender = appender as BufferingAppenderSkeleton; + if (bufferingAppender != null) + { + bufferingAppender.Fix = Fix; + } + } + + #endregion Appender Management + + #region Forwarding + + protected void ForwardInternalError(string message, Exception exception, Type thisType) + { + LogLog.Error(thisType, message, exception); + var loggingEvent = _loggingEventHelper.CreateLoggingEvent(Level.Error, message, exception); + ForwardLoggingEvent(loggingEvent, thisType); + } + + protected void ForwardLoggingEvent(LoggingEvent loggingEvent, Type thisType) + { + try + { + base.Append(loggingEvent); + } + catch (Exception exception) + { + LogLog.Error(thisType, "Unable to forward logging event", exception); + } + } + + #endregion Forwarding + } +} \ No newline at end of file diff --git a/src/Umbraco.Core/Logging/AsynchronousRollingFileAppender.cs b/src/Umbraco.Core/Logging/AsynchronousRollingFileAppender.cs index 56d04c8426..cb58ebbfaa 100644 --- a/src/Umbraco.Core/Logging/AsynchronousRollingFileAppender.cs +++ b/src/Umbraco.Core/Logging/AsynchronousRollingFileAppender.cs @@ -1,276 +1,276 @@ +using log4net.Core; +using log4net.Util; using System; +using System.Runtime.Remoting.Messaging; using System.Security.Principal; using System.Threading; using System.Threading.Tasks; using log4net.Appender; -using log4net.Core; -using log4net.Util; namespace Umbraco.Core.Logging { - /// - /// Based on code by Chris Haines http://cjbhaines.wordpress.com/2012/02/13/asynchronous-log4net-appenders/ + /// + /// Based on https://github.com/cjbhaines/Log4Net.Async + /// which is based on code by Chris Haines http://cjbhaines.wordpress.com/2012/02/13/asynchronous-log4net-appenders/ /// public class AsynchronousRollingFileAppender : RollingFileAppender { - private readonly ManualResetEvent _manualResetEvent; - private int _bufferOverflowCounter; - private bool _forceStop; - private bool _hasFinished; - private DateTime _lastLoggedBufferOverflow; - private bool _logBufferOverflow; - private RingBuffer _pendingAppends; - private int _queueSizeLimit = 1000; - private bool _shuttingDown; + private RingBuffer pendingAppends; + private readonly ManualResetEvent manualResetEvent; + private bool shuttingDown; + private bool hasFinished; + private bool forceStop; + private bool logBufferOverflow; + private int bufferOverflowCounter; + private DateTime lastLoggedBufferOverflow; + private int queueSizeLimit = 1000; + public int QueueSizeLimit + { + get + { + return queueSizeLimit; + } + set + { + queueSizeLimit = value; + } + } - public AsynchronousRollingFileAppender() - { - _manualResetEvent = new ManualResetEvent(false); - } + public AsynchronousRollingFileAppender() + { + manualResetEvent = new ManualResetEvent(false); + } - public int QueueSizeLimit - { - get { return _queueSizeLimit; } - set { _queueSizeLimit = value; } - } + public override void ActivateOptions() + { + base.ActivateOptions(); + pendingAppends = new RingBuffer(QueueSizeLimit); + pendingAppends.BufferOverflow += OnBufferOverflow; + StartAppendTask(); + } - public override void ActivateOptions() - { - base.ActivateOptions(); - _pendingAppends = new RingBuffer(QueueSizeLimit); - _pendingAppends.BufferOverflow += OnBufferOverflow; - StartAppendTask(); - } + protected override void Append(LoggingEvent[] loggingEvents) + { + Array.ForEach(loggingEvents, Append); + } - protected override void Append(LoggingEvent[] loggingEvents) - { - Array.ForEach(loggingEvents, Append); - } + protected override void Append(LoggingEvent loggingEvent) + { + if (FilterEvent(loggingEvent)) + { + pendingAppends.Enqueue(loggingEvent); + } + } - protected override void Append(LoggingEvent loggingEvent) - { - if (FilterEvent(loggingEvent)) - { - _pendingAppends.Enqueue(loggingEvent); - } - } + protected override void OnClose() + { + shuttingDown = true; + manualResetEvent.WaitOne(TimeSpan.FromSeconds(5)); - protected override void OnClose() - { - _shuttingDown = true; - _manualResetEvent.WaitOne(TimeSpan.FromSeconds(5)); + if (!hasFinished) + { + forceStop = true; + base.Append(new LoggingEvent(new LoggingEventData + { + Level = Level.Error, + Message = "Unable to clear out the AsyncRollingFileAppender buffer in the allotted time, forcing a shutdown", + TimeStamp = DateTime.UtcNow, + Identity = "", + ExceptionString = "", + UserName = WindowsIdentity.GetCurrent() != null ? WindowsIdentity.GetCurrent().Name : "", + Domain = AppDomain.CurrentDomain.FriendlyName, + ThreadName = Thread.CurrentThread.ManagedThreadId.ToString(), + LocationInfo = new LocationInfo(this.GetType().Name, "OnClose", "AsyncRollingFileAppender.cs", "75"), + LoggerName = this.GetType().FullName, + Properties = new PropertiesDictionary(), + }) + ); + } - if (!_hasFinished) - { - _forceStop = true; - var windowsIdentity = WindowsIdentity.GetCurrent(); + base.OnClose(); + } - var logEvent = new LoggingEvent(new LoggingEventData - { - Level = global::log4net.Core.Level.Error, - Message = - "Unable to clear out the AsynchronousRollingFileAppender buffer in the allotted time, forcing a shutdown", - TimeStamp = DateTime.UtcNow, - Identity = "", - ExceptionString = "", - UserName = windowsIdentity != null ? windowsIdentity.Name : "", - Domain = AppDomain.CurrentDomain.FriendlyName, - ThreadName = Thread.CurrentThread.ManagedThreadId.ToString(), - LocationInfo = - new LocationInfo(this.GetType().Name, "OnClose", "AsynchronousRollingFileAppender.cs", "59"), - LoggerName = this.GetType().FullName, - Properties = new PropertiesDictionary(), - }); + private void StartAppendTask() + { + if (!shuttingDown) + { + Task appendTask = new Task(AppendLoggingEvents, TaskCreationOptions.LongRunning); + appendTask.LogErrors(LogAppenderError).ContinueWith(x => StartAppendTask()).LogErrors(LogAppenderError); + appendTask.Start(); + } + } - if (this.DateTimeStrategy != null) - { - base.Append(logEvent); - } - } + private void LogAppenderError(string logMessage, Exception exception) + { + base.Append(new LoggingEvent(new LoggingEventData + { + Level = Level.Error, + Message = "Appender exception: " + logMessage, + TimeStamp = DateTime.UtcNow, + Identity = "", + ExceptionString = exception.ToString(), + UserName = WindowsIdentity.GetCurrent() != null ? WindowsIdentity.GetCurrent().Name : "", + Domain = AppDomain.CurrentDomain.FriendlyName, + ThreadName = Thread.CurrentThread.ManagedThreadId.ToString(), + LocationInfo = new LocationInfo(this.GetType().Name, "LogAppenderError", "AsyncRollingFileAppender.cs", "152"), + LoggerName = this.GetType().FullName, + Properties = new PropertiesDictionary(), + })); + } - base.OnClose(); - } + private void AppendLoggingEvents() + { + LoggingEvent loggingEventToAppend; + while (!shuttingDown) + { + if (logBufferOverflow) + { + LogBufferOverflowError(); + logBufferOverflow = false; + bufferOverflowCounter = 0; + lastLoggedBufferOverflow = DateTime.UtcNow; + } - private void StartAppendTask() - { - if (!_shuttingDown) - { - Task appendTask = new Task(AppendLoggingEvents, TaskCreationOptions.LongRunning); - appendTask.LogErrors(LogAppenderError).ContinueWith(x => StartAppendTask()).LogErrors(LogAppenderError); - appendTask.Start(); - } - } + while (!pendingAppends.TryDequeue(out loggingEventToAppend)) + { + Thread.Sleep(10); + if (shuttingDown) + { + break; + } + } + if (loggingEventToAppend == null) + { + continue; + } - private void LogAppenderError(string logMessage, Exception exception) - { - var windowsIdentity = WindowsIdentity.GetCurrent(); - base.Append(new LoggingEvent(new LoggingEventData - { - Level = Level.Error, - Message = "Appender exception: " + logMessage, - TimeStamp = DateTime.UtcNow, - Identity = "", - ExceptionString = exception.ToString(), - UserName = windowsIdentity != null ? windowsIdentity.Name : "", - Domain = AppDomain.CurrentDomain.FriendlyName, - ThreadName = Thread.CurrentThread.ManagedThreadId.ToString(), - LocationInfo = - new LocationInfo(this.GetType().Name, - "LogAppenderError", - "AsynchronousRollingFileAppender.cs", - "100"), - LoggerName = this.GetType().FullName, - Properties = new PropertiesDictionary(), - })); - } + try + { + base.Append(loggingEventToAppend); + } + catch + { + } + } - private void AppendLoggingEvents() - { - LoggingEvent loggingEventToAppend; - while (!_shuttingDown) - { - if (_logBufferOverflow) - { - LogBufferOverflowError(); - _logBufferOverflow = false; - _bufferOverflowCounter = 0; - _lastLoggedBufferOverflow = DateTime.UtcNow; - } + while (pendingAppends.TryDequeue(out loggingEventToAppend) && !forceStop) + { + try + { + base.Append(loggingEventToAppend); + } + catch + { + } + } + hasFinished = true; + manualResetEvent.Set(); + } - while (!_pendingAppends.TryDequeue(out loggingEventToAppend)) - { - Thread.Sleep(10); - if (_shuttingDown) - { - break; - } - } - if (loggingEventToAppend == null) - { - continue; - } + private void LogBufferOverflowError() + { + base.Append(new LoggingEvent(new LoggingEventData + { + Level = Level.Error, + Message = string.Format("Buffer overflow. {0} logging events have been lost in the last 30 seconds. [QueueSizeLimit: {1}]", bufferOverflowCounter, QueueSizeLimit), + TimeStamp = DateTime.UtcNow, + Identity = "", + ExceptionString = "", + UserName = WindowsIdentity.GetCurrent() != null ? WindowsIdentity.GetCurrent().Name : "", + Domain = AppDomain.CurrentDomain.FriendlyName, + ThreadName = Thread.CurrentThread.ManagedThreadId.ToString(), + LocationInfo = new LocationInfo(this.GetType().Name, "LogBufferOverflowError", "AsyncRollingFileAppender.cs", "152"), + LoggerName = this.GetType().FullName, + Properties = new PropertiesDictionary(), + })); + } - try - { - base.Append(loggingEventToAppend); - } - catch - { - } - } + private void OnBufferOverflow(object sender, EventArgs eventArgs) + { + bufferOverflowCounter++; + if (logBufferOverflow == false) + { + if (lastLoggedBufferOverflow < DateTime.UtcNow.AddSeconds(-30)) + { + logBufferOverflow = true; + } + } + } + } - while (_pendingAppends.TryDequeue(out loggingEventToAppend) && !_forceStop) - { - try - { - base.Append(loggingEventToAppend); - } - catch - { - } - } - _hasFinished = true; - _manualResetEvent.Set(); - } + internal interface IQueue + { + void Enqueue(T item); + bool TryDequeue(out T ret); + } - private void LogBufferOverflowError() - { - var windowsIdentity = WindowsIdentity.GetCurrent(); - base.Append(new LoggingEvent(new LoggingEventData - { - Level = Level.Error, - Message = - string.Format( - "Buffer overflow. {0} logging events have been lost in the last 30 seconds. [QueueSizeLimit: {1}]", - _bufferOverflowCounter, - QueueSizeLimit), - TimeStamp = DateTime.UtcNow, - Identity = "", - ExceptionString = "", - UserName = windowsIdentity != null ? windowsIdentity.Name : "", - Domain = AppDomain.CurrentDomain.FriendlyName, - ThreadName = Thread.CurrentThread.ManagedThreadId.ToString(), - LocationInfo = - new LocationInfo(this.GetType().Name, - "LogBufferOverflowError", - "AsynchronousRollingFileAppender.cs", - "172"), - LoggerName = this.GetType().FullName, - Properties = new PropertiesDictionary(), - })); - } + internal class RingBuffer : IQueue + { + private readonly object lockObject = new object(); + private readonly T[] buffer; + private readonly int size; + private int readIndex = 0; + private int writeIndex = 0; + private bool bufferFull = false; - private void OnBufferOverflow(object sender, EventArgs eventArgs) - { - _bufferOverflowCounter++; - if (_logBufferOverflow == false) - { - if (_lastLoggedBufferOverflow < DateTime.UtcNow.AddSeconds(-30)) - { - _logBufferOverflow = true; - } - } - } + public int Size { get { return size; } } - private class RingBuffer - { - private readonly object _lockObject = new object(); - private readonly T[] _buffer; - private readonly int _size; - private int _readIndex = 0; - private int _writeIndex = 0; - private bool _bufferFull = false; + public event Action BufferOverflow; - public event Action BufferOverflow; + public RingBuffer(int size) + { + this.size = size; + buffer = new T[size]; + } - public RingBuffer(int size) - { - this._size = size; - _buffer = new T[size]; - } + public void Enqueue(T item) + { + var bufferWasFull = false; + lock (lockObject) + { + buffer[writeIndex] = item; + writeIndex = (++writeIndex) % size; + if (bufferFull) + { + bufferWasFull = true; + readIndex = writeIndex; + } + else if (writeIndex == readIndex) + { + bufferFull = true; + } + } - public void Enqueue(T item) - { - lock (_lockObject) - { - _buffer[_writeIndex] = item; - _writeIndex = (++_writeIndex) % _size; - if (_bufferFull) - { - if (BufferOverflow != null) - { - BufferOverflow(this, EventArgs.Empty); - } - _readIndex = _writeIndex; - } - else if (_writeIndex == _readIndex) - { - _bufferFull = true; - } - } - } + if (bufferWasFull) + { + if (BufferOverflow != null) + { + BufferOverflow(this, EventArgs.Empty); + } + } + } - public bool TryDequeue(out T ret) - { - if (_readIndex == _writeIndex && !_bufferFull) - { - ret = default(T); - return false; - } - lock (_lockObject) - { - if (_readIndex == _writeIndex && !_bufferFull) - { - ret = default(T); - return false; - } + public bool TryDequeue(out T ret) + { + if (readIndex == writeIndex && !bufferFull) + { + ret = default(T); + return false; + } + lock (lockObject) + { + if (readIndex == writeIndex && !bufferFull) + { + ret = default(T); + return false; + } - ret = _buffer[_readIndex]; - _readIndex = (++_readIndex) % _size; - _bufferFull = false; - return true; - } - } - } - } + ret = buffer[readIndex]; + buffer[readIndex] = default(T); + readIndex = (++readIndex) % size; + bufferFull = false; + return true; + } + } + } } \ No newline at end of file diff --git a/src/Umbraco.Core/Logging/Logger.cs b/src/Umbraco.Core/Logging/Logger.cs index 58f696d82b..ae8bb60fcd 100644 --- a/src/Umbraco.Core/Logging/Logger.cs +++ b/src/Umbraco.Core/Logging/Logger.cs @@ -1,4 +1,5 @@ using System; +using System.Diagnostics; using System.IO; using System.Linq; using System.Threading; @@ -12,15 +13,20 @@ namespace Umbraco.Core.Logging /// Used for logging /// public class Logger : ILogger - { + { + public Logger(FileInfo log4NetConfigFile) + :this() { XmlConfigurator.Configure(log4NetConfigFile); } private Logger() { - + //Add custom global properties to the log4net context that we can use in our logging output + + log4net.GlobalContext.Properties["processId"] = Process.GetCurrentProcess().Id; + log4net.GlobalContext.Properties["appDomainId"] = AppDomain.CurrentDomain.Id; } /// @@ -53,31 +59,19 @@ namespace Umbraco.Core.Logging return LogManager.GetLogger(getTypeFromInstance.GetType()); } - - /// - /// Useful if the logger itself is running on another thread - /// - /// - /// - private string PrefixThreadId(string generateMessageFormat) - { - return "[Thread " + Thread.CurrentThread.ManagedThreadId + "] " + generateMessageFormat; - } - + public void Error(Type callingType, string message, Exception exception) { var logger = LogManager.GetLogger(callingType); if (logger != null) - logger.Error(PrefixThreadId(message), exception); + logger.Error((message), exception); } - - public void Warn(Type callingType, string message, params Func[] formatItems) { var logger = LogManager.GetLogger(callingType); if (logger == null || logger.IsWarnEnabled == false) return; - logger.WarnFormat(PrefixThreadId(message), formatItems.Select(x => x.Invoke()).ToArray()); + logger.WarnFormat((message), formatItems.Select(x => x.Invoke()).ToArray()); } public void Warn(Type callingType, string message, bool showHttpTrace, params Func[] formatItems) @@ -92,7 +86,7 @@ namespace Umbraco.Core.Logging var logger = LogManager.GetLogger(callingType); if (logger == null || logger.IsWarnEnabled == false) return; - logger.WarnFormat(PrefixThreadId(message), formatItems.Select(x => x.Invoke()).ToArray()); + logger.WarnFormat((message), formatItems.Select(x => x.Invoke()).ToArray()); } @@ -105,7 +99,7 @@ namespace Umbraco.Core.Logging var logger = LogManager.GetLogger(callingType); if (logger == null || logger.IsWarnEnabled == false) return; var executedParams = formatItems.Select(x => x.Invoke()).ToArray(); - logger.WarnFormat(PrefixThreadId(message) + ". Exception: " + e, executedParams); + logger.WarnFormat((message) + ". Exception: " + e, executedParams); } /// @@ -117,7 +111,7 @@ namespace Umbraco.Core.Logging { var logger = LogManager.GetLogger(callingType); if (logger == null || logger.IsInfoEnabled == false) return; - logger.Info(PrefixThreadId(generateMessage.Invoke())); + logger.Info((generateMessage.Invoke())); } /// @@ -131,7 +125,7 @@ namespace Umbraco.Core.Logging var logger = LogManager.GetLogger(type); if (logger == null || logger.IsInfoEnabled == false) return; var executedParams = formatItems.Select(x => x.Invoke()).ToArray(); - logger.InfoFormat(PrefixThreadId(generateMessageFormat), executedParams); + logger.InfoFormat((generateMessageFormat), executedParams); } @@ -144,7 +138,7 @@ namespace Umbraco.Core.Logging { var logger = LogManager.GetLogger(callingType); if (logger == null || logger.IsDebugEnabled == false) return; - logger.Debug(PrefixThreadId(generateMessage.Invoke())); + logger.Debug((generateMessage.Invoke())); } /// @@ -158,7 +152,7 @@ namespace Umbraco.Core.Logging var logger = LogManager.GetLogger(type); if (logger == null || logger.IsDebugEnabled == false) return; var executedParams = formatItems.Select(x => x.Invoke()).ToArray(); - logger.DebugFormat(PrefixThreadId(generateMessageFormat), executedParams); + logger.DebugFormat((generateMessageFormat), executedParams); } diff --git a/src/Umbraco.Core/Logging/LoggingEventContext.cs b/src/Umbraco.Core/Logging/LoggingEventContext.cs new file mode 100644 index 0000000000..159af4266b --- /dev/null +++ b/src/Umbraco.Core/Logging/LoggingEventContext.cs @@ -0,0 +1,17 @@ +using log4net.Core; + +namespace Umbraco.Core.Logging +{ + /// + /// Based on https://github.com/cjbhaines/Log4Net.Async + /// + internal class LoggingEventContext + { + public LoggingEventContext(LoggingEvent loggingEvent) + { + LoggingEvent = loggingEvent; + } + + public LoggingEvent LoggingEvent { get; set; } + } +} \ No newline at end of file diff --git a/src/Umbraco.Core/Logging/LoggingEventHelper.cs b/src/Umbraco.Core/Logging/LoggingEventHelper.cs new file mode 100644 index 0000000000..c788e115f2 --- /dev/null +++ b/src/Umbraco.Core/Logging/LoggingEventHelper.cs @@ -0,0 +1,31 @@ +using System; +using log4net.Core; + +namespace Umbraco.Core.Logging +{ + /// + /// Based on https://github.com/cjbhaines/Log4Net.Async + /// + internal class LoggingEventHelper + { + // needs to be a seperate class so that location is determined correctly by log4net when required + + private static readonly Type HelperType = typeof(LoggingEventHelper); + private readonly string loggerName; + + public FixFlags Fix { get; set; } + + public LoggingEventHelper(string loggerName, FixFlags fix) + { + this.loggerName = loggerName; + Fix = fix; + } + + public LoggingEvent CreateLoggingEvent(Level level, string message, Exception exception) + { + var loggingEvent = new LoggingEvent(HelperType, null, loggerName, level, message, exception); + loggingEvent.Fix = Fix; + return loggingEvent; + } + } +} \ No newline at end of file diff --git a/src/Umbraco.Core/Logging/ParallelForwardingAppender.cs b/src/Umbraco.Core/Logging/ParallelForwardingAppender.cs new file mode 100644 index 0000000000..92c4f7589b --- /dev/null +++ b/src/Umbraco.Core/Logging/ParallelForwardingAppender.cs @@ -0,0 +1,307 @@ +using System; +using System.Collections.Concurrent; +using System.Threading; +using System.Threading.Tasks; +using log4net.Core; +using log4net.Util; + +namespace Umbraco.Core.Logging +{ + /// + /// An asynchronous appender based on + /// + /// + /// Based on https://github.com/cjbhaines/Log4Net.Async + /// + public class ParallelForwardingAppender : AsyncForwardingAppenderBase, IDisposable + { + #region Private Members + + private const int DefaultBufferSize = 1000; + private BlockingCollection _loggingEvents; + private CancellationTokenSource _loggingCancelationTokenSource; + private CancellationToken _loggingCancelationToken; + private Task _loggingTask; + private Double _shutdownFlushTimeout = 5; + private TimeSpan _shutdownFlushTimespan = TimeSpan.FromSeconds(5); + private static readonly Type ThisType = typeof(ParallelForwardingAppender); + private volatile bool _shutDownRequested; + private int? _bufferSize = DefaultBufferSize; + + #endregion Private Members + + #region Properties + + /// + /// Gets or sets the number of LoggingEvents that will be buffered. Set to null for unlimited. + /// + public override int? BufferSize + { + get { return _bufferSize; } + set { _bufferSize = value; } + } + + public int BufferEntryCount + { + get + { + if (_loggingEvents == null) return 0; + return _loggingEvents.Count; + } + } + + /// + /// Gets or sets the time period in which the system will wait for appenders to flush before canceling the background task. + /// + public Double ShutdownFlushTimeout + { + get + { + return _shutdownFlushTimeout; + } + set + { + _shutdownFlushTimeout = value; + } + } + + protected override string InternalLoggerName + { + get { return "ParallelForwardingAppender"; } + } + + #endregion Properties + + #region Startup + + public override void ActivateOptions() + { + base.ActivateOptions(); + _shutdownFlushTimespan = TimeSpan.FromSeconds(_shutdownFlushTimeout); + StartForwarding(); + } + + private void StartForwarding() + { + if (_shutDownRequested) + { + return; + } + //Create a collection which will block the thread and wait for new entries + //if the collection is empty + if (BufferSize.HasValue && BufferSize > 0) + { + _loggingEvents = new BlockingCollection(BufferSize.Value); + } + else + { + //No limit on the number of events. + _loggingEvents = new BlockingCollection(); + } + //The cancellation token is used to cancel a running task gracefully. + _loggingCancelationTokenSource = new CancellationTokenSource(); + _loggingCancelationToken = _loggingCancelationTokenSource.Token; + _loggingTask = new Task(SubscriberLoop, _loggingCancelationToken); + _loggingTask.Start(); + } + + #endregion Startup + + #region Shutdown + + private void CompleteSubscriberTask() + { + _shutDownRequested = true; + if (_loggingEvents == null || _loggingEvents.IsAddingCompleted) + { + return; + } + //Don't allow more entries to be added. + _loggingEvents.CompleteAdding(); + //Allow some time to flush + Thread.Sleep(_shutdownFlushTimespan); + if (!_loggingTask.IsCompleted && !_loggingCancelationToken.IsCancellationRequested) + { + _loggingCancelationTokenSource.Cancel(); + //Wait here so that the error logging messages do not get into a random order. + //Don't pass the cancellation token because we are not interested + //in catching the OperationCanceledException that results. + _loggingTask.Wait(); + } + if (!_loggingEvents.IsCompleted) + { + ForwardInternalError("The buffer was not able to be flushed before timeout occurred.", null, ThisType); + } + } + + protected override void OnClose() + { + CompleteSubscriberTask(); + base.OnClose(); + } + + #endregion Shutdown + + #region Appending + + protected override void Append(LoggingEvent loggingEvent) + { + if (_loggingEvents == null || _loggingEvents.IsAddingCompleted || loggingEvent == null) + { + return; + } + + loggingEvent.Fix = Fix; + //In the case where blocking on a full collection, and the task is subsequently completed, the cancellation token + //will prevent the entry from attempting to add to the completed collection which would result in an exception. + _loggingEvents.Add(new LoggingEventContext(loggingEvent), _loggingCancelationToken); + } + + protected override void Append(LoggingEvent[] loggingEvents) + { + if (_loggingEvents == null || _loggingEvents.IsAddingCompleted || loggingEvents == null) + { + return; + } + + foreach (var loggingEvent in loggingEvents) + { + Append(loggingEvent); + } + } + + #endregion Appending + + #region Forwarding + + /// + /// Iterates over a BlockingCollection containing LoggingEvents. + /// + private void SubscriberLoop() + { + Thread.CurrentThread.Name = String.Format("{0} ParallelForwardingAppender Subscriber Task", Name); + //The task will continue in a blocking loop until + //the queue is marked as adding completed, or the task is canceled. + try + { + //This call blocks until an item is available or until adding is completed + foreach (var entry in _loggingEvents.GetConsumingEnumerable(_loggingCancelationToken)) + { + ForwardLoggingEvent(entry.LoggingEvent, ThisType); + } + } + catch (OperationCanceledException ex) + { + //The thread was canceled before all entries could be forwarded and the collection completed. + ForwardInternalError("Subscriber task was canceled before completion.", ex, ThisType); + //Cancellation is called in the CompleteSubscriberTask so don't call that again. + } + catch (ThreadAbortException ex) + { + //Thread abort may occur on domain unload. + ForwardInternalError("Subscriber task was aborted.", ex, ThisType); + //Cannot recover from a thread abort so complete the task. + CompleteSubscriberTask(); + //The exception is swallowed because we don't want the client application + //to halt due to a logging issue. + } + catch (Exception ex) + { + //On exception, try to log the exception + ForwardInternalError("Subscriber task error in forwarding loop.", ex, ThisType); + //Any error in the loop is going to be some sort of extenuating circumstance from which we + //probably cannot recover anyway. Complete subscribing. + CompleteSubscriberTask(); + } + } + + #endregion Forwarding + + #region IDisposable Implementation + + private bool _disposed = false; + + //Implement IDisposable. + public void Dispose() + { + Dispose(true); + GC.SuppressFinalize(this); + } + + protected virtual void Dispose(bool disposing) + { + if (!_disposed) + { + if (disposing) + { + if (_loggingTask != null) + { + if (!(_loggingTask.IsCanceled || _loggingTask.IsCompleted || _loggingTask.IsFaulted)) + { + try + { + CompleteSubscriberTask(); + } + catch (Exception ex) + { + LogLog.Error(ThisType, "Exception Completing Subscriber Task in Dispose Method", ex); + } + } + try + { + _loggingTask.Dispose(); + } + catch (Exception ex) + { + LogLog.Error(ThisType, "Exception Disposing Logging Task", ex); + } + finally + { + _loggingTask = null; + } + } + if (_loggingEvents != null) + { + try + { + _loggingEvents.Dispose(); + } + catch (Exception ex) + { + LogLog.Error(ThisType, "Exception Disposing BlockingCollection", ex); + } + finally + { + _loggingEvents = null; + } + } + if (_loggingCancelationTokenSource != null) + { + try + { + _loggingCancelationTokenSource.Dispose(); + } + catch (Exception ex) + { + LogLog.Error(ThisType, "Exception Disposing CancellationTokenSource", ex); + } + finally + { + _loggingCancelationTokenSource = null; + } + } + } + _disposed = true; + } + } + + // Use C# destructor syntax for finalization code. + ~ParallelForwardingAppender() + { + // Simply call Dispose(false). + Dispose(false); + } + + #endregion IDisposable Implementation + } +} \ No newline at end of file diff --git a/src/Umbraco.Core/Models/DictionaryItem.cs b/src/Umbraco.Core/Models/DictionaryItem.cs index e09c370053..7e59726c80 100644 --- a/src/Umbraco.Core/Models/DictionaryItem.cs +++ b/src/Umbraco.Core/Models/DictionaryItem.cs @@ -14,22 +14,22 @@ namespace Umbraco.Core.Models [DataContract(IsReference = true)] public class DictionaryItem : Entity, IDictionaryItem { - private Guid _parentId; + private Guid? _parentId; private string _itemKey; private IEnumerable _translations; public DictionaryItem(string itemKey) - : this(new Guid(Constants.Conventions.Localization.DictionaryItemRootId), itemKey) + : this(null, itemKey) {} - public DictionaryItem(Guid parentId, string itemKey) + public DictionaryItem(Guid? parentId, string itemKey) { _parentId = parentId; _itemKey = itemKey; _translations = new List(); } - private static readonly PropertyInfo ParentIdSelector = ExpressionHelper.GetPropertyInfo(x => x.ParentId); + private static readonly PropertyInfo ParentIdSelector = ExpressionHelper.GetPropertyInfo(x => x.ParentId); private static readonly PropertyInfo ItemKeySelector = ExpressionHelper.GetPropertyInfo(x => x.ItemKey); private static readonly PropertyInfo TranslationsSelector = ExpressionHelper.GetPropertyInfo>(x => x.Translations); @@ -37,7 +37,7 @@ namespace Umbraco.Core.Models /// Gets or Sets the Parent Id of the Dictionary Item /// [DataMember] - public Guid ParentId + public Guid? ParentId { get { return _parentId; } set @@ -95,11 +95,7 @@ namespace Umbraco.Core.Models { base.AddingEntity(); - Key = Guid.NewGuid(); - - //If ParentId is not set we should default to the root parent id - if(ParentId == Guid.Empty) - _parentId = new Guid(Constants.Conventions.Localization.DictionaryItemRootId); + Key = Guid.NewGuid(); } } diff --git a/src/Umbraco.Core/Models/IDictionaryItem.cs b/src/Umbraco.Core/Models/IDictionaryItem.cs index e10a80e831..ed88acfbec 100644 --- a/src/Umbraco.Core/Models/IDictionaryItem.cs +++ b/src/Umbraco.Core/Models/IDictionaryItem.cs @@ -12,7 +12,7 @@ namespace Umbraco.Core.Models /// Gets or Sets the Parent Id of the Dictionary Item /// [DataMember] - Guid ParentId { get; set; } + Guid? ParentId { get; set; } /// /// Gets or sets the Key for the Dictionary Item diff --git a/src/Umbraco.Core/Models/Identity/BackOfficeIdentityUser.cs b/src/Umbraco.Core/Models/Identity/BackOfficeIdentityUser.cs index 1523cf9040..0d803c26e5 100644 --- a/src/Umbraco.Core/Models/Identity/BackOfficeIdentityUser.cs +++ b/src/Umbraco.Core/Models/Identity/BackOfficeIdentityUser.cs @@ -12,6 +12,13 @@ namespace Umbraco.Core.Models.Identity public class BackOfficeIdentityUser : IdentityUser, IdentityUserClaim> { + public BackOfficeIdentityUser() + { + StartMediaId = -1; + StartContentId = -1; + Culture = Configuration.GlobalSettings.DefaultUILanguage; + } + public virtual async Task GenerateUserIdentityAsync(BackOfficeUserManager manager) { // NOTE the authenticationType must match the umbraco one @@ -31,6 +38,30 @@ namespace Umbraco.Core.Models.Identity public string UserTypeAlias { get; set; } + /// + /// Lockout is always enabled + /// + public override bool LockoutEnabled + { + get { return true; } + set + { + //do nothing + } + } + + /// + /// Based on the user's lockout end date, this will determine if they are locked out + /// + internal bool IsLockedOut + { + get + { + var isLocked = (LockoutEndDateUtc.HasValue && LockoutEndDateUtc.Value.ToLocalTime() >= DateTime.Now); + return isLocked; + } + } + /// /// Overridden to make the retrieval lazy /// diff --git a/src/Umbraco.Core/Models/Identity/IdentityModelMappings.cs b/src/Umbraco.Core/Models/Identity/IdentityModelMappings.cs index def71a8982..f57d6683a2 100644 --- a/src/Umbraco.Core/Models/Identity/IdentityModelMappings.cs +++ b/src/Umbraco.Core/Models/Identity/IdentityModelMappings.cs @@ -14,8 +14,7 @@ namespace Umbraco.Core.Models.Identity config.CreateMap() .ForMember(user => user.Email, expression => expression.MapFrom(user => user.Email)) .ForMember(user => user.Id, expression => expression.MapFrom(user => user.Id)) - .ForMember(user => user.LockoutEnabled, expression => expression.MapFrom(user => user.IsLockedOut)) - .ForMember(user => user.LockoutEndDateUtc, expression => expression.UseValue(DateTime.MaxValue.ToUniversalTime())) + .ForMember(user => user.LockoutEndDateUtc, expression => expression.MapFrom(user => user.IsLockedOut ? DateTime.MaxValue.ToUniversalTime() : (DateTime?)null)) .ForMember(user => user.UserName, expression => expression.MapFrom(user => user.Username)) .ForMember(user => user.PasswordHash, expression => expression.MapFrom(user => GetPasswordHash(user.RawPasswordValue))) .ForMember(user => user.Culture, expression => expression.MapFrom(user => user.GetUserCulture(applicationContext.Services.TextService))) @@ -23,6 +22,7 @@ namespace Umbraco.Core.Models.Identity .ForMember(user => user.StartMediaId, expression => expression.MapFrom(user => user.StartMediaId)) .ForMember(user => user.StartContentId, expression => expression.MapFrom(user => user.StartContentId)) .ForMember(user => user.UserTypeAlias, expression => expression.MapFrom(user => user.UserType.Alias)) + .ForMember(user => user.AccessFailedCount, expression => expression.MapFrom(user => user.FailedPasswordAttempts)) .ForMember(user => user.AllowedSections, expression => expression.MapFrom(user => user.AllowedSections.ToArray())); } diff --git a/src/Umbraco.Core/Models/Macro.cs b/src/Umbraco.Core/Models/Macro.cs index fcc23ed858..a15639f886 100644 --- a/src/Umbraco.Core/Models/Macro.cs +++ b/src/Umbraco.Core/Models/Macro.cs @@ -18,7 +18,7 @@ namespace Umbraco.Core.Models /// [Serializable] [DataContract(IsReference = true)] - internal class Macro : Entity, IMacro + public class Macro : Entity, IMacro { public Macro() { diff --git a/src/Umbraco.Core/Models/PropertyGroup.cs b/src/Umbraco.Core/Models/PropertyGroup.cs index 94e46e1ed1..7976a7eac6 100644 --- a/src/Umbraco.Core/Models/PropertyGroup.cs +++ b/src/Umbraco.Core/Models/PropertyGroup.cs @@ -1,6 +1,7 @@ using System; using System.Collections.Specialized; using System.Diagnostics; +using System.Linq; using System.Reflection; using System.Runtime.Serialization; using Umbraco.Core.Models.EntityBase; @@ -105,6 +106,13 @@ namespace Umbraco.Core.Models set { _propertyTypes = value; + + //since we're adding this collection to this group, we need to ensure that all the lazy values are set. + foreach (var propertyType in _propertyTypes) + { + propertyType.PropertyGroupId = new Lazy(() => this.Id); + } + _propertyTypes.CollectionChanged += PropertyTypesChanged; } } diff --git a/src/Umbraco.Core/Models/Rdbms/DictionaryDto.cs b/src/Umbraco.Core/Models/Rdbms/DictionaryDto.cs index 18fd16b658..712d1937a9 100644 --- a/src/Umbraco.Core/Models/Rdbms/DictionaryDto.cs +++ b/src/Umbraco.Core/Models/Rdbms/DictionaryDto.cs @@ -19,7 +19,9 @@ namespace Umbraco.Core.Models.Rdbms public Guid UniqueId { get; set; } [Column("parent")] - public Guid Parent { get; set; } + [NullSetting(NullSetting = NullSettings.Null)] + [ForeignKey(typeof(DictionaryDto), Column = "id")] + public Guid? Parent { get; set; } [Column("key")] [Length(1000)] diff --git a/src/Umbraco.Core/Models/Rdbms/LanguageTextDto.cs b/src/Umbraco.Core/Models/Rdbms/LanguageTextDto.cs index d062df4eae..87329fbd4c 100644 --- a/src/Umbraco.Core/Models/Rdbms/LanguageTextDto.cs +++ b/src/Umbraco.Core/Models/Rdbms/LanguageTextDto.cs @@ -14,6 +14,7 @@ namespace Umbraco.Core.Models.Rdbms public int PrimaryKey { get; set; } [Column("languageId")] + [ForeignKey(typeof(LanguageDto), Column = "id")] public int LanguageId { get; set; } [Column("UniqueId")] diff --git a/src/Umbraco.Core/Models/Rdbms/UserLoginDto.cs b/src/Umbraco.Core/Models/Rdbms/UserLoginDto.cs deleted file mode 100644 index 6826377856..0000000000 --- a/src/Umbraco.Core/Models/Rdbms/UserLoginDto.cs +++ /dev/null @@ -1,21 +0,0 @@ -using System; -using Umbraco.Core.Persistence; -using Umbraco.Core.Persistence.DatabaseAnnotations; - -namespace Umbraco.Core.Models.Rdbms -{ - [TableName("umbracoUserLogins")] - [ExplicitColumns] - internal class UserLoginDto - { - [Column("contextID")] - [Index(IndexTypes.Clustered, Name = "IX_umbracoUserLogins_Index")] - public Guid ContextId { get; set; } - - [Column("userID")] - public int UserId { get; set; } - - [Column("timeout")] - public long Timeout { get; set; } - } -} \ No newline at end of file diff --git a/src/Umbraco.Core/ObjectResolution/Resolution.cs b/src/Umbraco.Core/ObjectResolution/Resolution.cs index 87eb06e295..0b478d54cf 100644 --- a/src/Umbraco.Core/ObjectResolution/Resolution.cs +++ b/src/Umbraco.Core/ObjectResolution/Resolution.cs @@ -112,7 +112,7 @@ namespace Umbraco.Core.ObjectResolution /// resolution is already frozen. public static void Freeze() { - LogHelper.Debug(typeof(Resolution), "Freezing resolution"); + LogHelper.Debug(typeof (Resolution), "Freezing resolution"); using (new WriteLock(ConfigurationLock)) { @@ -121,9 +121,20 @@ namespace Umbraco.Core.ObjectResolution _isFrozen = true; } - - if (Frozen != null) - Frozen(null, null); + + LogHelper.Debug(typeof(Resolution), "Resolution is frozen"); + + if (Frozen == null) return; + + try + { + Frozen(null, null); + } + catch (Exception e) + { + LogHelper.Error(typeof (Resolution), "Exception in Frozen event handler.", e); + throw; + } } /// diff --git a/src/Umbraco.Core/Persistence/DatabaseSchemaHelper.cs b/src/Umbraco.Core/Persistence/DatabaseSchemaHelper.cs index ca64775880..55c1fe505f 100644 --- a/src/Umbraco.Core/Persistence/DatabaseSchemaHelper.cs +++ b/src/Umbraco.Core/Persistence/DatabaseSchemaHelper.cs @@ -151,6 +151,13 @@ namespace Umbraco.Core.Persistence _db.Update("SET id = @IdAfter WHERE id = @IdBefore AND userLogin = @Login", new { IdAfter = 0, IdBefore = 1, Login = "admin" }); } + //Loop through index statements and execute sql + foreach (var sql in indexSql) + { + int createdIndex = _db.Execute(new Sql(sql)); + _logger.Info(string.Format("Create Index sql {0}:\n {1}", createdIndex, sql)); + } + //Loop through foreignkey statements and execute sql foreach (var sql in foreignSql) { @@ -158,12 +165,7 @@ namespace Umbraco.Core.Persistence _logger.Info(string.Format("Create Foreign Key sql {0}:\n {1}", createdFk, sql)); } - //Loop through index statements and execute sql - foreach (var sql in indexSql) - { - int createdIndex = _db.Execute(new Sql(sql)); - _logger.Info(string.Format("Create Index sql {0}:\n {1}", createdIndex, sql)); - } + transaction.Complete(); } diff --git a/src/Umbraco.Core/Persistence/Migrations/Initial/DatabaseSchemaCreation.cs b/src/Umbraco.Core/Persistence/Migrations/Initial/DatabaseSchemaCreation.cs index ce2a53ea95..0ba269a3ba 100644 --- a/src/Umbraco.Core/Persistence/Migrations/Initial/DatabaseSchemaCreation.cs +++ b/src/Umbraco.Core/Persistence/Migrations/Initial/DatabaseSchemaCreation.cs @@ -48,8 +48,8 @@ namespace Umbraco.Core.Persistence.Migrations.Initial {7, typeof (DataTypeDto)}, {8, typeof (DataTypePreValueDto)}, {9, typeof (DictionaryDto)}, - {10, typeof (LanguageTextDto)}, - {11, typeof (LanguageDto)}, + {10, typeof (LanguageDto)}, + {11, typeof (LanguageTextDto)}, {12, typeof (DomainDto)}, {13, typeof (LogDto)}, {14, typeof (MacroDto)}, @@ -68,7 +68,6 @@ namespace Umbraco.Core.Persistence.Migrations.Initial {27, typeof (StylesheetPropertyDto)}, {28, typeof (TagDto)}, {29, typeof (TagRelationshipDto)}, - {30, typeof (UserLoginDto)}, {31, typeof (UserTypeDto)}, {32, typeof (UserDto)}, {33, typeof (TaskTypeDto)}, diff --git a/src/Umbraco.Core/Persistence/Migrations/MigrationExpressionBase.cs b/src/Umbraco.Core/Persistence/Migrations/MigrationExpressionBase.cs index e7535e78d4..7dde31d3e3 100644 --- a/src/Umbraco.Core/Persistence/Migrations/MigrationExpressionBase.cs +++ b/src/Umbraco.Core/Persistence/Migrations/MigrationExpressionBase.cs @@ -53,5 +53,32 @@ namespace Umbraco.Core.Persistence.Migrations /// to ensure they are not executed twice. /// internal string Name { get; set; } + + protected string GetQuotedValue(object val) + { + if (val == null) return "NULL"; + + var type = val.GetType(); + + switch (Type.GetTypeCode(type)) + { + case TypeCode.Boolean: + return ((bool)val) ? "1" : "0"; + case TypeCode.Single: + case TypeCode.Double: + case TypeCode.Decimal: + case TypeCode.SByte: + case TypeCode.Int16: + case TypeCode.Int32: + case TypeCode.Int64: + case TypeCode.Byte: + case TypeCode.UInt16: + case TypeCode.UInt32: + case TypeCode.UInt64: + return val.ToString(); + default: + return SqlSyntaxContext.SqlSyntaxProvider.GetQuotedValue(val.ToString()); + } + } } } \ No newline at end of file diff --git a/src/Umbraco.Core/Persistence/Migrations/Syntax/Delete/Expressions/DeleteDataExpression.cs b/src/Umbraco.Core/Persistence/Migrations/Syntax/Delete/Expressions/DeleteDataExpression.cs index 2131a7b106..73966f6e93 100644 --- a/src/Umbraco.Core/Persistence/Migrations/Syntax/Delete/Expressions/DeleteDataExpression.cs +++ b/src/Umbraco.Core/Persistence/Migrations/Syntax/Delete/Expressions/DeleteDataExpression.cs @@ -44,7 +44,7 @@ namespace Umbraco.Core.Persistence.Migrations.Syntax.Delete.Expressions whereClauses.Add(string.Format("{0} {1} {2}", SqlSyntaxContext.SqlSyntaxProvider.GetQuotedColumnName(item.Key), item.Value == null ? "IS" : "=", - SqlSyntaxContext.SqlSyntaxProvider.GetQuotedValue(item.Value.ToString()))); + GetQuotedValue(item.Value))); } deleteItems.Add(string.Format(SqlSyntaxContext.SqlSyntaxProvider.DeleteData, diff --git a/src/Umbraco.Core/Persistence/Migrations/Syntax/Insert/Expressions/InsertDataExpression.cs b/src/Umbraco.Core/Persistence/Migrations/Syntax/Insert/Expressions/InsertDataExpression.cs index 330e22bb93..568087733b 100644 --- a/src/Umbraco.Core/Persistence/Migrations/Syntax/Insert/Expressions/InsertDataExpression.cs +++ b/src/Umbraco.Core/Persistence/Migrations/Syntax/Insert/Expressions/InsertDataExpression.cs @@ -60,29 +60,6 @@ namespace Umbraco.Core.Persistence.Migrations.Syntax.Insert.Expressions return string.Join(",", insertItems); } - private string GetQuotedValue(object val) - { - var type = val.GetType(); - - switch (Type.GetTypeCode(type)) - { - case TypeCode.Boolean: - return ((bool) val) ? "1" : "0"; - case TypeCode.Single: - case TypeCode.Double: - case TypeCode.Decimal: - case TypeCode.SByte: - case TypeCode.Int16: - case TypeCode.Int32: - case TypeCode.Int64: - case TypeCode.Byte: - case TypeCode.UInt16: - case TypeCode.UInt32: - case TypeCode.UInt64: - return val.ToString(); - default: - return SqlSyntaxContext.SqlSyntaxProvider.GetQuotedValue(val.ToString()); - } - } + } } \ No newline at end of file diff --git a/src/Umbraco.Core/Persistence/Migrations/Syntax/Update/Expressions/UpdateDataExpression.cs b/src/Umbraco.Core/Persistence/Migrations/Syntax/Update/Expressions/UpdateDataExpression.cs index a5a3204974..fd470dd7f2 100644 --- a/src/Umbraco.Core/Persistence/Migrations/Syntax/Update/Expressions/UpdateDataExpression.cs +++ b/src/Umbraco.Core/Persistence/Migrations/Syntax/Update/Expressions/UpdateDataExpression.cs @@ -32,7 +32,7 @@ namespace Umbraco.Core.Persistence.Migrations.Syntax.Update.Expressions { updateItems.Add(string.Format("{0} = {1}", SqlSyntaxContext.SqlSyntaxProvider.GetQuotedColumnName(item.Key), - SqlSyntaxContext.SqlSyntaxProvider.GetQuotedValue(item.Value.ToString()))); + GetQuotedValue(item.Value))); } if (IsAllRows) @@ -46,7 +46,7 @@ namespace Umbraco.Core.Persistence.Migrations.Syntax.Update.Expressions whereClauses.Add(string.Format("{0} {1} {2}", SqlSyntaxContext.SqlSyntaxProvider.GetQuotedColumnName(item.Key), item.Value == null ? "IS" : "=", - SqlSyntaxContext.SqlSyntaxProvider.GetQuotedValue(item.Value.ToString()))); + GetQuotedValue(item.Value))); } } return string.Format(SqlSyntaxContext.SqlSyntaxProvider.UpdateData, diff --git a/src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSeven/AlterTagRelationsTable.cs b/src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSeven/AlterTagRelationsTable.cs index f6b7e75189..d822b7593a 100644 --- a/src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSeven/AlterTagRelationsTable.cs +++ b/src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSeven/AlterTagRelationsTable.cs @@ -38,15 +38,20 @@ namespace Umbraco.Core.Persistence.Migrations.Upgrades.TargetVersionSeven if (Context.CurrentDatabaseProvider == DatabaseProviders.MySql) { Delete.ForeignKey().FromTable("cmsTagRelationship").ForeignColumn("nodeId").ToTable("umbracoNode").PrimaryColumn("id"); + //check for another strange really old one that might have existed + if (constraints.Any(x => x.Item1 == "cmsTagRelationship" && x.Item2 == "tagId")) + { + Delete.ForeignKey().FromTable("cmsTagRelationship").ForeignColumn("tagId").ToTable("cmsTags").PrimaryColumn("id"); + } } else { //Before we try to delete this constraint, we'll see if it exists first, some older schemas never had it and some older schema's had this named // differently than the default. - var constraint = constraints - .SingleOrDefault(x => x.Item1 == "cmsTagRelationship" && x.Item2 == "nodeId" && x.Item3.InvariantStartsWith("PK_") == false); - if (constraint != null) + var constraintMatches = constraints.Where(x => x.Item1 == "cmsTagRelationship" && x.Item2 == "nodeId" && x.Item3.InvariantStartsWith("PK_") == false); + + foreach (var constraint in constraintMatches) { Delete.ForeignKey(constraint.Item3).OnTable("cmsTagRelationship"); } diff --git a/src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSevenThreeZero/AddForeignKeysForLanguageAndDictionaryTables.cs b/src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSevenThreeZero/AddForeignKeysForLanguageAndDictionaryTables.cs new file mode 100644 index 0000000000..81b93a8883 --- /dev/null +++ b/src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSevenThreeZero/AddForeignKeysForLanguageAndDictionaryTables.cs @@ -0,0 +1,58 @@ +using System; +using System.Data; +using System.Linq; +using Umbraco.Core.Configuration; +using Umbraco.Core.Logging; +using Umbraco.Core.Persistence.SqlSyntax; + +namespace Umbraco.Core.Persistence.Migrations.Upgrades.TargetVersionSevenThreeZero +{ + [Migration("7.3.0", 14, GlobalSettings.UmbracoMigrationName)] + public class AddForeignKeysForLanguageAndDictionaryTables : MigrationBase + { + public AddForeignKeysForLanguageAndDictionaryTables(ISqlSyntaxProvider sqlSyntax, ILogger logger) + : base(sqlSyntax, logger) + { + } + + public override void Up() + { + var constraints = SqlSyntax.GetConstraintsPerColumn(Context.Database).Distinct().ToArray(); + + //if the FK doesn't exist + if (constraints.Any(x => x.Item1.InvariantEquals("cmsLanguageText") && x.Item2.InvariantEquals("languageId") && x.Item3.InvariantEquals("FK_cmsLanguageText_umbracoLanguage_id")) == false) + { + //Somehow, a language text item might end up with a language Id of zero or one that no longer exists + //before we add the foreign key + foreach (var pk in Context.Database.Query( + "SELECT cmsLanguageText.pk FROM cmsLanguageText WHERE cmsLanguageText.languageId NOT IN (SELECT umbracoLanguage.id FROM umbracoLanguage)")) + { + Delete.FromTable("cmsLanguageText").Row(new { pk = pk }); + } + + //now we need to create a foreign key + Create.ForeignKey("FK_cmsLanguageText_umbracoLanguage_id").FromTable("cmsLanguageText").ForeignColumn("languageId") + .ToTable("umbracoLanguage").PrimaryColumn("id").OnDeleteOrUpdate(Rule.None); + + Alter.Table("cmsDictionary").AlterColumn("parent").AsGuid().Nullable(); + + //set the parent to null if it equals the default dictionary item root id + foreach (var pk in Context.Database.Query("SELECT pk FROM cmsDictionary WHERE parent NOT IN (SELECT id FROM cmsDictionary)")) + { + Update.Table("cmsDictionary").Set(new { parent = (Guid?)null }).Where(new { pk = pk }); + } + + Create.ForeignKey("FK_cmsDictionary_cmsDictionary_id").FromTable("cmsDictionary").ForeignColumn("parent") + .ToTable("cmsDictionary").PrimaryColumn("id").OnDeleteOrUpdate(Rule.None); + } + + + + } + + public override void Down() + { + throw new System.NotImplementedException(); + } + } +} \ No newline at end of file diff --git a/src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSevenThreeZero/MovePublicAccessXmlDataToDb.cs b/src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSevenThreeZero/MovePublicAccessXmlDataToDb.cs index 7dd5f81b3a..d60385926b 100644 --- a/src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSevenThreeZero/MovePublicAccessXmlDataToDb.cs +++ b/src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSevenThreeZero/MovePublicAccessXmlDataToDb.cs @@ -30,6 +30,9 @@ namespace Umbraco.Core.Persistence.Migrations.Upgrades.TargetVersionSevenThreeZe } var xmlFile = IOHelper.MapPath(SystemFiles.AccessXml); + + if (File.Exists(xmlFile) == false) return; + using (var fileStream = File.OpenRead(xmlFile)) { var xml = XDocument.Load(fileStream); diff --git a/src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSevenThreeZero/RemoveUmbracoLoginsTable.cs b/src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSevenThreeZero/RemoveUmbracoLoginsTable.cs new file mode 100644 index 0000000000..b842ec041a --- /dev/null +++ b/src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSevenThreeZero/RemoveUmbracoLoginsTable.cs @@ -0,0 +1,29 @@ +using System.Linq; +using Umbraco.Core.Configuration; +using Umbraco.Core.Logging; +using Umbraco.Core.Persistence.SqlSyntax; + +namespace Umbraco.Core.Persistence.Migrations.Upgrades.TargetVersionSevenThreeZero +{ + [Migration("7.3.0", 15, GlobalSettings.UmbracoMigrationName)] + public class RemoveUmbracoLoginsTable : MigrationBase + { + public RemoveUmbracoLoginsTable(ISqlSyntaxProvider sqlSyntax, ILogger logger) + : base(sqlSyntax, logger) + { + } + + public override void Up() + { + if (SqlSyntax.GetColumnsInSchema(Context.Database).Any(x => x.TableName.InvariantEquals("umbracoUserLogins"))) + { + Delete.Table("umbracoUserLogins"); + } + } + + public override void Down() + { + throw new System.NotImplementedException(); + } + } +} \ No newline at end of file diff --git a/src/Umbraco.Core/Persistence/Repositories/ContentPreviewRepository.cs b/src/Umbraco.Core/Persistence/Repositories/ContentPreviewRepository.cs index 67741c84d7..b368488833 100644 --- a/src/Umbraco.Core/Persistence/Repositories/ContentPreviewRepository.cs +++ b/src/Umbraco.Core/Persistence/Repositories/ContentPreviewRepository.cs @@ -83,7 +83,7 @@ namespace Umbraco.Core.Persistence.Repositories NodeId = entity.Id, Timestamp = DateTime.Now, VersionId = entity.Version, - Xml = entity.Xml.ToString(SaveOptions.None) + Xml = entity.Xml.ToDataString() }; //We need to do a special InsertOrUpdate here because we know that the PreviewXmlDto table has a composite key and thus diff --git a/src/Umbraco.Core/Persistence/Repositories/ContentRepository.cs b/src/Umbraco.Core/Persistence/Repositories/ContentRepository.cs index 1bec751c6c..3395b38b3d 100644 --- a/src/Umbraco.Core/Persistence/Repositories/ContentRepository.cs +++ b/src/Umbraco.Core/Persistence/Repositories/ContentRepository.cs @@ -20,6 +20,7 @@ using Umbraco.Core.Persistence.DatabaseModelDefinitions; using Umbraco.Core.Persistence.Factories; using Umbraco.Core.Persistence.Querying; using Umbraco.Core.Cache; +using Umbraco.Core.Configuration.UmbracoSettings; using Umbraco.Core.Persistence.SqlSyntax; using Umbraco.Core.Persistence.UnitOfWork; @@ -37,8 +38,8 @@ namespace Umbraco.Core.Persistence.Repositories private readonly ContentPreviewRepository _contentPreviewRepository; private readonly ContentXmlRepository _contentXmlRepository; - public ContentRepository(IDatabaseUnitOfWork work, CacheHelper cacheHelper, ILogger logger, ISqlSyntaxProvider syntaxProvider, IContentTypeRepository contentTypeRepository, ITemplateRepository templateRepository, ITagRepository tagRepository) - : base(work, cacheHelper, logger, syntaxProvider) + public ContentRepository(IDatabaseUnitOfWork work, CacheHelper cacheHelper, ILogger logger, ISqlSyntaxProvider syntaxProvider, IContentTypeRepository contentTypeRepository, ITemplateRepository templateRepository, ITagRepository tagRepository, IContentSection contentSection) + : base(work, cacheHelper, logger, syntaxProvider, contentSection) { if (contentTypeRepository == null) throw new ArgumentNullException("contentTypeRepository"); if (templateRepository == null) throw new ArgumentNullException("templateRepository"); @@ -237,7 +238,7 @@ namespace Umbraco.Core.Persistence.Repositories var xmlItems = (from descendant in descendants let xml = serializer(descendant) - select new ContentXmlDto { NodeId = descendant.Id, Xml = xml.ToString(SaveOptions.None) }).ToArray(); + select new ContentXmlDto { NodeId = descendant.Id, Xml = xml.ToDataString() }).ToArray(); //bulk insert it into the database Database.BulkInsertRecords(xmlItems, tr); @@ -351,11 +352,10 @@ namespace Umbraco.Core.Persistence.Repositories //NOTE Should the logic below have some kind of fallback for empty parent ids ? //Logic for setting Path, Level and SortOrder var parent = Database.First("WHERE id = @ParentId", new { ParentId = entity.ParentId }); - int level = parent.Level + 1; - var maxSortOrder = - Database.ExecuteScalar( - "SELECT coalesce(max(sortOrder),0) FROM umbracoNode WHERE parentid = @ParentId AND nodeObjectType = @NodeObjectType", - new { ParentId = entity.ParentId, NodeObjectType = NodeObjectTypeId }); + var level = parent.Level + 1; + var maxSortOrder = Database.ExecuteScalar( + "SELECT coalesce(max(sortOrder),-1) FROM umbracoNode WHERE parentid = @ParentId AND nodeObjectType = @NodeObjectType", + new { /*ParentId =*/ entity.ParentId, NodeObjectType = NodeObjectTypeId }); var sortOrder = maxSortOrder + 1; //Create the (base) node data - umbracoNode diff --git a/src/Umbraco.Core/Persistence/Repositories/ContentTypeBaseRepository.cs b/src/Umbraco.Core/Persistence/Repositories/ContentTypeBaseRepository.cs index 951475c358..fd4577faa5 100644 --- a/src/Umbraco.Core/Persistence/Repositories/ContentTypeBaseRepository.cs +++ b/src/Umbraco.Core/Persistence/Repositories/ContentTypeBaseRepository.cs @@ -24,15 +24,18 @@ namespace Umbraco.Core.Persistence.Repositories /// /// Exposes shared functionality /// - internal abstract class ContentTypeBaseRepository : PetaPocoRepositoryBase + internal abstract class ContentTypeBaseRepository : PetaPocoRepositoryBase, IReadRepository where TEntity : class, IContentTypeComposition { protected ContentTypeBaseRepository(IDatabaseUnitOfWork work, CacheHelper cache, ILogger logger, ISqlSyntaxProvider sqlSyntax) : base(work, cache, logger, sqlSyntax) { + _guidRepo = new GuidReadOnlyContentTypeBaseRepository(this, work, cache, logger, sqlSyntax); } + private readonly GuidReadOnlyContentTypeBaseRepository _guidRepo; + /// /// The container object type - used for organizing content types /// @@ -119,7 +122,7 @@ namespace Umbraco.Core.Persistence.Repositories yield return dto.ContentTypeNodeId; } } - + protected virtual PropertyType CreatePropertyType(string propertyEditorAlias, DataTypeDatabaseType dbType, string propertyTypeAlias) { return new PropertyType(propertyEditorAlias, dbType, propertyTypeAlias); @@ -178,7 +181,7 @@ AND umbracoNode.nodeObjectType = @objectType", else { //Fallback for ContentTypes with no identity - var contentTypeDto = Database.FirstOrDefault("WHERE alias = @Alias", new {Alias = composition.Alias}); + var contentTypeDto = Database.FirstOrDefault("WHERE alias = @Alias", new { Alias = composition.Alias }); if (contentTypeDto != null) { Database.Insert(new ContentType2ContentTypeDto { ParentId = contentTypeDto.NodeId, ChildId = entity.Id }); @@ -198,7 +201,7 @@ AND umbracoNode.nodeObjectType = @objectType", } var propertyFactory = new PropertyGroupFactory(nodeDto.NodeId); - + //Insert Tabs foreach (var propertyGroup in entity.PropertyGroups) { @@ -259,16 +262,16 @@ AND umbracoNode.id <> @id", var o = Database.Update(nodeDto); //Look up ContentType entry to get PrimaryKey for updating the DTO - var dtoPk = Database.First("WHERE nodeId = @Id", new {Id = entity.Id}); + var dtoPk = Database.First("WHERE nodeId = @Id", new { Id = entity.Id }); dto.PrimaryKey = dtoPk.PrimaryKey; Database.Update(dto); //Delete the ContentType composition entries before adding the updated collection - Database.Delete("WHERE childContentTypeId = @Id", new {Id = entity.Id}); + Database.Delete("WHERE childContentTypeId = @Id", new { Id = entity.Id }); //Update ContentType composition in new table foreach (var composition in entity.ContentTypeComposition) { - Database.Insert(new ContentType2ContentTypeDto {ParentId = composition.Id, ChildId = entity.Id}); + Database.Insert(new ContentType2ContentTypeDto { ParentId = composition.Id, ChildId = entity.Id }); } //Removing a ContentType from a composition (U4-1690) @@ -293,7 +296,7 @@ AND umbracoNode.id <> @id", foreach (var key in compositionBase.RemovedContentTypeKeyTracker) { //Find PropertyTypes for the removed ContentType - var propertyTypes = Database.Fetch("WHERE contentTypeId = @Id", new {Id = key}); + var propertyTypes = Database.Fetch("WHERE contentTypeId = @Id", new { Id = key }); //Loop through the Content that is based on the current ContentType in order to remove the Properties that are //based on the PropertyTypes that belong to the removed ContentType. foreach (var contentDto in contentDtos) @@ -318,7 +321,7 @@ AND umbracoNode.id <> @id", } //Delete the allowed content type entries before adding the updated collection - Database.Delete("WHERE Id = @Id", new {Id = entity.Id}); + Database.Delete("WHERE Id = @Id", new { Id = entity.Id }); //Insert collection of allowed content types foreach (var allowedContentType in entity.AllowedContentTypes) { @@ -331,10 +334,10 @@ AND umbracoNode.id <> @id", } - if (((ICanBeDirty) entity).IsPropertyDirty("PropertyTypes") || entity.PropertyTypes.Any(x => x.IsDirty())) + if (((ICanBeDirty)entity).IsPropertyDirty("PropertyTypes") || entity.PropertyTypes.Any(x => x.IsDirty())) { //Delete PropertyTypes by excepting entries from db with entries from collections - var dbPropertyTypes = Database.Fetch("WHERE contentTypeId = @Id", new {Id = entity.Id}); + var dbPropertyTypes = Database.Fetch("WHERE contentTypeId = @Id", new { Id = entity.Id }); var dbPropertyTypeAlias = dbPropertyTypes.Select(x => x.Id); var entityPropertyTypes = entity.PropertyTypes.Where(x => x.HasIdentity).Select(x => x.Id); var items = dbPropertyTypeAlias.Except(entityPropertyTypes); @@ -342,18 +345,18 @@ AND umbracoNode.id <> @id", { //Before a PropertyType can be deleted, all Properties based on that PropertyType should be deleted. Database.Delete("WHERE propertyTypeId = @Id", new { Id = item }); - Database.Delete("WHERE propertytypeid = @Id", new {Id = item}); + Database.Delete("WHERE propertytypeid = @Id", new { Id = item }); Database.Delete("WHERE contentTypeId = @Id AND id = @PropertyTypeId", - new {Id = entity.Id, PropertyTypeId = item}); + new { Id = entity.Id, PropertyTypeId = item }); } } - if (entity.IsPropertyDirty("PropertyGroups") || + if (entity.IsPropertyDirty("PropertyGroups") || entity.PropertyGroups.Any(x => x.IsDirty())) { //Delete Tabs/Groups by excepting entries from db with entries from collections var dbPropertyGroups = - Database.Fetch("WHERE contenttypeNodeId = @Id", new {Id = entity.Id}) + Database.Fetch("WHERE contenttypeNodeId = @Id", new { Id = entity.Id }) .Select(x => new Tuple(x.Id, x.Text)) .ToList(); var entityPropertyGroups = entity.PropertyGroups.Select(x => new Tuple(x.Id, x.Name)).ToList(); @@ -389,11 +392,11 @@ AND umbracoNode.id <> @id", foreach (var tab in tabs) { Database.Update("SET propertyTypeGroupId = NULL WHERE propertyTypeGroupId = @PropertyGroupId", - new {PropertyGroupId = tab.Item1}); + new { PropertyGroupId = tab.Item1 }); Database.Update("SET parentGroupId = NULL WHERE parentGroupId = @TabId", - new {TabId = tab.Item1}); + new { TabId = tab.Item1 }); Database.Delete("WHERE contenttypeNodeId = @Id AND text = @Name", - new {Id = entity.Id, Name = tab.Item2}); + new { Id = entity.Id, Name = tab.Item2 }); } } @@ -507,7 +510,7 @@ AND umbracoNode.id <> @id", var list = new List(); foreach (var dto in dtos.Where(x => (x.PropertyTypeGroupId > 0) == false)) { - var propType = CreatePropertyType(dto.DataTypeDto.PropertyEditorAlias, dto.DataTypeDto.DbType.EnumParse(true), dto.Alias); + var propType = CreatePropertyType(dto.DataTypeDto.PropertyEditorAlias, dto.DataTypeDto.DbType.EnumParse(true), dto.Alias); propType.DataTypeDefinitionId = dto.DataTypeId; propType.Description = dto.Description; propType.Id = dto.Id; @@ -558,7 +561,7 @@ AND umbracoNode.id <> @id", throw exception; }); } - + /// /// Try to set the data type id based on its ControlId /// @@ -621,28 +624,30 @@ AND umbracoNode.id <> @id", } } - public static IEnumerable GetMediaTypes( - int[] mediaTypeIds, Database db, ISqlSyntaxProvider sqlSyntax, + public static IEnumerable GetMediaTypes( + TId[] mediaTypeIds, Database db, ISqlSyntaxProvider sqlSyntax, TRepo contentTypeRepository) - where TRepo : IRepositoryQueryable + where TRepo : IReadRepository + where TId: struct { - IDictionary> allParentMediaTypeIds; + IDictionary> allParentMediaTypeIds; var mediaTypes = MapMediaTypes(mediaTypeIds, db, sqlSyntax, out allParentMediaTypeIds) .ToArray(); MapContentTypeChildren(mediaTypes, db, sqlSyntax, contentTypeRepository, allParentMediaTypeIds); - + return mediaTypes; } - public static IEnumerable GetContentTypes( - int[] contentTypeIds, Database db, ISqlSyntaxProvider sqlSyntax, + public static IEnumerable GetContentTypes( + TId[] contentTypeIds, Database db, ISqlSyntaxProvider sqlSyntax, TRepo contentTypeRepository, ITemplateRepository templateRepository) - where TRepo : IRepositoryQueryable + where TRepo : IReadRepository + where TId : struct { - IDictionary> allAssociatedTemplates; - IDictionary> allParentContentTypeIds; + IDictionary> allAssociatedTemplates; + IDictionary> allParentContentTypeIds; var contentTypes = MapContentTypes(contentTypeIds, db, sqlSyntax, out allAssociatedTemplates, out allParentContentTypeIds) .ToArray(); @@ -652,17 +657,18 @@ AND umbracoNode.id <> @id", contentTypes, db, contentTypeRepository, templateRepository, allAssociatedTemplates); MapContentTypeChildren( - contentTypes, db, sqlSyntax, contentTypeRepository, allParentContentTypeIds); + contentTypes, db, sqlSyntax, contentTypeRepository, allParentContentTypeIds); } return contentTypes; } - internal static void MapContentTypeChildren(IContentTypeComposition[] contentTypes, + internal static void MapContentTypeChildren(IContentTypeComposition[] contentTypes, Database db, ISqlSyntaxProvider sqlSyntax, TRepo contentTypeRepository, - IDictionary> allParentContentTypeIds) - where TRepo : IRepositoryQueryable + IDictionary> allParentContentTypeIds) + where TRepo : IReadRepository + where TId : struct { //NOTE: SQL call #2 @@ -674,9 +680,9 @@ AND umbracoNode.id <> @id", foreach (var contentType in contentTypes) { contentType.PropertyGroups = allPropGroups[contentType.Id]; - ((ContentTypeBase) contentType).PropertyTypes = allPropTypes[contentType.Id]; + ((ContentTypeBase)contentType).PropertyTypes = allPropTypes[contentType.Id]; } - + //NOTE: SQL call #3++ if (allParentContentTypeIds != null) @@ -687,7 +693,18 @@ AND umbracoNode.id <> @id", var allParentContentTypes = contentTypeRepository.GetAll(allParentIdsAsArray).ToArray(); foreach (var contentType in contentTypes) { - var parentContentTypes = allParentContentTypes.Where(x => allParentContentTypeIds[contentType.Id].Contains(x.Id)); + //TODO: this is pretty hacky right now but i don't have time to refactor/fix running queries based on ints and Guids + // (i.e. for v8) but we need queries by GUIDs now so this is how it's gonna have to be + var entityId = typeof(TId) == typeof(int) ? contentType.Id : (object)contentType.Key; + + var parentContentTypes = allParentContentTypes.Where(x => + { + //TODO: this is pretty hacky right now but i don't have time to refactor/fix running queries based on ints and Guids + // (i.e. for v8) but we need queries by GUIDs now so this is how it's gonna have to be + var parentEntityId = typeof(TId) == typeof(int) ? x.Id : (object)x.Key; + + return allParentContentTypeIds[(TId)entityId].Contains((TId)parentEntityId); + }); foreach (var parentContentType in parentContentTypes) { var result = contentType.AddContentType(parentContentType); @@ -701,15 +718,16 @@ AND umbracoNode.id <> @id", } } - + } - internal static void MapContentTypeTemplates(IContentType[] contentTypes, + internal static void MapContentTypeTemplates(IContentType[] contentTypes, Database db, TRepo contentTypeRepository, ITemplateRepository templateRepository, - IDictionary> associatedTemplates) - where TRepo : IRepositoryQueryable + IDictionary> associatedTemplates) + where TRepo : IReadRepository + where TId: struct { if (associatedTemplates == null || associatedTemplates.Any() == false) return; @@ -726,7 +744,11 @@ AND umbracoNode.id <> @id", foreach (var contentType in contentTypes) { - var associatedTemplateIds = associatedTemplates[contentType.Id].Select(x => x.TemplateId) + //TODO: this is pretty hacky right now but i don't have time to refactor/fix running queries based on ints and Guids + // (i.e. for v8) but we need queries by GUIDs now so this is how it's gonna have to be + var entityId = typeof(TId) == typeof(int) ? contentType.Id : (object)contentType.Key; + + var associatedTemplateIds = associatedTemplates[(TId)entityId].Select(x => x.TemplateId) .Distinct() .ToArray(); @@ -735,11 +757,12 @@ AND umbracoNode.id <> @id", : Enumerable.Empty()).ToArray(); } - + } - internal static IEnumerable MapMediaTypes(int[] mediaTypeIds, Database db, ISqlSyntaxProvider sqlSyntax, - out IDictionary> parentMediaTypeIds) + internal static IEnumerable MapMediaTypes(TId[] mediaTypeIds, Database db, ISqlSyntaxProvider sqlSyntax, + out IDictionary> parentMediaTypeIds) + where TId : struct { Mandate.That(mediaTypeIds.Any(), () => new InvalidOperationException("must be at least one content type id specified")); Mandate.ParameterNotNull(db, "db"); @@ -766,8 +789,21 @@ AND umbracoNode.id <> @id", ON AllowedTypes.Id = cmsContentType.nodeId LEFT JOIN cmsContentType2ContentType as ParentTypes ON ParentTypes.childContentTypeId = cmsContentType.nodeId - WHERE (umbracoNode.nodeObjectType = @nodeObjectType) - AND (umbracoNode.id IN (@contentTypeIds))"; + WHERE (umbracoNode.nodeObjectType = @nodeObjectType)"; + + if (mediaTypeIds.Any()) + { + //TODO: This is all sorts of hacky but i don't have time to refactor a lot to get both ints and guids working nicely... this will + // work for the time being. + if (typeof(TId) == typeof(int)) + { + sql = sql + " AND (umbracoNode.id IN (@contentTypeIds))"; + } + else if (typeof(TId) == typeof(Guid)) + { + sql = sql + " AND (umbracoNode.uniqueID IN (@contentTypeIds))"; + } + } //NOTE: we are going to assume there's not going to be more than 2100 content type ids since that is the max SQL param count! if ((mediaTypeIds.Length - 1) > 2000) @@ -781,7 +817,7 @@ AND umbracoNode.id <> @id", return Enumerable.Empty(); } - parentMediaTypeIds = new Dictionary>(); + parentMediaTypeIds = new Dictionary>(); var mappedMediaTypes = new List(); foreach (var contentTypeId in mediaTypeIds) @@ -793,7 +829,14 @@ AND umbracoNode.id <> @id", //first we want to get the main content type data this is 1 : 1 with umbraco node data var ct = result - .Where(x => x.ctId == currentCtId) + .Where(x => + { + //TODO: This is a bit hacky right now but don't have time to do a nice refactor to support both GUID and Int queries, so this is + // how it is for now. + return (typeof (TId) == typeof (int)) + ? x.ctId == currentCtId + : x.nUniqueId == currentCtId; + }) .Select(x => new { x.ctPk, x.ctId, x.ctAlias, x.ctAllowAtRoot, x.ctDesc, x.ctIcon, x.ctIsContainer, x.ctThumb, x.nName, x.nCreateDate, x.nLevel, x.nObjectType, x.nUser, x.nParentId, x.nPath, x.nSortOrder, x.nTrashed, x.nUniqueId }) .DistinctBy(x => (int)x.ctId) .FirstOrDefault(); @@ -817,7 +860,7 @@ AND umbracoNode.id <> @id", NodeDto = new NodeDto { CreateDate = ct.nCreateDate, - Level = (short) ct.nLevel, + Level = (short)ct.nLevel, NodeId = ct.ctId, NodeObjectType = ct.nObjectType, ParentId = ct.nParentId, @@ -829,7 +872,7 @@ AND umbracoNode.id <> @id", UserId = ct.nUser } }; - + //now create the media type object var factory = new MediaTypeFactory(new Guid(Constants.ObjectTypes.MediaType)); @@ -845,9 +888,10 @@ AND umbracoNode.id <> @id", return mappedMediaTypes; } - internal static IEnumerable MapContentTypes(int[] contentTypeIds, Database db, ISqlSyntaxProvider sqlSyntax, - out IDictionary> associatedTemplates, - out IDictionary> parentContentTypeIds) + internal static IEnumerable MapContentTypes(TId[] contentTypeIds, Database db, ISqlSyntaxProvider sqlSyntax, + out IDictionary> associatedTemplates, + out IDictionary> parentContentTypeIds) + where TId : struct { Mandate.ParameterNotNull(db, "db"); @@ -884,8 +928,21 @@ AND umbracoNode.id <> @id", LEFT JOIN cmsContentType2ContentType as ParentTypes ON ParentTypes.childContentTypeId = cmsContentType.nodeId WHERE (umbracoNode.nodeObjectType = @nodeObjectType)"; - if(contentTypeIds.Any()) - sql = sql + " AND (umbracoNode.id IN (@contentTypeIds))"; + + if (contentTypeIds.Any()) + { + //TODO: This is all sorts of hacky but i don't have time to refactor a lot to get both ints and guids working nicely... this will + // work for the time being. + if (typeof(TId) == typeof(int)) + { + sql = sql + " AND (umbracoNode.id IN (@contentTypeIds))"; + } + else if (typeof(TId) == typeof(Guid)) + { + sql = sql + " AND (umbracoNode.uniqueID IN (@contentTypeIds))"; + } + } + //NOTE: we are going to assume there's not going to be more than 2100 content type ids since that is the max SQL param count! if ((contentTypeIds.Length - 1) > 2000) @@ -900,8 +957,8 @@ AND umbracoNode.id <> @id", return Enumerable.Empty(); } - parentContentTypeIds = new Dictionary>(); - associatedTemplates = new Dictionary>(); + parentContentTypeIds = new Dictionary>(); + associatedTemplates = new Dictionary>(); var mappedContentTypes = new List(); foreach (var contentTypeId in contentTypeIds) @@ -913,7 +970,14 @@ AND umbracoNode.id <> @id", //first we want to get the main content type data this is 1 : 1 with umbraco node data var ct = result - .Where(x => (int)x.ctId == currentCtId) + .Where(x => + { + //TODO: This is a bit hacky right now but don't have time to do a nice refactor to support both GUID and Int queries, so this is + // how it is for now. + return (typeof(TId) == typeof(int)) + ? x.ctId == currentCtId + : x.nUniqueId == currentCtId; + }) .Select(x => new { x.ctPk, x.ctId, x.ctAlias, x.ctAllowAtRoot, x.ctDesc, x.ctIcon, x.ctIsContainer, x.ctThumb, x.nName, x.nCreateDate, x.nLevel, x.nObjectType, x.nUser, x.nParentId, x.nPath, x.nSortOrder, x.nTrashed, x.nUniqueId }) .DistinctBy(x => (int)x.ctId) .FirstOrDefault(); @@ -925,7 +989,14 @@ AND umbracoNode.id <> @id", //get the unique list of associated templates var defaultTemplates = result - .Where(x => x.ctId == currentCtId) + .Where(x => + { + //TODO: This is a bit hacky right now but don't have time to do a nice refactor to support both GUID and Int queries, so this is + // how it is for now. + return (typeof(TId) == typeof(int)) + ? x.ctId == currentCtId + : x.nUniqueId == currentCtId; + }) //use a tuple so that distinct checks both values (in some rare cases the dtIsDefault will not compute as bool?, so we force it with Convert.ToBoolean) .Select(x => new Tuple(Convert.ToBoolean(x.dtIsDefault), x.dtTemplateId)) .Where(x => x.Item1.HasValue && x.Item2.HasValue) @@ -973,7 +1044,14 @@ AND umbracoNode.id <> @id", // We will map a subset of the associated template - alias, id, name associatedTemplates.Add(currentCtId, result - .Where(x => x.ctId == currentCtId) + .Where(x => + { + //TODO: This is a bit hacky right now but don't have time to do a nice refactor to support both GUID and Int queries, so this is + // how it is for now. + return (typeof(TId) == typeof(int)) + ? x.ctId == currentCtId + : x.nUniqueId == currentCtId; + }) .Where(x => x.tId != null) .Select(x => new AssociatedTemplate(x.tId, x.tAlias, x.tText)) .Distinct() @@ -987,19 +1065,27 @@ AND umbracoNode.id <> @id", //map the allowed content types //map the child content type ids MapCommonContentTypeObjects(contentType, currentCtId, result, parentContentTypeIds); - + mappedContentTypes.Add(contentType); } return mappedContentTypes; } - private static void MapCommonContentTypeObjects(T contentType, int currentCtId, List result, IDictionary> parentContentTypeIds) - where T: IContentTypeBase + private static void MapCommonContentTypeObjects(T contentType, TId currentCtId, List result, IDictionary> parentContentTypeIds) + where T : IContentTypeBase + where TId : struct { //map the allowed content types contentType.AllowedContentTypes = result - .Where(x => x.ctId == currentCtId) + .Where(x => + { + //TODO: This is a bit hacky right now but don't have time to do a nice refactor to support both GUID and Int queries, so this is + // how it is for now. + return (typeof(TId) == typeof(int)) + ? x.ctId == currentCtId + : x.nUniqueId == currentCtId; + }) //use tuple so we can use distinct on all vals .Select(x => new Tuple(x.ctaAllowedId, x.ctaSortOrder, x.ctaAlias)) .Where(x => x.Item1.HasValue && x.Item2.HasValue && x.Item3 != null) @@ -1009,8 +1095,15 @@ AND umbracoNode.id <> @id", //map the child content type ids parentContentTypeIds.Add(currentCtId, result - .Where(x => x.ctId == currentCtId) - .Select(x => (int?)x.chtParentId) + .Where(x => + { + //TODO: This is a bit hacky right now but don't have time to do a nice refactor to support both GUID and Int queries, so this is + // how it is for now. + return (typeof(TId) == typeof(int)) + ? x.ctId == currentCtId + : x.nUniqueId == currentCtId; + }) + .Select(x => (TId?)x.chtParentId) .Where(x => x.HasValue) .Distinct() .Select(x => x.Value).ToList()); @@ -1019,7 +1112,7 @@ AND umbracoNode.id <> @id", internal static void MapGroupsAndProperties(int[] contentTypeIds, Database db, ISqlSyntaxProvider sqlSyntax, out IDictionary allPropertyTypeCollection, out IDictionary allPropertyGroupCollection) - { + { // first part Gets all property groups including property type data even when no property type exists on the group // second part Gets all property types including ones that are not on a group @@ -1057,7 +1150,7 @@ AND umbracoNode.id <> @id", LEFT JOIN cmsPropertyTypeGroup as PG ON PG.id = PT.propertyTypeGroupId"); - if(contentTypeIds.Any()) + if (contentTypeIds.Any()) sqlBuilder.AppendLine(" WHERE (PT.contentTypeId in (@contentTypeIds))"); sqlBuilder.AppendLine(" ORDER BY (pgId)"); @@ -1082,7 +1175,7 @@ AND umbracoNode.id <> @id", int currId = contentTypeId; - var propertyGroupCollection = new PropertyGroupCollection(result + var propertyGroupCollection = new PropertyGroupCollection(result //get all rows that have a group id .Where(x => x.pgId != null) //filter based on the current content type @@ -1120,7 +1213,7 @@ AND umbracoNode.id <> @id", //Create the property type collection now (that don't have groups) - var propertyTypeCollection = new PropertyTypeCollection(result + var propertyTypeCollection = new PropertyTypeCollection(result .Where(x => x.pgId == null) //filter based on the current content type .Where(x => x.contentTypeId == currId) @@ -1141,9 +1234,105 @@ AND umbracoNode.id <> @id", allPropertyTypeCollection[currId] = propertyTypeCollection; } - + } } + + /// + /// Inner repository to support the GUID lookups and keep the caching consistent + /// + internal class GuidReadOnlyContentTypeBaseRepository : PetaPocoRepositoryBase + { + private readonly ContentTypeBaseRepository _parentRepo; + + public GuidReadOnlyContentTypeBaseRepository( + ContentTypeBaseRepository parentRepo, + IDatabaseUnitOfWork work, CacheHelper cache, ILogger logger, ISqlSyntaxProvider sqlSyntax) + : base(work, cache, logger, sqlSyntax) + { + _parentRepo = parentRepo; + } + + protected override TEntity PerformGet(Guid id) + { + return _parentRepo.PerformGet(id); + } + + protected override IEnumerable PerformGetAll(params Guid[] ids) + { + return _parentRepo.PerformGetAll(ids); + } + + protected override Sql GetBaseQuery(bool isCount) + { + return _parentRepo.GetBaseQuery(isCount); + } + + protected override string GetBaseWhereClause() + { + return "umbracoNode.uniqueID = @Id"; + } + + #region No implementation required + protected override IEnumerable PerformGetByQuery(IQuery query) + { + throw new NotImplementedException(); + } + + protected override IEnumerable GetDeleteClauses() + { + throw new NotImplementedException(); + } + + protected override Guid NodeObjectTypeId + { + get { throw new NotImplementedException(); } + } + + protected override void PersistNewItem(TEntity entity) + { + throw new NotImplementedException(); + } + + protected override void PersistUpdatedItem(TEntity entity) + { + throw new NotImplementedException(); + } + #endregion + } + + protected abstract TEntity PerformGet(Guid id); + protected abstract IEnumerable PerformGetAll(params Guid[] ids); + + /// + /// Gets an Entity by Id + /// + /// + /// + public TEntity Get(Guid id) + { + return _guidRepo.Get(id); + } + + /// + /// Gets all entities of the spefified type + /// + /// + /// + public IEnumerable GetAll(params Guid[] ids) + { + return _guidRepo.GetAll(ids); + } + + /// + /// Boolean indicating whether an Entity with the specified Id exists + /// + /// + /// + public bool Exists(Guid id) + { + return _guidRepo.Exists(id); + } } } \ No newline at end of file diff --git a/src/Umbraco.Core/Persistence/Repositories/ContentTypeRepository.cs b/src/Umbraco.Core/Persistence/Repositories/ContentTypeRepository.cs index 4db21a5616..ab22b66679 100644 --- a/src/Umbraco.Core/Persistence/Repositories/ContentTypeRepository.cs +++ b/src/Umbraco.Core/Persistence/Repositories/ContentTypeRepository.cs @@ -249,5 +249,28 @@ namespace Umbraco.Core.Persistence.Repositories { get { return new Guid(Constants.ObjectTypes.DocumentTypeContainer); } } + + protected override IContentType PerformGet(Guid id) + { + var contentTypes = ContentTypeQueryMapper.GetContentTypes( + new[] { id }, Database, SqlSyntax, this, _templateRepository); + + var contentType = contentTypes.SingleOrDefault(); + return contentType; + } + + protected override IEnumerable PerformGetAll(params Guid[] ids) + { + if (ids.Any()) + { + return ContentTypeQueryMapper.GetContentTypes(ids, Database, SqlSyntax, this, _templateRepository); + } + else + { + var sql = new Sql().Select("id").From(SqlSyntax).Where(dto => dto.NodeObjectType == NodeObjectTypeId); + var allIds = Database.Fetch(sql).ToArray(); + return ContentTypeQueryMapper.GetContentTypes(allIds, Database, SqlSyntax, this, _templateRepository); + } + } } } \ No newline at end of file diff --git a/src/Umbraco.Core/Persistence/Repositories/ContentXmlRepository.cs b/src/Umbraco.Core/Persistence/Repositories/ContentXmlRepository.cs index a9d5850368..b242bb34f7 100644 --- a/src/Umbraco.Core/Persistence/Repositories/ContentXmlRepository.cs +++ b/src/Umbraco.Core/Persistence/Repositories/ContentXmlRepository.cs @@ -81,8 +81,8 @@ namespace Umbraco.Core.Persistence.Repositories var poco = new ContentXmlDto { - NodeId = entity.Id, - Xml = entity.Xml.ToString(SaveOptions.None) + NodeId = entity.Id, + Xml = entity.Xml.ToDataString() }; //We need to do a special InsertOrUpdate here because we know that the ContentXmlDto table has a 1:1 relation diff --git a/src/Umbraco.Core/Persistence/Repositories/DataTypeDefinitionRepository.cs b/src/Umbraco.Core/Persistence/Repositories/DataTypeDefinitionRepository.cs index 30b92b2ddc..859c4e7ae7 100644 --- a/src/Umbraco.Core/Persistence/Repositories/DataTypeDefinitionRepository.cs +++ b/src/Umbraco.Core/Persistence/Repositories/DataTypeDefinitionRepository.cs @@ -3,6 +3,7 @@ using System.Collections.Generic; using System.Data; using System.Globalization; using System.Linq; +using System.Text.RegularExpressions; using System.Threading; using Umbraco.Core.Cache; using Umbraco.Core.Logging; @@ -279,19 +280,22 @@ AND umbracoNode.id <> @id", return GetAndCachePreValueCollection(dataTypeId); } + internal static string GetCacheKeyRegex(int preValueId) + { + return CacheKeys.DataTypePreValuesCacheKey + @"[-\d]+-([\d]*,)*" + preValueId + @"(?!\d)[,\d$]*"; + } + public string GetPreValueAsString(int preValueId) { //We need to see if we can find the cached PreValueCollection based on the cache key above - var regex = CacheKeys.DataTypePreValuesCacheKey + @"[\d]+-[,\d]*" + preValueId + @"[,\d$]*"; - - var cached = _cacheHelper.RuntimeCache.GetCacheItemsByKeyExpression(regex); + var cached = _cacheHelper.RuntimeCache.GetCacheItemsByKeyExpression(GetCacheKeyRegex(preValueId)); if (cached != null && cached.Any()) { //return from the cache var collection = cached.First(); - var preVal = collection.FormatAsDictionary().Single(x => x.Value.Id == preValueId); - return preVal.Value.Value; + var preVal = collection.FormatAsDictionary().Single(x => x.Value.Id == preValueId); + return preVal.Value.Value; } //go and find the data type id for the pre val id passed in diff --git a/src/Umbraco.Core/Persistence/Repositories/DictionaryRepository.cs b/src/Umbraco.Core/Persistence/Repositories/DictionaryRepository.cs index cf3193943b..1e84814d1b 100644 --- a/src/Umbraco.Core/Persistence/Repositories/DictionaryRepository.cs +++ b/src/Umbraco.Core/Persistence/Repositories/DictionaryRepository.cs @@ -103,12 +103,9 @@ namespace Umbraco.Core.Persistence.Repositories return new List(); } - /// - /// Returns the Top Level Parent Guid Id - /// protected override Guid NodeObjectTypeId { - get { return new Guid(Constants.Conventions.Localization.DictionaryItemRootId); } + get { throw new NotImplementedException(); } } #endregion diff --git a/src/Umbraco.Core/Persistence/Repositories/Interfaces/IContentRepository.cs b/src/Umbraco.Core/Persistence/Repositories/Interfaces/IContentRepository.cs index c27dd96d46..9d3fcbb40b 100644 --- a/src/Umbraco.Core/Persistence/Repositories/Interfaces/IContentRepository.cs +++ b/src/Umbraco.Core/Persistence/Repositories/Interfaces/IContentRepository.cs @@ -9,7 +9,7 @@ using Umbraco.Core.Persistence.Querying; namespace Umbraco.Core.Persistence.Repositories { - public interface IContentRepository : IRepositoryVersionable, IRecycleBinRepository + public interface IContentRepository : IRepositoryVersionable, IRecycleBinRepository, IDeleteMediaFilesRepository { /// /// Get the count of published items diff --git a/src/Umbraco.Core/Persistence/Repositories/Interfaces/IContentTypeRepository.cs b/src/Umbraco.Core/Persistence/Repositories/Interfaces/IContentTypeRepository.cs index b612a9109d..245552e422 100644 --- a/src/Umbraco.Core/Persistence/Repositories/Interfaces/IContentTypeRepository.cs +++ b/src/Umbraco.Core/Persistence/Repositories/Interfaces/IContentTypeRepository.cs @@ -5,7 +5,7 @@ using Umbraco.Core.Persistence.Querying; namespace Umbraco.Core.Persistence.Repositories { - public interface IContentTypeRepository : IRepositoryQueryable + public interface IContentTypeRepository : IRepositoryQueryable, IReadRepository { /// /// Gets all entities of the specified query diff --git a/src/Umbraco.Core/Persistence/Repositories/Interfaces/IDeleteMediaFilesRepository.cs b/src/Umbraco.Core/Persistence/Repositories/Interfaces/IDeleteMediaFilesRepository.cs new file mode 100644 index 0000000000..005c1d62ba --- /dev/null +++ b/src/Umbraco.Core/Persistence/Repositories/Interfaces/IDeleteMediaFilesRepository.cs @@ -0,0 +1,14 @@ +using System.Collections.Generic; + +namespace Umbraco.Core.Persistence.Repositories +{ + public interface IDeleteMediaFilesRepository + { + /// + /// Called to remove all files associated with entities when an entity is permanently deleted + /// + /// + /// + bool DeleteMediaFiles(IEnumerable files); + } +} \ No newline at end of file diff --git a/src/Umbraco.Core/Persistence/Repositories/Interfaces/IMediaRepository.cs b/src/Umbraco.Core/Persistence/Repositories/Interfaces/IMediaRepository.cs index 1149949e31..46bce6a03c 100644 --- a/src/Umbraco.Core/Persistence/Repositories/Interfaces/IMediaRepository.cs +++ b/src/Umbraco.Core/Persistence/Repositories/Interfaces/IMediaRepository.cs @@ -7,7 +7,7 @@ using Umbraco.Core.Persistence.Querying; namespace Umbraco.Core.Persistence.Repositories { - public interface IMediaRepository : IRepositoryVersionable, IRecycleBinRepository + public interface IMediaRepository : IRepositoryVersionable, IRecycleBinRepository, IDeleteMediaFilesRepository { /// diff --git a/src/Umbraco.Core/Persistence/Repositories/Interfaces/IMediaTypeRepository.cs b/src/Umbraco.Core/Persistence/Repositories/Interfaces/IMediaTypeRepository.cs index 54220e0b59..d28c59ac5b 100644 --- a/src/Umbraco.Core/Persistence/Repositories/Interfaces/IMediaTypeRepository.cs +++ b/src/Umbraco.Core/Persistence/Repositories/Interfaces/IMediaTypeRepository.cs @@ -1,10 +1,11 @@ -using System.Collections.Generic; +using System; +using System.Collections.Generic; using Umbraco.Core.Models; using Umbraco.Core.Persistence.Querying; namespace Umbraco.Core.Persistence.Repositories { - public interface IMediaTypeRepository : IRepositoryQueryable + public interface IMediaTypeRepository : IRepositoryQueryable, IReadRepository { /// /// Gets all entities of the specified query diff --git a/src/Umbraco.Core/Persistence/Repositories/Interfaces/IMemberRepository.cs b/src/Umbraco.Core/Persistence/Repositories/Interfaces/IMemberRepository.cs index 2436ffbfb6..9cb74d1806 100644 --- a/src/Umbraco.Core/Persistence/Repositories/Interfaces/IMemberRepository.cs +++ b/src/Umbraco.Core/Persistence/Repositories/Interfaces/IMemberRepository.cs @@ -9,7 +9,7 @@ using Umbraco.Core.Persistence.Querying; namespace Umbraco.Core.Persistence.Repositories { - public interface IMemberRepository : IRepositoryVersionable + public interface IMemberRepository : IRepositoryVersionable, IDeleteMediaFilesRepository { /// /// Finds members in a given role diff --git a/src/Umbraco.Core/Persistence/Repositories/Interfaces/IMemberTypeRepository.cs b/src/Umbraco.Core/Persistence/Repositories/Interfaces/IMemberTypeRepository.cs index 9e91b1c87c..ae7739b28b 100644 --- a/src/Umbraco.Core/Persistence/Repositories/Interfaces/IMemberTypeRepository.cs +++ b/src/Umbraco.Core/Persistence/Repositories/Interfaces/IMemberTypeRepository.cs @@ -1,8 +1,9 @@ -using Umbraco.Core.Models; +using System; +using Umbraco.Core.Models; namespace Umbraco.Core.Persistence.Repositories { - public interface IMemberTypeRepository : IRepositoryQueryable + public interface IMemberTypeRepository : IRepositoryQueryable, IReadRepository { } diff --git a/src/Umbraco.Core/Persistence/Repositories/Interfaces/IRecycleBinRepository.cs b/src/Umbraco.Core/Persistence/Repositories/Interfaces/IRecycleBinRepository.cs index e1a464af66..a6ed95711e 100644 --- a/src/Umbraco.Core/Persistence/Repositories/Interfaces/IRecycleBinRepository.cs +++ b/src/Umbraco.Core/Persistence/Repositories/Interfaces/IRecycleBinRepository.cs @@ -18,12 +18,6 @@ namespace Umbraco.Core.Persistence.Repositories /// /// bool EmptyRecycleBin(); - - /// - /// Called to remove all files associated with entities when recycle bin is emptied - /// - /// - /// - bool DeleteFiles(IEnumerable files); + } } \ No newline at end of file diff --git a/src/Umbraco.Core/Persistence/Repositories/Interfaces/IRepository.cs b/src/Umbraco.Core/Persistence/Repositories/Interfaces/IRepository.cs index 9cb4d938c7..ecee9af138 100644 --- a/src/Umbraco.Core/Persistence/Repositories/Interfaces/IRepository.cs +++ b/src/Umbraco.Core/Persistence/Repositories/Interfaces/IRepository.cs @@ -15,23 +15,8 @@ namespace Umbraco.Core.Persistence.Repositories } - /// - /// Defines the implementation of a Repository - /// - public interface IRepository : IRepository - { - /// - /// Adds or Updates an Entity - /// - /// - void AddOrUpdate(TEntity entity); - - /// - /// Deletes an Entity - /// - /// - void Delete(TEntity entity); - + public interface IReadRepository : IRepository + { /// /// Gets an Entity by Id /// @@ -52,5 +37,25 @@ namespace Umbraco.Core.Persistence.Repositories /// /// bool Exists(TId id); - } + } + + //TODO: This should be decoupled! Shouldn't inherit from the IReadRepository and should be named IWriteRepository + + /// + /// Defines the implementation of a Repository + /// + public interface IRepository : IReadRepository + { + /// + /// Adds or Updates an Entity + /// + /// + void AddOrUpdate(TEntity entity); + + /// + /// Deletes an Entity + /// + /// + void Delete(TEntity entity); + } } \ No newline at end of file diff --git a/src/Umbraco.Core/Persistence/Repositories/Interfaces/IRepositoryQueryable.cs b/src/Umbraco.Core/Persistence/Repositories/Interfaces/IRepositoryQueryable.cs index c32f1b33a6..c0682f94f3 100644 --- a/src/Umbraco.Core/Persistence/Repositories/Interfaces/IRepositoryQueryable.cs +++ b/src/Umbraco.Core/Persistence/Repositories/Interfaces/IRepositoryQueryable.cs @@ -4,6 +4,8 @@ using Umbraco.Core.Persistence.Querying; namespace Umbraco.Core.Persistence.Repositories { + //TODO: This should be decoupled! Shouldn't inherit from the IRepository + /// /// Defines the implementation of a Repository, which allows queries against the /// diff --git a/src/Umbraco.Core/Persistence/Repositories/MediaRepository.cs b/src/Umbraco.Core/Persistence/Repositories/MediaRepository.cs index 008e588311..4a9c110359 100644 --- a/src/Umbraco.Core/Persistence/Repositories/MediaRepository.cs +++ b/src/Umbraco.Core/Persistence/Repositories/MediaRepository.cs @@ -5,6 +5,7 @@ using System.Linq; using System.Text; using System.Xml.Linq; using Umbraco.Core.Configuration; +using Umbraco.Core.Configuration.UmbracoSettings; using Umbraco.Core.Dynamics; using Umbraco.Core.IO; using Umbraco.Core.Logging; @@ -31,8 +32,8 @@ namespace Umbraco.Core.Persistence.Repositories private readonly ContentXmlRepository _contentXmlRepository; private readonly ContentPreviewRepository _contentPreviewRepository; - public MediaRepository(IDatabaseUnitOfWork work, CacheHelper cache, ILogger logger, ISqlSyntaxProvider sqlSyntax, IMediaTypeRepository mediaTypeRepository, ITagRepository tagRepository) - : base(work, cache, logger, sqlSyntax) + public MediaRepository(IDatabaseUnitOfWork work, CacheHelper cache, ILogger logger, ISqlSyntaxProvider sqlSyntax, IMediaTypeRepository mediaTypeRepository, ITagRepository tagRepository, IContentSection contentSection) + : base(work, cache, logger, sqlSyntax, contentSection) { if (mediaTypeRepository == null) throw new ArgumentNullException("mediaTypeRepository"); if (tagRepository == null) throw new ArgumentNullException("tagRepository"); @@ -40,10 +41,10 @@ namespace Umbraco.Core.Persistence.Repositories _tagRepository = tagRepository; _contentXmlRepository = new ContentXmlRepository(work, CacheHelper.CreateDisabledCacheHelper(), logger, sqlSyntax); _contentPreviewRepository = new ContentPreviewRepository(work, CacheHelper.CreateDisabledCacheHelper(), logger, sqlSyntax); - EnsureUniqueNaming = true; + EnsureUniqueNaming = contentSection.EnsureUniqueNaming; } - public bool EnsureUniqueNaming { get; set; } + public bool EnsureUniqueNaming { get; private set; } #region Overrides of RepositoryBase @@ -235,7 +236,7 @@ namespace Umbraco.Core.Persistence.Repositories var xmlItems = (from descendant in descendants let xml = serializer(descendant) - select new ContentXmlDto { NodeId = descendant.Id, Xml = xml.ToString(SaveOptions.None) }).ToArray(); + select new ContentXmlDto { NodeId = descendant.Id, Xml = xml.ToDataString() }).ToArray(); //bulk insert it into the database Database.BulkInsertRecords(xmlItems, tr); @@ -283,10 +284,11 @@ namespace Umbraco.Core.Persistence.Repositories //NOTE Should the logic below have some kind of fallback for empty parent ids ? //Logic for setting Path, Level and SortOrder var parent = Database.First("WHERE id = @ParentId", new { ParentId = entity.ParentId }); - int level = parent.Level + 1; - int sortOrder = - Database.ExecuteScalar("SELECT COUNT(*) FROM umbracoNode WHERE parentID = @ParentId AND nodeObjectType = @NodeObjectType", - new { ParentId = entity.ParentId, NodeObjectType = NodeObjectTypeId }); + var level = parent.Level + 1; + var maxSortOrder = Database.ExecuteScalar( + "SELECT coalesce(max(sortOrder),-1) FROM umbracoNode WHERE parentid = @ParentId AND nodeObjectType = @NodeObjectType", + new { /*ParentId =*/ entity.ParentId, NodeObjectType = NodeObjectTypeId }); + var sortOrder = maxSortOrder + 1; //Create the (base) node data - umbracoNode var nodeDto = dto.ContentDto.NodeDto; diff --git a/src/Umbraco.Core/Persistence/Repositories/MediaTypeRepository.cs b/src/Umbraco.Core/Persistence/Repositories/MediaTypeRepository.cs index 13cdab400e..3bf70f1135 100644 --- a/src/Umbraco.Core/Persistence/Repositories/MediaTypeRepository.cs +++ b/src/Umbraco.Core/Persistence/Repositories/MediaTypeRepository.cs @@ -28,31 +28,10 @@ namespace Umbraco.Core.Persistence.Repositories protected override IMediaType PerformGet(int id) { - var contentTypeSql = GetBaseQuery(false); - contentTypeSql.Where(GetBaseWhereClause(), new { Id = id}); + var contentTypes = ContentTypeQueryMapper.GetMediaTypes( + new[] { id }, Database, SqlSyntax, this); - var dto = Database.Fetch(contentTypeSql).FirstOrDefault(); - - if (dto == null) - return null; - - var factory = new MediaTypeFactory(NodeObjectTypeId); - var contentType = factory.BuildEntity(dto); - - contentType.AllowedContentTypes = GetAllowedContentTypeIds(id); - contentType.PropertyGroups = GetPropertyGroupCollection(id, contentType.CreateDate, contentType.UpdateDate); - ((MediaType)contentType).PropertyTypes = GetPropertyTypeCollection(id, contentType.CreateDate, contentType.UpdateDate); - - var list = Database.Fetch("WHERE childContentTypeId = @Id", new{ Id = id}); - foreach (var contentTypeDto in list) - { - bool result = contentType.AddContentType(Get(contentTypeDto.ParentId)); - //Do something if adding fails? (Should hopefully not be possible unless someone create a circular reference) - } - - //on initial construction we don't want to have dirty properties tracked - // http://issues.umbraco.org/issue/U4-1946 - ((Entity)contentType).ResetDirtyProperties(false); + var contentType = contentTypes.SingleOrDefault(); return contentType; } @@ -85,13 +64,18 @@ namespace Umbraco.Core.Persistence.Repositories #endregion + + /// + /// Gets all entities of the specified query + /// + /// + /// An enumerable list of objects public IEnumerable GetByQuery(IQuery query) { - var ints = PerformGetByQuery(query); - foreach (var i in ints) - { - yield return Get(i); - } + var ints = PerformGetByQuery(query).ToArray(); + return ints.Any() + ? GetAll(ints) + : Enumerable.Empty(); } #region Overrides of PetaPocoRepositoryBase @@ -189,5 +173,28 @@ namespace Umbraco.Core.Persistence.Repositories { get { throw new NotImplementedException(); } } + + protected override IMediaType PerformGet(Guid id) + { + var contentTypes = ContentTypeQueryMapper.GetMediaTypes( + new[] { id }, Database, SqlSyntax, this); + + var contentType = contentTypes.SingleOrDefault(); + return contentType; + } + + protected override IEnumerable PerformGetAll(params Guid[] ids) + { + if (ids.Any()) + { + return ContentTypeQueryMapper.GetMediaTypes(ids, Database, SqlSyntax, this); + } + else + { + var sql = new Sql().Select("id").From(SqlSyntax).Where(dto => dto.NodeObjectType == NodeObjectTypeId); + var allIds = Database.Fetch(sql).ToArray(); + return ContentTypeQueryMapper.GetMediaTypes(allIds, Database, SqlSyntax, this); + } + } } } \ No newline at end of file diff --git a/src/Umbraco.Core/Persistence/Repositories/MemberRepository.cs b/src/Umbraco.Core/Persistence/Repositories/MemberRepository.cs index 8c6edbd27e..02f5fb10c1 100644 --- a/src/Umbraco.Core/Persistence/Repositories/MemberRepository.cs +++ b/src/Umbraco.Core/Persistence/Repositories/MemberRepository.cs @@ -6,6 +6,7 @@ using System.Linq.Expressions; using System.Text; using System.Xml.Linq; using Umbraco.Core.Configuration; +using Umbraco.Core.Configuration.UmbracoSettings; using Umbraco.Core.IO; using Umbraco.Core.Logging; using Umbraco.Core.Models.EntityBase; @@ -33,8 +34,8 @@ namespace Umbraco.Core.Persistence.Repositories private readonly ContentXmlRepository _contentXmlRepository; private readonly ContentPreviewRepository _contentPreviewRepository; - public MemberRepository(IDatabaseUnitOfWork work, CacheHelper cache, ILogger logger, ISqlSyntaxProvider sqlSyntax, IMemberTypeRepository memberTypeRepository, IMemberGroupRepository memberGroupRepository, ITagRepository tagRepository) - : base(work, cache, logger, sqlSyntax) + public MemberRepository(IDatabaseUnitOfWork work, CacheHelper cache, ILogger logger, ISqlSyntaxProvider sqlSyntax, IMemberTypeRepository memberTypeRepository, IMemberGroupRepository memberGroupRepository, ITagRepository tagRepository, IContentSection contentSection) + : base(work, cache, logger, sqlSyntax, contentSection) { if (memberTypeRepository == null) throw new ArgumentNullException("memberTypeRepository"); if (tagRepository == null) throw new ArgumentNullException("tagRepository"); @@ -373,36 +374,6 @@ namespace Umbraco.Core.Persistence.Repositories dirtyEntity.ResetDirtyProperties(); } - protected override void PersistDeletedItem(IMember entity) - { - var fs = FileSystemProviderManager.Current.GetFileSystemProvider(); - var uploadFieldAlias = Constants.PropertyEditors.UploadFieldAlias; - //Loop through properties to check if the media item contains images/file that should be deleted - foreach (var property in ((Member)entity).Properties) - { - if (property.PropertyType.PropertyEditorAlias == uploadFieldAlias && - string.IsNullOrEmpty(property.Value.ToString()) == false - && fs.FileExists(fs.GetRelativePath(property.Value.ToString()))) - { - var relativeFilePath = fs.GetRelativePath(property.Value.ToString()); - var parentDirectory = System.IO.Path.GetDirectoryName(relativeFilePath); - - // don't want to delete the media folder if not using directories. - if (UmbracoConfig.For.UmbracoSettings().Content.UploadAllowDirectories && parentDirectory != fs.GetRelativePath("/")) - { - //issue U4-771: if there is a parent directory the recursive parameter should be true - fs.DeleteDirectory(parentDirectory, String.IsNullOrEmpty(parentDirectory) == false); - } - else - { - fs.DeleteFile(relativeFilePath, true); - } - } - } - - base.PersistDeletedItem(entity); - } - #endregion #region Overrides of VersionableRepositoryBase @@ -480,7 +451,7 @@ namespace Umbraco.Core.Persistence.Repositories var xmlItems = (from descendant in descendants let xml = serializer(descendant) - select new ContentXmlDto { NodeId = descendant.Id, Xml = xml.ToString(SaveOptions.None) }).ToArray(); + select new ContentXmlDto { NodeId = descendant.Id, Xml = xml.ToDataString() }).ToArray(); //bulk insert it into the database Database.BulkInsertRecords(xmlItems, tr); @@ -791,5 +762,6 @@ namespace Umbraco.Core.Persistence.Repositories _contentXmlRepository.Dispose(); _contentPreviewRepository.Dispose(); } + } } diff --git a/src/Umbraco.Core/Persistence/Repositories/MemberTypeRepository.cs b/src/Umbraco.Core/Persistence/Repositories/MemberTypeRepository.cs index d9c8e815be..4d2fbe30de 100644 --- a/src/Umbraco.Core/Persistence/Repositories/MemberTypeRepository.cs +++ b/src/Umbraco.Core/Persistence/Repositories/MemberTypeRepository.cs @@ -268,6 +268,42 @@ namespace Umbraco.Core.Persistence.Repositories propertyTypeAlias); } + protected override IMemberType PerformGet(Guid id) + { + var sql = GetBaseQuery(false); + sql.Where("umbracoNode.uniqueID = @Id", new { Id = id }); + sql.OrderByDescending(x => x.NodeId); + + var dtos = + Database.Fetch( + new PropertyTypePropertyGroupRelator().Map, sql); + + if (dtos == null || dtos.Any() == false) + return null; + + var factory = new MemberTypeReadOnlyFactory(); + var member = factory.BuildEntity(dtos.First()); + + return member; + } + + protected override IEnumerable PerformGetAll(params Guid[] ids) + { + var sql = GetBaseQuery(false); + if (ids.Any()) + { + var statement = string.Join(" OR ", ids.Select(x => string.Format("umbracoNode.uniqueID='{0}'", x))); + sql.Where(statement); + } + sql.OrderByDescending(x => x.NodeId, SqlSyntax); + + var dtos = + Database.Fetch( + new PropertyTypePropertyGroupRelator().Map, sql); + + return BuildFromDtos(dtos); + } + /// /// Ensure that all the built-in membership provider properties have their correct data type /// and property editors assigned. This occurs prior to saving so that the correct values are persisted. diff --git a/src/Umbraco.Core/Persistence/Repositories/RecycleBinRepository.cs b/src/Umbraco.Core/Persistence/Repositories/RecycleBinRepository.cs index 0599afce82..977c2a54cd 100644 --- a/src/Umbraco.Core/Persistence/Repositories/RecycleBinRepository.cs +++ b/src/Umbraco.Core/Persistence/Repositories/RecycleBinRepository.cs @@ -3,6 +3,7 @@ using System.Collections.Generic; using System.Linq; using System.Threading.Tasks; using Umbraco.Core.Configuration; +using Umbraco.Core.Configuration.UmbracoSettings; using Umbraco.Core.IO; using Umbraco.Core.Logging; using Umbraco.Core.Models.EntityBase; @@ -17,8 +18,8 @@ namespace Umbraco.Core.Persistence.Repositories internal abstract class RecycleBinRepository : VersionableRepositoryBase, IRecycleBinRepository where TEntity : class, IUmbracoEntity { - protected RecycleBinRepository(IDatabaseUnitOfWork work, CacheHelper cache, ILogger logger, ISqlSyntaxProvider sqlSyntax) - : base(work, cache, logger, sqlSyntax) + protected RecycleBinRepository(IDatabaseUnitOfWork work, CacheHelper cache, ILogger logger, ISqlSyntaxProvider sqlSyntax, IContentSection contentSection) + : base(work, cache, logger, sqlSyntax, contentSection) { } @@ -81,51 +82,6 @@ namespace Umbraco.Core.Persistence.Repositories } } - /// - /// Deletes all files passed in. - /// - /// - /// - public virtual bool DeleteFiles(IEnumerable files) - { - //ensure duplicates are removed - files = files.Distinct(); - - var allsuccess = true; - - var fs = FileSystemProviderManager.Current.GetFileSystemProvider(); - Parallel.ForEach(files, file => - { - try - { - if (file.IsNullOrWhiteSpace()) return; - - var relativeFilePath = fs.GetRelativePath(file); - if (fs.FileExists(relativeFilePath) == false) return; - - var parentDirectory = System.IO.Path.GetDirectoryName(relativeFilePath); - - // don't want to delete the media folder if not using directories. - if (UmbracoConfig.For.UmbracoSettings().Content.UploadAllowDirectories && parentDirectory != fs.GetRelativePath("/")) - { - //issue U4-771: if there is a parent directory the recursive parameter should be true - fs.DeleteDirectory(parentDirectory, String.IsNullOrEmpty(parentDirectory) == false); - } - else - { - fs.DeleteFile(file, true); - } - } - catch (Exception e) - { - Logger.Error>("An error occurred while deleting file attached to nodes: " + file, e); - allsuccess = false; - } - }); - - return allsuccess; - } - private string FormatDeleteStatement(string tableName, string keyName) { //This query works with sql ce and sql server: diff --git a/src/Umbraco.Core/Persistence/Repositories/UserRepository.cs b/src/Umbraco.Core/Persistence/Repositories/UserRepository.cs index 86eb2964fc..2bbac2a280 100644 --- a/src/Umbraco.Core/Persistence/Repositories/UserRepository.cs +++ b/src/Umbraco.Core/Persistence/Repositories/UserRepository.cs @@ -120,7 +120,6 @@ namespace Umbraco.Core.Persistence.Repositories "DELETE FROM cmsTask WHERE parentUserId = @Id", "DELETE FROM umbracoUser2NodePermission WHERE userId = @Id", "DELETE FROM umbracoUser2NodeNotify WHERE userId = @Id", - "DELETE FROM umbracoUserLogins WHERE userID = @Id", "DELETE FROM umbracoUser2app WHERE " + SqlSyntax.GetQuotedColumnName("user") + "=@Id", "DELETE FROM umbracoUser WHERE id = @Id", "DELETE FROM umbracoExternalLogin WHERE id = @Id" diff --git a/src/Umbraco.Core/Persistence/Repositories/VersionableRepositoryBase.cs b/src/Umbraco.Core/Persistence/Repositories/VersionableRepositoryBase.cs index 27fe5ef4ad..207cb1d04e 100644 --- a/src/Umbraco.Core/Persistence/Repositories/VersionableRepositoryBase.cs +++ b/src/Umbraco.Core/Persistence/Repositories/VersionableRepositoryBase.cs @@ -3,6 +3,9 @@ using System.Collections.Generic; using System.Diagnostics; using System.Linq; using System.Text; +using System.Threading.Tasks; +using Umbraco.Core.Configuration; +using Umbraco.Core.Configuration.UmbracoSettings; using Umbraco.Core.Logging; using Umbraco.Core.Models; using Umbraco.Core.Models.Editors; @@ -17,16 +20,19 @@ using Umbraco.Core.Persistence.UnitOfWork; using Umbraco.Core.PropertyEditors; using Umbraco.Core.Services; using Umbraco.Core.Dynamics; +using Umbraco.Core.IO; namespace Umbraco.Core.Persistence.Repositories { internal abstract class VersionableRepositoryBase : PetaPocoRepositoryBase where TEntity : class, IAggregateRoot { + private readonly IContentSection _contentSection; - protected VersionableRepositoryBase(IDatabaseUnitOfWork work, CacheHelper cache, ILogger logger, ISqlSyntaxProvider sqlSyntax) + protected VersionableRepositoryBase(IDatabaseUnitOfWork work, CacheHelper cache, ILogger logger, ISqlSyntaxProvider sqlSyntax, IContentSection contentSection) : base(work, cache, logger, sqlSyntax) { + _contentSection = contentSection; } #region IRepositoryVersionable Implementation @@ -395,7 +401,7 @@ ON cmsPropertyType.dataTypeId = cmsDataTypePreValues.datatypeNodeId", docSql.Arg // below if any property requires tag support var allPreValues = new Lazy>(() => { - var preValsSql = new Sql(@"SELECT a.id as preValId, a.value, a.sortorder, a.alias, a.datatypeNodeId + var preValsSql = new Sql(@"SELECT a.id, a.value, a.sortorder, a.alias, a.datatypeNodeId FROM cmsDataTypePreValues a WHERE EXISTS( SELECT DISTINCT b.id as preValIdInner @@ -535,5 +541,50 @@ WHERE EXISTS( return orderBy; } } + + /// + /// Deletes all media files passed in. + /// + /// + /// + public virtual bool DeleteMediaFiles(IEnumerable files) + { + //ensure duplicates are removed + files = files.Distinct(); + + var allsuccess = true; + + var fs = FileSystemProviderManager.Current.GetFileSystemProvider(); + Parallel.ForEach(files, file => + { + try + { + if (file.IsNullOrWhiteSpace()) return; + + var relativeFilePath = fs.GetRelativePath(file); + if (fs.FileExists(relativeFilePath) == false) return; + + var parentDirectory = System.IO.Path.GetDirectoryName(relativeFilePath); + + // don't want to delete the media folder if not using directories. + if (_contentSection.UploadAllowDirectories && parentDirectory != fs.GetRelativePath("/")) + { + //issue U4-771: if there is a parent directory the recursive parameter should be true + fs.DeleteDirectory(parentDirectory, String.IsNullOrEmpty(parentDirectory) == false); + } + else + { + fs.DeleteFile(file, true); + } + } + catch (Exception e) + { + Logger.Error>("An error occurred while deleting file attached to nodes: " + file, e); + allsuccess = false; + } + }); + + return allsuccess; + } } } \ No newline at end of file diff --git a/src/Umbraco.Core/Persistence/RepositoryFactory.cs b/src/Umbraco.Core/Persistence/RepositoryFactory.cs index 787a06f005..19556b1f31 100644 --- a/src/Umbraco.Core/Persistence/RepositoryFactory.cs +++ b/src/Umbraco.Core/Persistence/RepositoryFactory.cs @@ -108,7 +108,8 @@ namespace Umbraco.Core.Persistence _sqlSyntax, CreateContentTypeRepository(uow), CreateTemplateRepository(uow), - CreateTagRepository(uow)) + CreateTagRepository(uow), + _settings.Content) { EnsureUniqueNaming = _settings.Content.EnsureUniqueNaming }; @@ -158,7 +159,8 @@ namespace Umbraco.Core.Persistence _cacheHelper, _logger, _sqlSyntax, CreateMediaTypeRepository(uow), - CreateTagRepository(uow)) { EnsureUniqueNaming = _settings.Content.EnsureUniqueNaming }; + CreateTagRepository(uow), + _settings.Content); } public virtual IMediaTypeRepository CreateMediaTypeRepository(IDatabaseUnitOfWork uow) @@ -266,7 +268,8 @@ namespace Umbraco.Core.Persistence _logger, _sqlSyntax, CreateMemberTypeRepository(uow), CreateMemberGroupRepository(uow), - CreateTagRepository(uow)); + CreateTagRepository(uow), + _settings.Content); } public virtual IMemberTypeRepository CreateMemberTypeRepository(IDatabaseUnitOfWork uow) diff --git a/src/Umbraco.Core/PropertyEditors/PreValueEditor.cs b/src/Umbraco.Core/PropertyEditors/PreValueEditor.cs index 89e17438f3..d773eed2e9 100644 --- a/src/Umbraco.Core/PropertyEditors/PreValueEditor.cs +++ b/src/Umbraco.Core/PropertyEditors/PreValueEditor.cs @@ -3,6 +3,7 @@ using System.Collections.Generic; using System.Linq; using System.Reflection; using Newtonsoft.Json; +using Umbraco.Core.IO; using Umbraco.Core.Logging; using Umbraco.Core.Models; @@ -84,7 +85,7 @@ namespace Umbraco.Core.PropertyEditors Name = att.Name, Description = att.Description, HideLabel = att.HideLabel, - View = att.View + View = att.View.StartsWith("~/") ? IOHelper.ResolveUrl(att.View) : att.View }; } diff --git a/src/Umbraco.Core/PropertyEditors/TagPropertyDefinition.cs b/src/Umbraco.Core/PropertyEditors/TagPropertyDefinition.cs index 978a7bf2ba..fd314ba9b7 100644 --- a/src/Umbraco.Core/PropertyEditors/TagPropertyDefinition.cs +++ b/src/Umbraco.Core/PropertyEditors/TagPropertyDefinition.cs @@ -31,7 +31,10 @@ namespace Umbraco.Core.PropertyEditors Delimiter = tagsAttribute.Delimiter; ReplaceTags = tagsAttribute.ReplaceTags; TagGroup = tagsAttribute.TagGroup; - StorageType = TagCacheStorageType.Csv; + + var preValues = propertySaving.PreValues.PreValuesAsDictionary; + StorageType = preValues.ContainsKey("storageType") && preValues["storageType"].Value == TagCacheStorageType.Json.ToString() ? + TagCacheStorageType.Json : TagCacheStorageType.Csv; } /// diff --git a/src/Umbraco.Core/Security/BackOfficeSignInManager.cs b/src/Umbraco.Core/Security/BackOfficeSignInManager.cs new file mode 100644 index 0000000000..fc7ecf5330 --- /dev/null +++ b/src/Umbraco.Core/Security/BackOfficeSignInManager.cs @@ -0,0 +1,72 @@ +using System; +using System.Security.Claims; +using System.Threading.Tasks; +using Microsoft.AspNet.Identity; +using Microsoft.AspNet.Identity.Owin; +using Microsoft.Owin; +using Microsoft.Owin.Security; +using Umbraco.Core.Configuration; +using Umbraco.Core.Models.Identity; + +namespace Umbraco.Core.Security +{ + public class BackOfficeSignInManager : SignInManager + { + public BackOfficeSignInManager(BackOfficeUserManager userManager, IAuthenticationManager authenticationManager) + : base(userManager, authenticationManager) + { + AuthenticationType = Constants.Security.BackOfficeAuthenticationType; + } + + public override Task CreateUserIdentityAsync(BackOfficeIdentityUser user) + { + return user.GenerateUserIdentityAsync((BackOfficeUserManager)UserManager); + } + + public static BackOfficeSignInManager Create(IdentityFactoryOptions options, IOwinContext context) + { + return new BackOfficeSignInManager(context.GetUserManager(), context.Authentication); + } + + /// + /// Creates a user identity and then signs the identity using the AuthenticationManager + /// + /// + /// + /// + /// + public override async Task SignInAsync(BackOfficeIdentityUser user, bool isPersistent, bool rememberBrowser) + { + var userIdentity = await CreateUserIdentityAsync(user); + + // Clear any partial cookies from external or two factor partial sign ins + AuthenticationManager.SignOut( + Constants.Security.BackOfficeExternalAuthenticationType, + Constants.Security.BackOfficeTwoFactorAuthenticationType); + + var nowUtc = DateTime.Now.ToUniversalTime(); + + if (rememberBrowser) + { + var rememberBrowserIdentity = AuthenticationManager.CreateTwoFactorRememberBrowserIdentity(ConvertIdToString(user.Id)); + AuthenticationManager.SignIn(new AuthenticationProperties() + { + IsPersistent = isPersistent, + AllowRefresh = true, + IssuedUtc = nowUtc, + ExpiresUtc = nowUtc.AddMinutes(GlobalSettings.TimeOutInMinutes) + }, userIdentity, rememberBrowserIdentity); + } + else + { + AuthenticationManager.SignIn(new AuthenticationProperties() + { + IsPersistent = isPersistent, + AllowRefresh = true, + IssuedUtc = nowUtc, + ExpiresUtc = nowUtc.AddMinutes(GlobalSettings.TimeOutInMinutes) + }, userIdentity); + } + } + } +} \ No newline at end of file diff --git a/src/Umbraco.Core/Security/BackOfficeUserManager.cs b/src/Umbraco.Core/Security/BackOfficeUserManager.cs index def46b7556..f86c06c39c 100644 --- a/src/Umbraco.Core/Security/BackOfficeUserManager.cs +++ b/src/Umbraco.Core/Security/BackOfficeUserManager.cs @@ -1,17 +1,16 @@ using System; using System.Linq; -using System.Security.Claims; using System.Text; -using System.Threading.Tasks; using System.Web.Security; using Microsoft.AspNet.Identity; using Microsoft.AspNet.Identity.Owin; -using Microsoft.Owin; using Umbraco.Core.Models.Identity; using Umbraco.Core.Services; namespace Umbraco.Core.Security { + + /// /// Default back office user manager /// @@ -89,6 +88,7 @@ namespace Umbraco.Core.Security RequireDigit = false, RequireLowercase = false, RequireUppercase = false + //TODO: Do we support the old regex match thing that membership providers used? }; //use a custom hasher based on our membership provider @@ -100,6 +100,13 @@ namespace Umbraco.Core.Security manager.UserTokenProvider = new DataProtectorTokenProvider(dataProtectionProvider.Create("ASP.NET Identity")); } + manager.UserLockoutEnabledByDefault = true; + manager.MaxFailedAccessAttemptsBeforeLockout = membershipProvider.MaxInvalidPasswordAttempts; + //NOTE: This just needs to be in the future, we currently don't support a lockout timespan, it's either they are locked + // or they are not locked, but this determines what is set on the account lockout date which corresponds to whether they are + // locked out or not. + manager.DefaultAccountLockoutTimeSpan = TimeSpan.FromDays(30); + //custom identity factory for creating the identity object for which we auth against in the back office manager.ClaimsIdentityFactory = new BackOfficeClaimsIdentityFactory(); @@ -149,13 +156,9 @@ namespace Umbraco.Core.Security get { return false; } } - //TODO: Support this - public override bool SupportsUserLockout - { - get { return false; } - } - - //TODO: Support this + /// + /// Developers will need to override this to support custom 2 factor auth + /// public override bool SupportsUserTwoFactor { get { return false; } diff --git a/src/Umbraco.Core/Security/BackOfficeUserStore.cs b/src/Umbraco.Core/Security/BackOfficeUserStore.cs index f6d8222c44..e37f9d1a54 100644 --- a/src/Umbraco.Core/Security/BackOfficeUserStore.cs +++ b/src/Umbraco.Core/Security/BackOfficeUserStore.cs @@ -5,6 +5,7 @@ using System.Threading.Tasks; using System.Web.Security; using AutoMapper; using Microsoft.AspNet.Identity; +using Microsoft.Owin; using Umbraco.Core.Models.Identity; using Umbraco.Core.Models.Membership; using Umbraco.Core.Services; @@ -17,15 +18,12 @@ namespace Umbraco.Core.Security IUserEmailStore, IUserLoginStore, IUserRoleStore, - IUserSecurityStampStore - + IUserSecurityStampStore, + IUserLockoutStore, + IUserTwoFactorStore + //TODO: This would require additional columns/tables for now people will need to implement this on their own //IUserPhoneNumberStore, - //IUserTwoFactorStore, - - //TODO: This will require additional columns/tables - //IUserLockoutStore - //TODO: To do this we need to implement IQueryable - we'll have an IQuerable implementation soon with the UmbracoLinqPadDriver implementation //IQueryableUserStore { @@ -75,12 +73,12 @@ namespace Umbraco.Core.Security { DefaultToLiveEditing = false, Email = user.Email, - Language = Configuration.GlobalSettings.DefaultUILanguage, + Language = user.Culture ?? Configuration.GlobalSettings.DefaultUILanguage, Name = user.Name, Username = user.UserName, - StartContentId = -1, - StartMediaId = -1, - IsLockedOut = false, + StartContentId = user.StartContentId == 0 ? -1 : user.StartContentId, + StartMediaId = user.StartMediaId == 0 ? -1 : user.StartMediaId, + IsLockedOut = user.IsLockedOut, IsApproved = true }; @@ -168,7 +166,7 @@ namespace Umbraco.Core.Security /// /// /// - public Task FindByIdAsync(int userId) + public async Task FindByIdAsync(int userId) { ThrowIfDisposed(); var user = _userService.GetUserById(userId); @@ -176,7 +174,7 @@ namespace Umbraco.Core.Security { return null; } - return Task.FromResult(AssignLoginsCallback(Mapper.Map(user))); + return await Task.FromResult(AssignLoginsCallback(Mapper.Map(user))); } /// @@ -184,7 +182,7 @@ namespace Umbraco.Core.Security /// /// /// - public Task FindByNameAsync(string userName) + public async Task FindByNameAsync(string userName) { ThrowIfDisposed(); var user = _userService.GetByUsername(userName); @@ -195,7 +193,7 @@ namespace Umbraco.Core.Security var result = AssignLoginsCallback(Mapper.Map(user)); - return Task.FromResult(result); + return await Task.FromResult(result); } /// @@ -506,6 +504,118 @@ namespace Umbraco.Core.Security return user; } + /// + /// Sets whether two factor authentication is enabled for the user + /// + /// + /// + public virtual Task SetTwoFactorEnabledAsync(BackOfficeIdentityUser user, bool enabled) + { + user.TwoFactorEnabled = false; + return Task.FromResult(0); + } + + /// + /// Returns whether two factor authentication is enabled for the user + /// + /// + /// + public virtual Task GetTwoFactorEnabledAsync(BackOfficeIdentityUser user) + { + return Task.FromResult(false); + } + + #region IUserLockoutStore + + /// + /// Returns the DateTimeOffset that represents the end of a user's lockout, any time in the past should be considered not locked out. + /// + /// + /// + /// + /// Currently we do not suport a timed lock out, when they are locked out, an admin will have to reset the status + /// + public Task GetLockoutEndDateAsync(BackOfficeIdentityUser user) + { + if (user == null) throw new ArgumentNullException("user"); + + return user.LockoutEndDateUtc.HasValue + ? Task.FromResult(DateTimeOffset.MaxValue) + : Task.FromResult(DateTimeOffset.MinValue); + } + + /// + /// Locks a user out until the specified end date (set to a past date, to unlock a user) + /// + /// + /// + public Task SetLockoutEndDateAsync(BackOfficeIdentityUser user, DateTimeOffset lockoutEnd) + { + if (user == null) throw new ArgumentNullException("user"); + user.LockoutEndDateUtc = lockoutEnd.UtcDateTime; + return Task.FromResult(0); + } + + /// + /// Used to record when an attempt to access the user has failed + /// + /// + /// + public Task IncrementAccessFailedCountAsync(BackOfficeIdentityUser user) + { + if (user == null) throw new ArgumentNullException("user"); + user.AccessFailedCount++; + return Task.FromResult(user.AccessFailedCount); + } + + /// + /// Used to reset the access failed count, typically after the account is successfully accessed + /// + /// + /// + public Task ResetAccessFailedCountAsync(BackOfficeIdentityUser user) + { + if (user == null) throw new ArgumentNullException("user"); + user.AccessFailedCount = 0; + return Task.FromResult(0); + } + + /// + /// Returns the current number of failed access attempts. This number usually will be reset whenever the password is + /// verified or the account is locked out. + /// + /// + /// + public Task GetAccessFailedCountAsync(BackOfficeIdentityUser user) + { + if (user == null) throw new ArgumentNullException("user"); + return Task.FromResult(user.AccessFailedCount); + } + + /// + /// Returns true + /// + /// + /// + public Task GetLockoutEnabledAsync(BackOfficeIdentityUser user) + { + if (user == null) throw new ArgumentNullException("user"); + return Task.FromResult(user.LockoutEnabled); + } + + /// + /// Doesn't actually perform any function, users can always be locked out + /// + /// + /// + public Task SetLockoutEnabledAsync(BackOfficeIdentityUser user, bool enabled) + { + if (user == null) throw new ArgumentNullException("user"); + user.LockoutEnabled = enabled; + return Task.FromResult(0); + } + #endregion + private bool UpdateMemberProperties(Models.Membership.IUser user, BackOfficeIdentityUser identityUser) { var anythingChanged = false; @@ -526,10 +636,10 @@ namespace Umbraco.Core.Security anythingChanged = true; user.FailedPasswordAttempts = identityUser.AccessFailedCount; } - if (user.IsLockedOut != identityUser.LockoutEnabled) + if (user.IsLockedOut != identityUser.IsLockedOut) { anythingChanged = true; - user.IsLockedOut = identityUser.LockoutEnabled; + user.IsLockedOut = identityUser.IsLockedOut; } if (user.Username != identityUser.UserName && identityUser.UserName.IsNullOrWhiteSpace() == false) { @@ -562,6 +672,7 @@ namespace Umbraco.Core.Security anythingChanged = true; user.SecurityStamp = identityUser.SecurityStamp; } + if (user.AllowedSections.ContainsAll(identityUser.AllowedSections) == false || identityUser.AllowedSections.ContainsAll(user.AllowedSections) == false) { @@ -579,10 +690,13 @@ namespace Umbraco.Core.Security return anythingChanged; } + private void ThrowIfDisposed() { if (_disposed) throw new ObjectDisposedException(GetType().Name); } + + } } \ No newline at end of file diff --git a/src/Umbraco.Core/Security/MembershipProviderBase.cs b/src/Umbraco.Core/Security/MembershipProviderBase.cs index 794c8fda2d..392c1545d1 100644 --- a/src/Umbraco.Core/Security/MembershipProviderBase.cs +++ b/src/Umbraco.Core/Security/MembershipProviderBase.cs @@ -225,7 +225,7 @@ namespace Umbraco.Core.Security _enablePasswordReset = config.GetValue("enablePasswordReset", false); _requiresQuestionAndAnswer = config.GetValue("requiresQuestionAndAnswer", false); _requiresUniqueEmail = config.GetValue("requiresUniqueEmail", true); - _maxInvalidPasswordAttempts = GetIntValue(config, "maxInvalidPasswordAttempts", 20, false, 0); + _maxInvalidPasswordAttempts = GetIntValue(config, "maxInvalidPasswordAttempts", 5, false, 0); _passwordAttemptWindow = GetIntValue(config, "passwordAttemptWindow", 10, false, 0); _minRequiredPasswordLength = GetIntValue(config, "minRequiredPasswordLength", DefaultMinPasswordLength, true, 0x80); _minRequiredNonAlphanumericCharacters = GetIntValue(config, "minRequiredNonalphanumericCharacters", DefaultMinNonAlphanumericChars, true, 0x80); diff --git a/src/Umbraco.Core/SemVersionExtensions.cs b/src/Umbraco.Core/SemVersionExtensions.cs new file mode 100644 index 0000000000..f45aacdfc2 --- /dev/null +++ b/src/Umbraco.Core/SemVersionExtensions.cs @@ -0,0 +1,12 @@ +using Semver; + +namespace Umbraco.Core +{ + public static class SemVersionExtensions + { + public static string ToSemanticString(this SemVersion semVersion) + { + return semVersion.ToString().Replace("--", "-").Replace("-+", "+"); + } + } +} \ No newline at end of file diff --git a/src/Umbraco.Core/Services/ContentService.cs b/src/Umbraco.Core/Services/ContentService.cs index 57da3bd8b3..b7ad8c4d03 100644 --- a/src/Umbraco.Core/Services/ContentService.cs +++ b/src/Umbraco.Core/Services/ContentService.cs @@ -1111,7 +1111,7 @@ namespace Umbraco.Core.Services Deleted.RaiseEvent(args, this); //remove any flagged media files - repository.DeleteFiles(args.MediaFilesToDelete); + repository.DeleteMediaFiles(args.MediaFilesToDelete); } Audit(AuditType.Delete, "Delete Content performed by user", userId, content.Id); @@ -1310,7 +1310,7 @@ namespace Umbraco.Core.Services EmptiedRecycleBin.RaiseEvent(new RecycleBinEventArgs(nodeObjectType, entities, files, success), this); if (success) - repository.DeleteFiles(files); + repository.DeleteMediaFiles(files); } @@ -1632,7 +1632,7 @@ namespace Umbraco.Core.Services { var xml = _entitySerializer.Serialize(this, _dataTypeService, _userService, content); - var poco = new ContentXmlDto { NodeId = content.Id, Xml = xml.ToString(SaveOptions.None) }; + var poco = new ContentXmlDto { NodeId = content.Id, Xml = xml.ToDataString() }; var exists = uow.Database.FirstOrDefault("WHERE nodeId = @Id", new { Id = content.Id }) != null; diff --git a/src/Umbraco.Core/Services/ContentTypeService.cs b/src/Umbraco.Core/Services/ContentTypeService.cs index 9bff23a99b..194871f252 100644 --- a/src/Umbraco.Core/Services/ContentTypeService.cs +++ b/src/Umbraco.Core/Services/ContentTypeService.cs @@ -185,6 +185,19 @@ namespace Umbraco.Core.Services } } + /// + /// Gets an object by its Key + /// + /// Alias of the to retrieve + /// + public IContentType GetContentType(Guid id) + { + using (var repository = RepositoryFactory.CreateContentTypeRepository(UowProvider.GetUnitOfWork())) + { + return repository.Get(id); + } + } + /// /// Gets a list of all available objects /// @@ -198,6 +211,19 @@ namespace Umbraco.Core.Services } } + /// + /// Gets a list of all available objects + /// + /// Optional list of ids + /// An Enumerable list of objects + public IEnumerable GetAllContentTypes(IEnumerable ids) + { + using (var repository = RepositoryFactory.CreateContentTypeRepository(UowProvider.GetUnitOfWork())) + { + return repository.GetAll(ids.ToArray()); + } + } + /// /// Gets a list of children for a object /// @@ -213,25 +239,22 @@ namespace Umbraco.Core.Services } } - ///// - ///// Returns the content type descendant Ids for the content type specified - ///// - ///// - ///// - //internal IEnumerable GetDescendantContentTypeIds(int contentTypeId) - //{ - // using (var uow = UowProvider.GetUnitOfWork()) - // { - // //method to return the child content type ids for the id specified - // Func getChildIds = - // parentId => - // uow.Database.Fetch("WHERE parentContentTypeId = @Id", new {Id = parentId}) - // .Select(x => x.ChildId).ToArray(); - - // //recursively get all descendant ids - // return getChildIds(contentTypeId).FlattenList(getChildIds); - // } - //} + /// + /// Gets a list of children for a object + /// + /// Id of the Parent + /// An Enumerable list of objects + public IEnumerable GetContentTypeChildren(Guid id) + { + using (var repository = RepositoryFactory.CreateContentTypeRepository(UowProvider.GetUnitOfWork())) + { + var found = GetContentType(id); + if (found == null) return Enumerable.Empty(); + var query = Query.Builder.Where(x => x.ParentId == found.Id); + var contentTypes = repository.GetByQuery(query); + return contentTypes; + } + } /// /// Checks whether an item has any children @@ -248,6 +271,23 @@ namespace Umbraco.Core.Services } } + /// + /// Checks whether an item has any children + /// + /// Id of the + /// True if the content type has any children otherwise False + public bool HasChildren(Guid id) + { + using (var repository = RepositoryFactory.CreateContentTypeRepository(UowProvider.GetUnitOfWork())) + { + var found = GetContentType(id); + if (found == null) return false; + var query = Query.Builder.Where(x => x.ParentId == found.Id); + int count = repository.Count(query); + return count > 0; + } + } + /// /// This is called after an IContentType is saved and is used to update the content xml structures in the database /// if they are required to be updated. @@ -518,6 +558,19 @@ namespace Umbraco.Core.Services } } + /// + /// Gets an object by its Id + /// + /// Id of the to retrieve + /// + public IMediaType GetMediaType(Guid id) + { + using (var repository = RepositoryFactory.CreateMediaTypeRepository(UowProvider.GetUnitOfWork())) + { + return repository.Get(id); + } + } + /// /// Gets a list of all available objects /// @@ -531,6 +584,19 @@ namespace Umbraco.Core.Services } } + /// + /// Gets a list of all available objects + /// + /// Optional list of ids + /// An Enumerable list of objects + public IEnumerable GetAllMediaTypes(IEnumerable ids) + { + using (var repository = RepositoryFactory.CreateMediaTypeRepository(UowProvider.GetUnitOfWork())) + { + return repository.GetAll(ids.ToArray()); + } + } + /// /// Gets a list of children for a object /// @@ -546,6 +612,23 @@ namespace Umbraco.Core.Services } } + /// + /// Gets a list of children for a object + /// + /// Id of the Parent + /// An Enumerable list of objects + public IEnumerable GetMediaTypeChildren(Guid id) + { + using (var repository = RepositoryFactory.CreateMediaTypeRepository(UowProvider.GetUnitOfWork())) + { + var found = GetMediaType(id); + if (found == null) return Enumerable.Empty(); + var query = Query.Builder.Where(x => x.ParentId == found.Id); + var contentTypes = repository.GetByQuery(query); + return contentTypes; + } + } + /// /// Checks whether an item has any children /// @@ -561,6 +644,23 @@ namespace Umbraco.Core.Services } } + /// + /// Checks whether an item has any children + /// + /// Id of the + /// True if the media type has any children otherwise False + public bool MediaTypeHasChildren(Guid id) + { + using (var repository = RepositoryFactory.CreateMediaTypeRepository(UowProvider.GetUnitOfWork())) + { + var found = GetMediaType(id); + if (found == null) return false; + var query = Query.Builder.Where(x => x.ParentId == found.Id); + int count = repository.Count(query); + return count > 0; + } + } + /// /// Saves a single object /// diff --git a/src/Umbraco.Core/Services/IContentTypeService.cs b/src/Umbraco.Core/Services/IContentTypeService.cs index a538840e36..1eb0b8695c 100644 --- a/src/Umbraco.Core/Services/IContentTypeService.cs +++ b/src/Umbraco.Core/Services/IContentTypeService.cs @@ -68,6 +68,13 @@ namespace Umbraco.Core.Services /// IContentType GetContentType(string alias); + /// + /// Gets an object by its Key + /// + /// Alias of the to retrieve + /// + IContentType GetContentType(Guid id); + /// /// Gets a list of all available objects /// @@ -75,6 +82,13 @@ namespace Umbraco.Core.Services /// An Enumerable list of objects IEnumerable GetAllContentTypes(params int[] ids); + /// + /// Gets a list of all available objects + /// + /// Optional list of ids + /// An Enumerable list of objects + IEnumerable GetAllContentTypes(IEnumerable ids); + /// /// Gets a list of children for a object /// @@ -82,6 +96,13 @@ namespace Umbraco.Core.Services /// An Enumerable list of objects IEnumerable GetContentTypeChildren(int id); + /// + /// Gets a list of children for a object + /// + /// Id of the Parent + /// An Enumerable list of objects + IEnumerable GetContentTypeChildren(Guid id); + /// /// Saves a single object /// @@ -126,6 +147,13 @@ namespace Umbraco.Core.Services /// IMediaType GetMediaType(string alias); + /// + /// Gets an object by its Id + /// + /// Id of the to retrieve + /// + IMediaType GetMediaType(Guid id); + /// /// Gets a list of all available objects /// @@ -133,6 +161,13 @@ namespace Umbraco.Core.Services /// An Enumerable list of objects IEnumerable GetAllMediaTypes(params int[] ids); + /// + /// Gets a list of all available objects + /// + /// Optional list of ids + /// An Enumerable list of objects + IEnumerable GetAllMediaTypes(IEnumerable ids); + /// /// Gets a list of children for a object /// @@ -140,6 +175,13 @@ namespace Umbraco.Core.Services /// An Enumerable list of objects IEnumerable GetMediaTypeChildren(int id); + /// + /// Gets a list of children for a object + /// + /// Id of the Parent + /// An Enumerable list of objects + IEnumerable GetMediaTypeChildren(Guid id); + /// /// Saves a single object /// @@ -189,11 +231,25 @@ namespace Umbraco.Core.Services /// True if the content type has any children otherwise False bool HasChildren(int id); + /// + /// Checks whether an item has any children + /// + /// Id of the + /// True if the content type has any children otherwise False + bool HasChildren(Guid id); + /// /// Checks whether an item has any children /// /// Id of the /// True if the media type has any children otherwise False bool MediaTypeHasChildren(int id); + + /// + /// Checks whether an item has any children + /// + /// Id of the + /// True if the media type has any children otherwise False + bool MediaTypeHasChildren(Guid id); } } \ No newline at end of file diff --git a/src/Umbraco.Core/Services/LocalizationService.cs b/src/Umbraco.Core/Services/LocalizationService.cs index bd695b65e5..59b77085af 100644 --- a/src/Umbraco.Core/Services/LocalizationService.cs +++ b/src/Umbraco.Core/Services/LocalizationService.cs @@ -18,7 +18,6 @@ namespace Umbraco.Core.Services /// public class LocalizationService : RepositoryService, ILocalizationService { - private static readonly Guid RootParentId = new Guid(Constants.Conventions.Localization.DictionaryItemRootId); [Obsolete("Use the constructors that specify all dependencies instead")] public LocalizationService() @@ -93,7 +92,7 @@ namespace Umbraco.Core.Services } } - var item = new DictionaryItem(parentId.HasValue ? parentId.Value : RootParentId, key); + var item = new DictionaryItem(parentId, key); if (defaultValue.IsNullOrWhiteSpace() == false) { @@ -188,7 +187,7 @@ namespace Umbraco.Core.Services { using (var repository = RepositoryFactory.CreateDictionaryRepository(UowProvider.GetUnitOfWork())) { - var query = Query.Builder.Where(x => x.ParentId == RootParentId); + var query = Query.Builder.Where(x => x.ParentId == null); var items = repository.GetByQuery(query); return items; diff --git a/src/Umbraco.Core/Services/MediaService.cs b/src/Umbraco.Core/Services/MediaService.cs index 1c7355ef42..299d089319 100644 --- a/src/Umbraco.Core/Services/MediaService.cs +++ b/src/Umbraco.Core/Services/MediaService.cs @@ -825,7 +825,7 @@ namespace Umbraco.Core.Services EmptiedRecycleBin.RaiseEvent(new RecycleBinEventArgs(nodeObjectType, entities, files, success), this); if (success) - repository.DeleteFiles(files); + repository.DeleteMediaFiles(files); } } Audit(AuditType.Delete, "Empty Media Recycle Bin performed by user", 0, -21); @@ -910,7 +910,7 @@ namespace Umbraco.Core.Services Deleted.RaiseEvent(args, this); //remove any flagged media files - repository.DeleteFiles(args.MediaFilesToDelete); + repository.DeleteMediaFiles(args.MediaFilesToDelete); } Audit(AuditType.Delete, "Delete Media performed by user", userId, media.Id); @@ -1160,7 +1160,7 @@ namespace Umbraco.Core.Services //private void CreateAndSaveMediaXml(XElement xml, int id, UmbracoDatabase db) //{ - // var poco = new ContentXmlDto { NodeId = id, Xml = xml.ToString(SaveOptions.None) }; + // var poco = new ContentXmlDto { NodeId = id, Xml = xml.ToDataString() }; // var exists = db.FirstOrDefault("WHERE nodeId = @Id", new { Id = id }) != null; // int result = exists ? db.Update(poco) : Convert.ToInt32(db.Insert(poco)); //} diff --git a/src/Umbraco.Core/Services/MemberService.cs b/src/Umbraco.Core/Services/MemberService.cs index 9b444de296..c6c49da7e9 100644 --- a/src/Umbraco.Core/Services/MemberService.cs +++ b/src/Umbraco.Core/Services/MemberService.cs @@ -80,7 +80,7 @@ namespace Umbraco.Core.Services { using (var repository = RepositoryFactory.CreateMemberTypeRepository(UowProvider.GetUnitOfWork())) { - var types = repository.GetAll().Select(x => x.Alias).ToArray(); + var types = repository.GetAll(new int[]{}).Select(x => x.Alias).ToArray(); if (types.Any() == false) { @@ -132,11 +132,11 @@ namespace Umbraco.Core.Services //go re-fetch the member and update the properties that may have changed var result = GetByUsername(member.Username); - + //should never be null but it could have been deleted by another thread. - if (result == null) + if (result == null) return; - + member.RawPasswordValue = result.RawPasswordValue; member.LastPasswordChangeDate = result.LastPasswordChangeDate; member.UpdateDate = member.UpdateDate; @@ -975,9 +975,13 @@ namespace Umbraco.Core.Services { repository.Delete(member); uow.Commit(); - } - Deleted.RaiseEvent(new DeleteEventArgs(member, false), this); + var args = new DeleteEventArgs(member, false); + Deleted.RaiseEvent(args, this); + + //remove any flagged media files + repository.DeleteMediaFiles(args.MediaFilesToDelete); + } } /// @@ -1169,7 +1173,7 @@ namespace Umbraco.Core.Services repository.DissociateRoles(usernames, roleNames); } } - + public void AssignRole(int memberId, string roleName) { AssignRoles(new[] { memberId }, new[] { roleName }); @@ -1198,7 +1202,7 @@ namespace Umbraco.Core.Services } } - + #endregion @@ -1233,7 +1237,7 @@ namespace Umbraco.Core.Services uow.Commit(); } } - + #region Event Handlers /// @@ -1250,7 +1254,7 @@ namespace Umbraco.Core.Services /// Occurs before Save /// public static event TypedEventHandler> Saving; - + /// /// Occurs after Create /// diff --git a/src/Umbraco.Core/Services/UserService.cs b/src/Umbraco.Core/Services/UserService.cs index 961175f455..dd4866c8c3 100644 --- a/src/Umbraco.Core/Services/UserService.cs +++ b/src/Umbraco.Core/Services/UserService.cs @@ -243,10 +243,6 @@ namespace Umbraco.Core.Services membershipUser.Username = DateTime.Now.ToString("yyyyMMdd") + "_" + membershipUser.Username; } Save(membershipUser); - - //clear out the user logins! - var uow = UowProvider.GetUnitOfWork(); - uow.Database.Execute("delete from umbracoUserLogins where userID = @id", new {id = membershipUser.Id}); } /// diff --git a/src/Umbraco.Core/Sync/BatchedDatabaseServerMessenger.cs b/src/Umbraco.Core/Sync/BatchedDatabaseServerMessenger.cs index 9eaf557170..b16caa8779 100644 --- a/src/Umbraco.Core/Sync/BatchedDatabaseServerMessenger.cs +++ b/src/Umbraco.Core/Sync/BatchedDatabaseServerMessenger.cs @@ -40,7 +40,7 @@ namespace Umbraco.Core.Sync { UtcStamp = DateTime.UtcNow, Instructions = JsonConvert.SerializeObject(instructions, Formatting.None), - OriginIdentity = GetLocalIdentity() + OriginIdentity = LocalIdentity }; ApplicationContext.DatabaseContext.Database.Insert(dto); diff --git a/src/Umbraco.Core/Sync/DatabaseServerMessenger.cs b/src/Umbraco.Core/Sync/DatabaseServerMessenger.cs index e6ce565280..e9be30ab09 100644 --- a/src/Umbraco.Core/Sync/DatabaseServerMessenger.cs +++ b/src/Umbraco.Core/Sync/DatabaseServerMessenger.cs @@ -1,5 +1,6 @@ using System; using System.Collections.Generic; +using System.Diagnostics; using System.Globalization; using System.IO; using System.Linq; @@ -78,7 +79,7 @@ namespace Umbraco.Core.Sync { UtcStamp = DateTime.UtcNow, Instructions = JsonConvert.SerializeObject(instructions, Formatting.None), - OriginIdentity = GetLocalIdentity() + OriginIdentity = LocalIdentity }; ApplicationContext.DatabaseContext.Database.Insert(dto); @@ -186,7 +187,7 @@ namespace Umbraco.Core.Sync // only process instructions coming from a remote server, and ignore instructions coming from // the local server as they've already been processed. We should NOT assume that the sequence of // instructions in the database makes any sense whatsoever, because it's all async. - var localIdentity = GetLocalIdentity(); + var localIdentity = LocalIdentity; var lastId = 0; foreach (var dto in dtos) @@ -269,17 +270,20 @@ namespace Umbraco.Core.Sync } /// - /// Gets the local server unique identity. + /// Gets the unique local identity of the executing AppDomain. /// - /// The unique identity of the local server. - protected string GetLocalIdentity() - { - return JsonConvert.SerializeObject(new - { - machineName = NetworkHelper.MachineName, - appDomainAppId = HttpRuntime.AppDomainAppId - }); - } + /// + /// It is not only about the "server" (machine name and appDomainappId), but also about + /// an AppDomain, within a Process, on that server - because two AppDomains running at the same + /// time on the same server (eg during a restart) are, practically, a LB setup. + /// Practically, all we really need is the guid, the other infos are here for information + /// and debugging purposes. + /// + protected readonly static string LocalIdentity = NetworkHelper.MachineName // eg DOMAIN\SERVER + + "/" + HttpRuntime.AppDomainAppId // eg /LM/S3SVC/11/ROOT + + " [P" + Process.GetCurrentProcess().Id // eg 1234 + + "/D" + AppDomain.CurrentDomain.Id // eg 22 + + "] " + Guid.NewGuid().ToString("N").ToUpper(); // make it truly unique /// /// Gets the sync file path for the local server. diff --git a/src/Umbraco.Core/Sync/DatabaseServerMessengerOptions.cs b/src/Umbraco.Core/Sync/DatabaseServerMessengerOptions.cs index 66b845f4ec..f1bebce10b 100644 --- a/src/Umbraco.Core/Sync/DatabaseServerMessengerOptions.cs +++ b/src/Umbraco.Core/Sync/DatabaseServerMessengerOptions.cs @@ -13,7 +13,7 @@ namespace Umbraco.Core.Sync /// public DatabaseServerMessengerOptions() { - DaysToRetainInstructions = 100; // 100 days + DaysToRetainInstructions = 2; // 2 days ThrottleSeconds = 5; // 5 seconds } diff --git a/src/Umbraco.Core/Sync/ServerEnvironmentHelper.cs b/src/Umbraco.Core/Sync/ServerEnvironmentHelper.cs index 1d5ee7855a..e79a0f9209 100644 --- a/src/Umbraco.Core/Sync/ServerEnvironmentHelper.cs +++ b/src/Umbraco.Core/Sync/ServerEnvironmentHelper.cs @@ -1,10 +1,9 @@ -using System; using System.Linq; using System.Web; -using System.Xml; using Umbraco.Core.Configuration; using Umbraco.Core.Configuration.UmbracoSettings; using Umbraco.Core.IO; +using Umbraco.Core.Logging; namespace Umbraco.Core.Sync { @@ -13,58 +12,73 @@ namespace Umbraco.Core.Sync /// internal static class ServerEnvironmentHelper { - /// - /// Returns the current umbraco base url for the current server depending on it's environment - /// status. This will attempt to determine the internal umbraco base url that can be used by the current - /// server to send a request to itself if it is in a load balanced environment. - /// - /// The full base url including schema (i.e. http://myserver:80/umbraco ) - or null if the url - /// cannot be determined at the moment (usually because the first request has not properly completed yet). - public static string GetCurrentServerUmbracoBaseUrl(ApplicationContext appContext, IUmbracoSettingsSection settings) + public static void TrySetApplicationUrlFromSettings(ApplicationContext appContext, ILogger logger, IUmbracoSettingsSection settings) { + // try umbracoSettings:settings/web.routing/@umbracoApplicationUrl + // which is assumed to: + // - end with SystemDirectories.Umbraco + // - contain a scheme + // - end or not with a slash, it will be taken care of + // eg "http://www.mysite.com/umbraco" + var url = settings.WebRouting.UmbracoApplicationUrl; + if (url.IsNullOrWhiteSpace() == false) + { + appContext.UmbracoApplicationUrl = url.TrimEnd('/'); + logger.Info("ApplicationUrl: " + appContext.UmbracoApplicationUrl + " (using web.routing/@umbracoApplicationUrl)"); + return; + } + + // try umbracoSettings:settings/scheduledTasks/@baseUrl + // which is assumed to: + // - end with SystemDirectories.Umbraco + // - NOT contain any scheme (because, legacy) + // - end or not with a slash, it will be taken care of + // eg "mysite.com/umbraco" + url = settings.ScheduledTasks.BaseUrl; + if (url.IsNullOrWhiteSpace() == false) + { + var ssl = GlobalSettings.UseSSL ? "s" : ""; + url = "http" + ssl + "://" + url; + appContext.UmbracoApplicationUrl = url.TrimEnd('/'); + logger.Info("ApplicationUrl: " + appContext.UmbracoApplicationUrl + " (using scheduledTasks/@baseUrl)"); + return; + } + + // try servers var status = GetStatus(settings); - if (status == CurrentServerEnvironmentStatus.Single) - { - // single install, return null if no config/original url, else use config/original url as base - // use http or https as appropriate - return GetBaseUrl(appContext, settings); - } + return; + // no server, nothing we can do var servers = settings.DistributedCall.Servers.ToArray(); + if (servers.Length == 0) + return; - if (servers.Any() == false) - { - // cannot be determined, return null if no config/original url, else use config/original url as base - // use http or https as appropriate - return GetBaseUrl(appContext, settings); - } - + // we have servers, look for this server foreach (var server in servers) { var appId = server.AppId; var serverName = server.ServerName; + // skip if no data if (appId.IsNullOrWhiteSpace() && serverName.IsNullOrWhiteSpace()) - { continue; - } + // if this server, build and return the url if ((appId.IsNullOrWhiteSpace() == false && appId.Trim().InvariantEquals(HttpRuntime.AppDomainAppId)) || (serverName.IsNullOrWhiteSpace() == false && serverName.Trim().InvariantEquals(NetworkHelper.MachineName))) { - //match by appId or computer name! return the url configured - return string.Format("{0}://{1}:{2}/{3}", + // match by appId or computer name, return the url configured + url = string.Format("{0}://{1}:{2}/{3}", server.ForceProtocol.IsNullOrWhiteSpace() ? "http" : server.ForceProtocol, server.ServerAddress, server.ForcePortnumber.IsNullOrWhiteSpace() ? "80" : server.ForcePortnumber, IOHelper.ResolveUrl(SystemDirectories.Umbraco).TrimStart('/')); + + appContext.UmbracoApplicationUrl = url.TrimEnd('/'); + logger.Info("ApplicationUrl: " + appContext.UmbracoApplicationUrl + " (using distributedCall/servers)"); } } - - // cannot be determined, return null if no config/original url, else use config/original url as base - // use http or https as appropriate - return GetBaseUrl(appContext, settings); } /// @@ -113,21 +127,5 @@ namespace Umbraco.Core.Sync return CurrentServerEnvironmentStatus.Slave; } - - private static string GetBaseUrl(ApplicationContext appContext, IUmbracoSettingsSection settings) - { - return ( - // is config empty? - settings.ScheduledTasks.BaseUrl.IsNullOrWhiteSpace() - // is the orig req empty? - ? appContext.OriginalRequestUrl.IsNullOrWhiteSpace() - // we've got nothing - ? null - //the orig req url is not null, use that - : string.Format("http{0}://{1}", GlobalSettings.UseSSL ? "s" : "", appContext.OriginalRequestUrl) - // the config has been specified, use that - : string.Format("http{0}://{1}", GlobalSettings.UseSSL ? "s" : "", settings.ScheduledTasks.BaseUrl)) - .EnsureEndsWith('/'); - } } } \ No newline at end of file diff --git a/src/Umbraco.Core/Umbraco.Core.csproj b/src/Umbraco.Core/Umbraco.Core.csproj index 82b4636dd4..24bbd61c8b 100644 --- a/src/Umbraco.Core/Umbraco.Core.csproj +++ b/src/Umbraco.Core/Umbraco.Core.csproj @@ -58,11 +58,11 @@ False - ..\packages\Microsoft.AspNet.Identity.Core.2.2.0\lib\net45\Microsoft.AspNet.Identity.Core.dll + ..\packages\Microsoft.AspNet.Identity.Core.2.2.1\lib\net45\Microsoft.AspNet.Identity.Core.dll False - ..\packages\Microsoft.AspNet.Identity.Owin.2.2.0\lib\net45\Microsoft.AspNet.Identity.Owin.dll + ..\packages\Microsoft.AspNet.Identity.Owin.2.2.1\lib\net45\Microsoft.AspNet.Identity.Owin.dll False @@ -332,8 +332,12 @@ + + + + @@ -378,6 +382,7 @@ + @@ -386,6 +391,7 @@ + @@ -416,6 +422,7 @@ + @@ -425,14 +432,16 @@ + + - + @@ -1102,7 +1111,6 @@ - diff --git a/src/Umbraco.Core/UmbracoApplicationBase.cs b/src/Umbraco.Core/UmbracoApplicationBase.cs index a53dd09ca5..33c3d58689 100644 --- a/src/Umbraco.Core/UmbracoApplicationBase.cs +++ b/src/Umbraco.Core/UmbracoApplicationBase.cs @@ -2,6 +2,7 @@ using System.Linq; using System.Web; using System.Web.Hosting; +using log4net; using Umbraco.Core.Logging; using Umbraco.Core.ObjectResolution; @@ -31,6 +32,18 @@ namespace Umbraco.Core /// internal void StartApplication(object sender, EventArgs e) { + //take care of unhandled exceptions - there is nothing we can do to + // prevent the entire w3wp process to go down but at least we can try + // and log the exception + AppDomain.CurrentDomain.UnhandledException += (_, args) => + { + var exception = (Exception) args.ExceptionObject; + var isTerminating = args.IsTerminating; // always true? + + var msg = "Unhandled exception in AppDomain"; + if (isTerminating) msg += " (terminating)"; + Logger.Error(typeof(UmbracoApplicationBase), msg, exception); + }; //boot up the application GetBootManager() @@ -139,6 +152,9 @@ namespace Umbraco.Core Logger.Info("Application shutdown. Reason: " + HostingEnvironment.ShutdownReason); } OnApplicationEnd(sender, e); + + //Last thing to do is shutdown log4net + LogManager.Shutdown(); } protected abstract IBootManager GetBootManager(); @@ -147,6 +163,7 @@ namespace Umbraco.Core { get { + // LoggerResolver can resolve before resolution is frozen if (LoggerResolver.HasCurrent && LoggerResolver.Current.HasValue) { return LoggerResolver.Current.Logger; diff --git a/src/Umbraco.Core/XmlExtensions.cs b/src/Umbraco.Core/XmlExtensions.cs index 200b845002..b81785eb7e 100644 --- a/src/Umbraco.Core/XmlExtensions.cs +++ b/src/Umbraco.Core/XmlExtensions.cs @@ -317,5 +317,25 @@ namespace Umbraco.Core } } + // this exists because + // new XElement("root", "a\nb").Value is "a\nb" but + // .ToString(SaveOptions.*) is "a\r\nb" and cannot figure out how to get rid of "\r" + // and when saving data we want nothing to change + // this method will produce a string that respects the \r and \n in the data value + public static string ToDataString(this XElement xml) + { + var settings = new XmlWriterSettings + { + OmitXmlDeclaration = true, + NewLineHandling = NewLineHandling.None, + Indent = false + }; + var output = new StringBuilder(); + using (var writer = XmlWriter.Create(output, settings)) + { + xml.WriteTo(writer); + } + return output.ToString(); + } } } \ No newline at end of file diff --git a/src/Umbraco.Core/packages.config b/src/Umbraco.Core/packages.config index 6ffcf860e6..9edfbb097e 100644 --- a/src/Umbraco.Core/packages.config +++ b/src/Umbraco.Core/packages.config @@ -3,8 +3,8 @@ - - + + diff --git a/src/Umbraco.Tests/ApplicationContextTests.cs b/src/Umbraco.Tests/ApplicationContextTests.cs index 60eecce81d..61dabf6e3b 100644 --- a/src/Umbraco.Tests/ApplicationContextTests.cs +++ b/src/Umbraco.Tests/ApplicationContextTests.cs @@ -20,7 +20,7 @@ namespace Umbraco.Tests [Test] public void Is_Configured() { - ConfigurationManager.AppSettings.Set("umbracoConfigurationStatus", UmbracoVersion.GetSemanticVersion().ToString()); + ConfigurationManager.AppSettings.Set("umbracoConfigurationStatus", UmbracoVersion.GetSemanticVersion().ToSemanticString()); var migrationEntryService = new Mock(); migrationEntryService.Setup(x => x.FindEntry(It.IsAny(), It.IsAny())) @@ -42,7 +42,7 @@ namespace Umbraco.Tests [Test] public void Is_Not_Configured_By_Migration_Not_Found() { - ConfigurationManager.AppSettings.Set("umbracoConfigurationStatus", UmbracoVersion.GetSemanticVersion().ToString()); + ConfigurationManager.AppSettings.Set("umbracoConfigurationStatus", UmbracoVersion.GetSemanticVersion().ToSemanticString()); var migrationEntryService = new Mock(); migrationEntryService.Setup(x => x.FindEntry(It.IsAny(), It.IsAny())) diff --git a/src/Umbraco.Tests/AsynchronousRollingFileAppenderTests.cs b/src/Umbraco.Tests/AsynchronousRollingFileAppenderTests.cs deleted file mode 100644 index 2f1a8d99d3..0000000000 --- a/src/Umbraco.Tests/AsynchronousRollingFileAppenderTests.cs +++ /dev/null @@ -1,173 +0,0 @@ -using System; -using System.Collections.Generic; -using System.IO; -using System.Linq; -using System.Threading; -using NUnit.Framework; -using Umbraco.Core; -using Umbraco.Core.Logging; -using Umbraco.Tests.TestHelpers; -using log4net; -using log4net.Config; -using log4net.Core; -using log4net.Layout; -using log4net.Repository; - -namespace Umbraco.Tests -{ - //Ignore this test, it fails sometimes on the build server - pretty sure it's a threading issue with this test class - [Ignore] - [TestFixture] - public class AsynchronousRollingFileAppenderTests - { - private const string ErrorMessage = "TEST ERROR MESSAGE"; - private string _fileFolderPath = @"c:\LogTesting\"; - private readonly Level _errorLevel = Level.Error; - private AsynchronousRollingFileAppender _appender; - private ILoggerRepository _rep; - private Guid _fileGuid; - - - - private string GetFilePath() - { - return string.Format("{0}{1}.log", _fileFolderPath, _fileGuid); - } - - [SetUp] - public void SetUp() - { - _fileFolderPath = TestHelper.MapPathForTest("~/LogTesting/"); - - _fileGuid = Guid.NewGuid(); - if (File.Exists(GetFilePath())) - { - File.Delete(GetFilePath()); - } - - _appender = new AsynchronousRollingFileAppender(); - _appender.Threshold = _errorLevel; - _appender.File = GetFilePath(); - _appender.Layout = new PatternLayout("%d|%-5level|%logger| %message %exception%n"); - _appender.StaticLogFileName = true; - _appender.AppendToFile = true; - _appender.ActivateOptions(); - - _rep = LogManager.CreateRepository(Guid.NewGuid().ToString()); - BasicConfigurator.Configure(_rep, _appender); - } - - [TearDown] - public void TearDown() - { - _rep.Shutdown(); - if (File.Exists(GetFilePath())) - { - File.Delete(GetFilePath()); - } - } - - [TestFixtureTearDown] - public void FixtureTearDown() - { - foreach (string file in Directory.GetFiles(_fileFolderPath)) - { - try - { - File.Delete(file); - } - catch { } - } - } - - private void ReleaseFileLocks() - { - _rep.Shutdown(); - _appender.Close(); - } - - [Test] - public void CanWriteToFile() - { - // Arrange - ILog log = LogManager.GetLogger(_rep.Name, "CanWriteToDatabase"); - - // Act - log.Error(ErrorMessage); - Thread.Sleep(200); // let background thread finish - - // Assert - ReleaseFileLocks(); - Assert.That(File.Exists(GetFilePath()), Is.True); - IEnumerable readLines = File.ReadLines(GetFilePath()); - Assert.That(readLines.Count(), Is.GreaterThanOrEqualTo(1)); - } - - [Test] - public void ReturnsQuicklyAfterLogging100Messages() - { - // Arrange - ILog log = LogManager.GetLogger(_rep.Name, "ReturnsQuicklyAfterLogging100Messages"); - - // Act - DateTime startTime = DateTime.UtcNow; - 100.Times(i => log.Error(ErrorMessage)); - DateTime endTime = DateTime.UtcNow; - - // Give background thread time to finish - Thread.Sleep(500); - - // Assert - ReleaseFileLocks(); - Assert.That(endTime - startTime, Is.LessThan(TimeSpan.FromMilliseconds(100))); - Assert.That(File.Exists(GetFilePath()), Is.True); - IEnumerable readLines = File.ReadLines(GetFilePath()); - Assert.That(readLines.Count(), Is.GreaterThanOrEqualTo(100)); - } - - [Test] - public void CanLogAtleast1000MessagesASecond() - { - // Arrange - ILog log = LogManager.GetLogger(_rep.Name, "CanLogAtLeast1000MessagesASecond"); - - int logCount = 0; - bool logging = true; - bool logsCounted = false; - - var logTimer = new Timer(s => - { - logging = false; - - if (File.Exists(GetFilePath())) - { - ReleaseFileLocks(); - IEnumerable readLines = File.ReadLines(GetFilePath()); - logCount = readLines.Count(); - } - logsCounted = true; - }, null, TimeSpan.FromSeconds(3), TimeSpan.FromMilliseconds(-1)); - - // Act - DateTime startTime = DateTime.UtcNow; - while (logging) - { - log.Error(ErrorMessage); - } - TimeSpan testDuration = DateTime.UtcNow - startTime; - - while (!logsCounted) - { - Thread.Sleep(1); - } - - logTimer.Dispose(); - - // Assert - var logsPerSecond = logCount / testDuration.TotalSeconds; - - Console.WriteLine("{0} messages logged in {1}s => {2}/s", logCount, testDuration.TotalSeconds, logsPerSecond); - Assert.That(logsPerSecond, Is.GreaterThan(1000), "Must log at least 1000 messages per second"); - } - } -} \ No newline at end of file diff --git a/src/Umbraco.Tests/Logging/AsyncRollingFileAppenderTest.cs b/src/Umbraco.Tests/Logging/AsyncRollingFileAppenderTest.cs new file mode 100644 index 0000000000..37323a67d5 --- /dev/null +++ b/src/Umbraco.Tests/Logging/AsyncRollingFileAppenderTest.cs @@ -0,0 +1,166 @@ +using System; +using System.Collections.Generic; +using System.IO; +using System.Linq; +using System.Threading; +using log4net; +using log4net.Config; +using log4net.Core; +using log4net.Layout; +using log4net.Repository; +using NUnit.Framework; +using Umbraco.Core; +using Umbraco.Core.Logging; + +namespace Umbraco.Tests.Logging +{ + [TestFixture] + public class AsyncRollingFileAppenderTest + { + private const string ErrorMessage = "TEST ERROR MESSAGE"; + private const string FileFolderPath = @"c:\LogTesting\"; + private readonly Level ErrorLevel = Level.Error; + private AsynchronousRollingFileAppender appender; + private ILoggerRepository rep; + private Guid fileGuid; + + private string GetFilePath() + { + return string.Format("{0}{1}.log", FileFolderPath, fileGuid); + } + + [SetUp] + public void SetUp() + { + fileGuid = Guid.NewGuid(); + if (File.Exists(GetFilePath())) + { + File.Delete(GetFilePath()); + } + + appender = new AsynchronousRollingFileAppender(); + appender.Threshold = ErrorLevel; + appender.File = GetFilePath(); + appender.Layout = new PatternLayout("%d|%-5level|%logger| %message %exception%n"); + appender.StaticLogFileName = true; + appender.AppendToFile = true; + appender.ActivateOptions(); + + rep = LogManager.CreateRepository(Guid.NewGuid().ToString()); + BasicConfigurator.Configure(rep, appender); + } + + [TearDown] + public void TearDown() + { + rep.Shutdown(); + if (File.Exists(GetFilePath())) + { + File.Delete(GetFilePath()); + } + } + + [TestFixtureTearDown] + public void FixtureTearDown() + { + foreach (string file in Directory.GetFiles(FileFolderPath)) + { + try + { + File.Delete(file); + } + catch { } + } + } + + private void ReleaseFileLocks() + { + rep.Shutdown(); + appender.Close(); + } + + [Test] + public void CanWriteToFile() + { + // Arrange + ILog log = LogManager.GetLogger(rep.Name, "CanWriteToDatabase"); + + // Act + log.Error(ErrorMessage); + Thread.Sleep(200); // let background thread finish + + // Assert + ReleaseFileLocks(); + Assert.That(File.Exists(GetFilePath()), Is.True); + IEnumerable readLines = File.ReadLines(GetFilePath()); + Assert.That(readLines.Count(), Is.GreaterThanOrEqualTo(1)); + } + + [Test] + public void ReturnsQuicklyAfterLogging100Messages() + { + // Arrange + ILog log = LogManager.GetLogger(rep.Name, "ReturnsQuicklyAfterLogging100Messages"); + + // Act + DateTime startTime = DateTime.UtcNow; + 100.Times(i => log.Error(ErrorMessage)); + DateTime endTime = DateTime.UtcNow; + + // Give background thread time to finish + Thread.Sleep(500); + + // Assert + ReleaseFileLocks(); + Assert.That(endTime - startTime, Is.LessThan(TimeSpan.FromMilliseconds(100))); + Assert.That(File.Exists(GetFilePath()), Is.True); + IEnumerable readLines = File.ReadLines(GetFilePath()); + Assert.That(readLines.Count(), Is.GreaterThanOrEqualTo(100)); + } + + [Test] + public void CanLogAtleast1000MessagesASecond() + { + // Arrange + ILog log = LogManager.GetLogger(rep.Name, "CanLogAtLeast1000MessagesASecond"); + + int logCount = 0; + bool logging = true; + bool logsCounted = false; + + var logTimer = new Timer(s => + { + logging = false; + + if (File.Exists(GetFilePath())) + { + ReleaseFileLocks(); + IEnumerable readLines = File.ReadLines(GetFilePath()); + logCount = readLines.Count(); + } + logsCounted = true; + }, null, TimeSpan.FromSeconds(3), TimeSpan.FromMilliseconds(-1)); + + // Act + DateTime startTime = DateTime.UtcNow; + while (logging) + { + log.Error(ErrorMessage); + } + TimeSpan testDuration = DateTime.UtcNow - startTime; + + while (!logsCounted) + { + Thread.Sleep(1); + } + + logTimer.Dispose(); + + // Assert + var logsPerSecond = logCount / testDuration.TotalSeconds; + + Console.WriteLine("{0} messages logged in {1}s => {2}/s", logCount, testDuration.TotalSeconds, logsPerSecond); + Assert.That(logsPerSecond, Is.GreaterThan(1000), "Must log at least 1000 messages per second"); + } + } +} \ No newline at end of file diff --git a/src/Umbraco.Tests/Logging/DebugAppender.cs b/src/Umbraco.Tests/Logging/DebugAppender.cs new file mode 100644 index 0000000000..a483103992 --- /dev/null +++ b/src/Umbraco.Tests/Logging/DebugAppender.cs @@ -0,0 +1,26 @@ +using System; +using System.Threading; +using log4net.Appender; +using log4net.Core; + +namespace Umbraco.Tests.Logging +{ + internal class DebugAppender : MemoryAppender + { + public TimeSpan AppendDelay { get; set; } + public int LoggedEventCount { get { return m_eventsList.Count; } } + + public bool Cancel { get; set; } + + protected override void Append(LoggingEvent loggingEvent) + { + if (Cancel) return; + + if (AppendDelay > TimeSpan.Zero) + { + Thread.Sleep(AppendDelay); + } + base.Append(loggingEvent); + } + } +} \ No newline at end of file diff --git a/src/Umbraco.Tests/Logging/ParallelForwarderTest.cs b/src/Umbraco.Tests/Logging/ParallelForwarderTest.cs new file mode 100644 index 0000000000..03df34c420 --- /dev/null +++ b/src/Umbraco.Tests/Logging/ParallelForwarderTest.cs @@ -0,0 +1,326 @@ +using System; +using System.Diagnostics; +using System.Security.Principal; +using System.Threading; +using log4net; +using log4net.Appender; +using log4net.Config; +using log4net.Core; +using log4net.Filter; +using log4net.Repository; +using Moq; +using NUnit.Framework; +using Umbraco.Core.Logging; + +namespace Umbraco.Tests.Logging +{ + [TestFixture] + public class ParallelForwarderTest : IDisposable + { + private ParallelForwardingAppender asyncForwardingAppender; + private DebugAppender debugAppender; + private ILoggerRepository repository; + private ILog log; + + [SetUp] + public void TestFixtureSetUp() + { + debugAppender = new DebugAppender(); + debugAppender.ActivateOptions(); + + asyncForwardingAppender = new ParallelForwardingAppender(); + asyncForwardingAppender.AddAppender(debugAppender); + asyncForwardingAppender.ActivateOptions(); + + repository = LogManager.CreateRepository(Guid.NewGuid().ToString()); + BasicConfigurator.Configure(repository, asyncForwardingAppender); + + log = LogManager.GetLogger(repository.Name, "TestLogger"); + } + + [TearDown] + public void TearDown() + { + LogManager.Shutdown(); + } + + [Test] + public void CanHandleNullLoggingEvent() + { + // Arrange + + // Act + asyncForwardingAppender.DoAppend((LoggingEvent)null); + log.Info("SusequentMessage"); + asyncForwardingAppender.Close(); + + // Assert - should not have had an exception from previous call + Assert.That(debugAppender.LoggedEventCount, Is.EqualTo(1), "Expected subsequent message only"); + Assert.That(debugAppender.GetEvents()[0].MessageObject, Is.EqualTo("SusequentMessage")); + } + + [Test] + public void CanHandleNullLoggingEvents() + { + // Arrange + + // Act + asyncForwardingAppender.DoAppend((LoggingEvent[])null); + log.Info("SusequentMessage"); + asyncForwardingAppender.Close(); + + // Assert - should not have had an exception from previous call + Assert.That(debugAppender.LoggedEventCount, Is.EqualTo(1), "Expected subsequent message only"); + Assert.That(debugAppender.GetEvents()[0].MessageObject, Is.EqualTo("SusequentMessage")); + } + + [Test] + public void CanHandleAppenderThrowing() + { + // Arrange + var badAppender = new Mock(); + asyncForwardingAppender.AddAppender(badAppender.Object); + + badAppender + .Setup(ba => ba.DoAppend(It.IsAny())) + .Throws(new Exception("Bad Appender")); + //.Verifiable(); + + // Act + log.Info("InitialMessage"); + log.Info("SusequentMessage"); + asyncForwardingAppender.Close(); + + // Assert + Assert.That(debugAppender.LoggedEventCount, Is.EqualTo(2)); + Assert.That(debugAppender.GetEvents()[1].MessageObject, Is.EqualTo("SusequentMessage")); + badAppender.Verify(appender => appender.DoAppend(It.IsAny()), Times.Exactly(2)); + } + + [Test] + public void WillLogFastWhenThereIsASlowAppender() + { + const int testSize = 1000; + + // Arrange + debugAppender.AppendDelay = TimeSpan.FromSeconds(10); + var watch = new Stopwatch(); + + // Act + watch.Start(); + for (int i = 0; i < testSize; i++) + { + log.Error("Exception"); + } + watch.Stop(); + + // Assert + Assert.That(debugAppender.LoggedEventCount, Is.EqualTo(0)); + Assert.That(watch.ElapsedMilliseconds, Is.LessThan(testSize)); + Console.WriteLine("Logged {0} errors in {1}ms", testSize, watch.ElapsedMilliseconds); + + debugAppender.Cancel = true; + } + + [Test] + public void WillNotOverflow() + { + const int testSize = 1000; + + // Arrange + debugAppender.AppendDelay = TimeSpan.FromMilliseconds(1); + asyncForwardingAppender.BufferSize = 100; + + // Act + for (int i = 0; i < testSize; i++) + { + log.Error("Exception"); + } + + while (asyncForwardingAppender.BufferEntryCount > 0) ; + asyncForwardingAppender.Close(); + + // Assert + Assert.That(debugAppender.LoggedEventCount, Is.EqualTo(testSize)); + } + + [Test] + public void WillTryToFlushBufferOnShutdown() + { + const int testSize = 250; + + // Arrange + debugAppender.AppendDelay = TimeSpan.FromMilliseconds(1); + + // Act + for (int i = 0; i < testSize; i++) + { + log.Error("Exception"); + } + + Thread.Sleep(50); + + var numberLoggedBeforeClose = debugAppender.LoggedEventCount; + asyncForwardingAppender.Close(); + var numberLoggedAfterClose = debugAppender.LoggedEventCount; + + // Assert + //We can't use specific numbers here because the timing and counts will be different on different systems. + Assert.That(numberLoggedBeforeClose, Is.GreaterThan(0), "Some number of Logging events should be logged prior to appender close."); + //On some systems, we may not be able to flush all events prior to close, but it is reasonable to assume in this test case + //that some events should be logged after close. + Assert.That(numberLoggedAfterClose, Is.GreaterThan(numberLoggedBeforeClose), "Some number of LoggingEvents should be logged after close."); + Console.WriteLine("Flushed {0} events during shutdown", numberLoggedAfterClose - numberLoggedBeforeClose); + } + + [Test, Explicit("Long-running")] + public void WillShutdownIfBufferCannotBeFlushedFastEnough() + { + const int testSize = 250; + + // Arrange + debugAppender.AppendDelay = TimeSpan.FromSeconds(1); + Stopwatch watch = new Stopwatch(); + + // Act + for (int i = 0; i < testSize; i++) + { + log.Error("Exception"); + } + + Thread.Sleep(TimeSpan.FromSeconds(2)); + var numberLoggedBeforeClose = debugAppender.LoggedEventCount; + + watch.Start(); + asyncForwardingAppender.Close(); + watch.Stop(); + + var numberLoggedAfterClose = debugAppender.LoggedEventCount; + + // Assert + Assert.That(numberLoggedBeforeClose, Is.GreaterThan(0)); + Assert.That(numberLoggedAfterClose, Is.GreaterThan(numberLoggedBeforeClose)); + Assert.That(numberLoggedAfterClose, Is.LessThan(testSize)); + //We can't assume what the shutdown time will be. It will vary from system to system. Don't test shutdown time. + var events = debugAppender.GetEvents(); + var evnt = events[events.Length - 1]; + Assert.That(evnt.MessageObject, Is.EqualTo("The buffer was not able to be flushed before timeout occurred.")); + Console.WriteLine("Flushed {0} events during shutdown which lasted {1}ms", numberLoggedAfterClose - numberLoggedBeforeClose, watch.ElapsedMilliseconds); + } + + [Test] + public void ThreadContextPropertiesArePreserved() + { + // Arrange + ThreadContext.Properties["TestProperty"] = "My Value"; + Assert.That(asyncForwardingAppender.Fix & FixFlags.Properties, Is.EqualTo(FixFlags.Properties), "Properties must be fixed if they are to be preserved"); + + // Act + log.Info("Information"); + asyncForwardingAppender.Close(); + + // Assert + var lastLoggedEvent = debugAppender.GetEvents()[0]; + Assert.That(lastLoggedEvent.Properties["TestProperty"], Is.EqualTo("My Value")); + } + + [Test] + public void MessagesExcludedByFilterShouldNotBeAppended() + { + // Arrange + var levelFilter = + new LevelRangeFilter + { + LevelMin = Level.Warn, + LevelMax = Level.Error, + }; + + asyncForwardingAppender.AddFilter(levelFilter); + + // Act + log.Info("Info"); + log.Warn("Warn"); + log.Error("Error"); + log.Fatal("Fatal"); + + asyncForwardingAppender.Close(); + + //Assert + Assert.That(debugAppender.LoggedEventCount, Is.EqualTo(2)); + } + + [Test] + public void HelperCanGenerateLoggingEventWithAllProperties() + { + // Arrange + var helper = new LoggingEventHelper("TestLoggerName", FixFlags.All); + ThreadContext.Properties["MyProperty"] = "MyValue"; + var exception = new Exception("SomeError"); + + var stackFrame = new StackFrame(0); + var currentUser = WindowsIdentity.GetCurrent(); + var loggingTime = DateTime.Now; // Log4Net does not seem to be using UtcNow + + // Act + var loggingEvent = helper.CreateLoggingEvent(Level.Emergency, "Who's on live support?", exception); + Thread.Sleep(50); // to make sure the time stamp is actually captured + + // Assert + Assert.That(loggingEvent.Domain, Is.EqualTo(AppDomain.CurrentDomain.FriendlyName), "Domain"); + //The identity assigned to new threads is dependent upon AppDomain principal policy. + //Background information here:http://www.neovolve.com/post/2010/10/21/Unit-testing-a-workflow-that-relies-on-ThreadCurrentPrincipalIdentityName.aspx + //VS2013 does have a principal assigned to new threads in the unit test. + //It's probably best not to test that the identity has been set. + //Assert.That(loggingEvent.Identity, Is.Empty, "Identity: always empty for some reason"); + Assert.That(loggingEvent.UserName, Is.EqualTo(currentUser == null ? String.Empty : currentUser.Name), "UserName"); + Assert.That(loggingEvent.ThreadName, Is.EqualTo(Thread.CurrentThread.Name), "ThreadName"); + + Assert.That(loggingEvent.Repository, Is.Null, "Repository: Helper does not have access to this"); + Assert.That(loggingEvent.LoggerName, Is.EqualTo("TestLoggerName"), "LoggerName"); + + Assert.That(loggingEvent.Level, Is.EqualTo(Level.Emergency), "Level"); + //Raised time to within 10 ms. However, this may not be a valid test. The time is going to vary from system to system. The + //tolerance setting here is arbitrary. + Assert.That(loggingEvent.TimeStamp, Is.EqualTo(loggingTime).Within(TimeSpan.FromMilliseconds(10)), "TimeStamp"); + Assert.That(loggingEvent.ExceptionObject, Is.EqualTo(exception), "ExceptionObject"); + Assert.That(loggingEvent.MessageObject, Is.EqualTo("Who's on live support?"), "MessageObject"); + + Assert.That(loggingEvent.LocationInformation.MethodName, Is.EqualTo(stackFrame.GetMethod().Name), "LocationInformation"); + Assert.That(loggingEvent.Properties["MyProperty"], Is.EqualTo("MyValue"), "Properties"); + } + + private bool _disposed = false; + + //Implement IDisposable. + public void Dispose() + { + Dispose(true); + GC.SuppressFinalize(this); + } + + protected virtual void Dispose(bool disposing) + { + if (!_disposed) + { + if (disposing) + { + if (asyncForwardingAppender != null) + { + asyncForwardingAppender.Dispose(); + asyncForwardingAppender = null; + } + } + // Free your own state (unmanaged objects). + // Set large fields to null. + _disposed = true; + } + } + + // Use C# destructor syntax for finalization code. + ~ParallelForwarderTest() + { + // Simply call Dispose(false). + Dispose(false); + } + } +} \ No newline at end of file diff --git a/src/Umbraco.Tests/Logging/RingBufferTest.cs b/src/Umbraco.Tests/Logging/RingBufferTest.cs new file mode 100644 index 0000000000..8e80faf8ad --- /dev/null +++ b/src/Umbraco.Tests/Logging/RingBufferTest.cs @@ -0,0 +1,147 @@ +using System; +using System.Collections.Generic; +using System.Diagnostics; +using System.Threading; +using System.Threading.Tasks; +using NUnit.Framework; +using Umbraco.Core.Logging; +using Umbraco.Tests.TestHelpers; + +namespace Umbraco.Tests.Logging +{ + [TestFixture] + public class RingBufferTest + { + [Test] + public void PerfTest() + { + RingBuffer ringBuffer = new RingBuffer(1000); + Stopwatch ringWatch = new Stopwatch(); + ringWatch.Start(); + for (int i = 0; i < 1000000; i++) + { + ringBuffer.Enqueue("StringOfFun"); + } + ringWatch.Stop(); + + Assert.That(ringWatch.ElapsedMilliseconds, Is.LessThan(150)); + } + + [Test] + public void PerfTestThreads() + { + RingBuffer ringBuffer = new RingBuffer(1000); + + Stopwatch ringWatch = new Stopwatch(); + List ringTasks = new List(); + CancellationTokenSource cancelationTokenSource = new CancellationTokenSource(); + CancellationToken cancelationToken = cancelationTokenSource.Token; + for (int t = 0; t < 10; t++) + { + ringTasks.Add(new Task(() => + { + for (int i = 0; i < 1000000; i++) + { + ringBuffer.Enqueue("StringOfFun"); + } + }, cancelationToken)); + } + ringWatch.Start(); + ringTasks.ForEach(t => t.Start()); + var allTasks = ringTasks.ToArray(); + Task.WaitAny(allTasks); + ringWatch.Stop(); + //Cancel tasks to avoid System.AppDominUnloadException which is caused when the domain is unloaded + //and threads created in the domain are not stopped. + //Do this before assertions because they may throw an exception causing the thread cancellation to not happen. + cancelationTokenSource.Cancel(); + try + { + Task.WaitAll(allTasks); + } + catch (AggregateException) + { + //Don't care about cancellation Exceptions. + } + //Tolerance at 500 was too low + ringTasks.ForEach(t => t.Dispose()); + Assert.That(ringWatch.ElapsedMilliseconds, Is.LessThan(1000)); + } + + [Test] + public void PerfTestThreadsWithDequeues() + { + RingBuffer ringBuffer = new RingBuffer(1000); + + Stopwatch ringWatch = new Stopwatch(); + List ringTasks = new List(); + CancellationTokenSource cancelationTokenSource = new CancellationTokenSource(); + CancellationToken cancelationToken = cancelationTokenSource.Token; + for (int t = 0; t < 10; t++) + { + ringTasks.Add(new Task(() => + { + for (int i = 0; i < 1000000; i++) + { + ringBuffer.Enqueue("StringOfFun"); + } + }, cancelationToken)); + } + for (int t = 0; t < 10; t++) + { + ringTasks.Add(new Task(() => + { + for (int i = 0; i < 1000000; i++) + { + string foo; + ringBuffer.TryDequeue(out foo); + } + })); + } + ringWatch.Start(); + ringTasks.ForEach(t => t.Start()); + var allTasks = ringTasks.ToArray(); + Task.WaitAny(allTasks); + ringWatch.Stop(); + //Cancel tasks to avoid System.AppDominUnloadException which is caused when the domain is unloaded + //and threads created in the domain are not stopped. + //Do this before assertions because they may throw an exception causing the thread cancellation to not happen. + cancelationTokenSource.Cancel(); + try + { + Task.WaitAll(allTasks); + } + catch (AggregateException) + { + //Don't care about cancellation Exceptions. + } + ringTasks.ForEach(t => t.Dispose()); + Assert.That(ringWatch.ElapsedMilliseconds, Is.LessThan(800)); + } + + [Test] + public void WhenRingSizeLimitIsHit_ItemsAreDequeued() + { + // Arrange + const int limit = 2; + object object1 = "one"; + object object2 = "two"; + object object3 = "three"; + RingBuffer queue = new RingBuffer(limit); + + // Act + queue.Enqueue(object1); + queue.Enqueue(object2); + queue.Enqueue(object3); + + // Assert + object value; + queue.TryDequeue(out value); + Assert.That(value, Is.EqualTo(object2)); + queue.TryDequeue(out value); + Assert.That(value, Is.EqualTo(object3)); + queue.TryDequeue(out value); + Assert.That(value, Is.Null); + } + } +} \ No newline at end of file diff --git a/src/Umbraco.Tests/Membership/MembershipProviderBaseTests.cs b/src/Umbraco.Tests/Membership/MembershipProviderBaseTests.cs index 609452978c..c786a61996 100644 --- a/src/Umbraco.Tests/Membership/MembershipProviderBaseTests.cs +++ b/src/Umbraco.Tests/Membership/MembershipProviderBaseTests.cs @@ -148,7 +148,7 @@ namespace Umbraco.Tests.Membership Assert.AreEqual(false, provider.EnablePasswordReset); Assert.AreEqual(false, provider.RequiresQuestionAndAnswer); Assert.AreEqual(true, provider.RequiresUniqueEmail); - Assert.AreEqual(20, provider.MaxInvalidPasswordAttempts); + Assert.AreEqual(5, provider.MaxInvalidPasswordAttempts); Assert.AreEqual(10, provider.PasswordAttemptWindow); Assert.AreEqual(provider.DefaultMinPasswordLength, provider.MinRequiredPasswordLength); Assert.AreEqual(provider.DefaultMinNonAlphanumericChars, provider.MinRequiredNonAlphanumericCharacters); diff --git a/src/Umbraco.Tests/Migrations/SqlScripts/MySqlTotal-480.sql b/src/Umbraco.Tests/Migrations/SqlScripts/MySqlTotal-480.sql index 818a20babb..49af66b93b 100644 --- a/src/Umbraco.Tests/Migrations/SqlScripts/MySqlTotal-480.sql +++ b/src/Umbraco.Tests/Migrations/SqlScripts/MySqlTotal-480.sql @@ -478,14 +478,6 @@ permission char (1) NOT NULL ; ALTER TABLE umbracoUser2NodePermission ADD CONSTRAINT PK_umbracoUser2NodePermission PRIMARY KEY CLUSTERED (userId, nodeId, permission) -; -CREATE TABLE umbracoUserLogins -( -contextId CHAR(36) NOT NULL, -userID int NOT NULL, -timeout bigint NOT NULL -) - ; INSERT INTO umbracoNode (id, trashed, parentID, nodeUser, level, path, sortOrder, uniqueID, text, nodeObjectType, createDate) VALUES (-92, 0, -1, 0, 11, '-1,-92', 37, 'f0bc4bfb-b499-40d6-ba86-058885a5178c', 'Label', '30a2a501-1978-4ddb-a57b-f7efed43ba3c', '2004/09/30 14:01:49.920'), diff --git a/src/Umbraco.Tests/Migrations/SqlScripts/SqlCe-SchemaAndData-4110.sql b/src/Umbraco.Tests/Migrations/SqlScripts/SqlCe-SchemaAndData-4110.sql index 82f4eefcca..e4c3d47ee2 100644 Binary files a/src/Umbraco.Tests/Migrations/SqlScripts/SqlCe-SchemaAndData-4110.sql and b/src/Umbraco.Tests/Migrations/SqlScripts/SqlCe-SchemaAndData-4110.sql differ diff --git a/src/Umbraco.Tests/Migrations/SqlScripts/SqlCeTotal-480.sql b/src/Umbraco.Tests/Migrations/SqlScripts/SqlCeTotal-480.sql index 84a6d0927a..9f535a518a 100644 --- a/src/Umbraco.Tests/Migrations/SqlScripts/SqlCeTotal-480.sql +++ b/src/Umbraco.Tests/Migrations/SqlScripts/SqlCeTotal-480.sql @@ -443,14 +443,7 @@ CREATE TABLE [umbracoUser2NodePermission] ; ALTER TABLE [umbracoUser2NodePermission] ADD CONSTRAINT [PK_umbracoUser2NodePermission] PRIMARY KEY ([userId], [nodeId], [permission]) ; -CREATE TABLE [umbracoUserLogins] -( -[contextID] [uniqueidentifier] NOT NULL, -[userID] [int] NOT NULL, -[timeout] [bigint] NOT NULL -) -; ALTER TABLE [umbracoAppTree] ADD CONSTRAINT [FK_umbracoAppTree_umbracoApp] FOREIGN KEY ([appAlias]) REFERENCES [umbracoApp] ([appAlias]) ; diff --git a/src/Umbraco.Tests/Migrations/SqlScripts/SqlServerTotal-480.sql b/src/Umbraco.Tests/Migrations/SqlScripts/SqlServerTotal-480.sql index ff82b7a3fc..c729a7ffbc 100644 --- a/src/Umbraco.Tests/Migrations/SqlScripts/SqlServerTotal-480.sql +++ b/src/Umbraco.Tests/Migrations/SqlScripts/SqlServerTotal-480.sql @@ -541,16 +541,7 @@ CREATE TABLE [umbracoUser2NodePermission] ; ALTER TABLE [umbracoUser2NodePermission] ADD CONSTRAINT [PK_umbracoUser2NodePermission] PRIMARY KEY CLUSTERED ([userId], [nodeId], [permission]) -; -CREATE TABLE [umbracoUserLogins] -( -[contextID] [uniqueidentifier] NOT NULL, -[userID] [int] NOT NULL, -[timeout] [bigint] NOT NULL -) ; -CREATE CLUSTERED INDEX umbracoUserLogins_Index ON umbracoUserLogins (contextID) -; ALTER TABLE [umbracoAppTree] ADD CONSTRAINT [FK_umbracoAppTree_umbracoApp] FOREIGN KEY ([appAlias]) REFERENCES [umbracoApp] ([appAlias]) ; diff --git a/src/Umbraco.Tests/Models/Mapping/ContentTypeModelMappingTests.cs b/src/Umbraco.Tests/Models/Mapping/ContentTypeModelMappingTests.cs index 95f3f55308..ad47bafb80 100644 --- a/src/Umbraco.Tests/Models/Mapping/ContentTypeModelMappingTests.cs +++ b/src/Umbraco.Tests/Models/Mapping/ContentTypeModelMappingTests.cs @@ -69,7 +69,7 @@ namespace Umbraco.Tests.Models.Mapping } [Test] - public void ContentTypeDisplay_To_PropertyType() + public void PropertyTypeDisplay_To_PropertyType() { // setup the mocks to return the data we want to test against... @@ -207,6 +207,33 @@ namespace Umbraco.Tests.Models.Mapping } } + [Test] + public void ContentTypeDisplay_With_Composition_To_IContentType() + { + //Arrange + + // setup the mocks to return the data we want to test against... + + _dataTypeService.Setup(x => x.GetDataTypeDefinitionById(It.IsAny())) + .Returns(Mock.Of( + definition => + definition.Id == 555 + && definition.PropertyEditorAlias == "myPropertyType" + && definition.DatabaseType == DataTypeDatabaseType.Nvarchar)); + + + var display = CreateCompositionContentTypeDisplay(); + + //Act + + var result = Mapper.Map(display); + + //Assert + + //TODO: Now we need to assert all of the more complicated parts + Assert.AreEqual(display.Groups.Count(x => x.Inherited == false), result.PropertyGroups.Count); + } + [Test] public void IContentType_To_ContentTypeDisplay() { @@ -227,17 +254,7 @@ namespace Umbraco.Tests.Models.Mapping .Returns(new[] { new TextboxPropertyEditor() }); var contentType = MockedContentTypes.CreateTextpageContentType(); - //ensure everything has ids - contentType.Id = 1234; - var itemid = 8888; - foreach (var propertyGroup in contentType.CompositionPropertyGroups) - { - propertyGroup.Id = itemid++; - } - foreach (var propertyType in contentType.CompositionPropertyTypes) - { - propertyType.Id = itemid++; - } + MockedContentTypes.EnsureAllIds(contentType, 8888); //Act @@ -289,6 +306,103 @@ namespace Umbraco.Tests.Models.Mapping } + [Test] + public void IContentTypeComposition_To_ContentTypeDisplay() + { + //Arrange + + // setup the mocks to return the data we want to test against... + + // for any call to GetPreValuesCollectionByDataTypeId just return an empty dictionary for now + // TODO: but we'll need to change this to return some pre-values to test the mappings + _dataTypeService.Setup(x => x.GetPreValuesCollectionByDataTypeId(It.IsAny())) + .Returns(new PreValueCollection(new Dictionary())); + + //return a textbox property editor for any requested editor by alias + _propertyEditorResolver.Setup(resolver => resolver.GetByAlias(It.IsAny())) + .Returns(new TextboxPropertyEditor()); + //for testing, just return a list of whatever property editors we want + _propertyEditorResolver.Setup(resolver => resolver.PropertyEditors) + .Returns(new[] { new TextboxPropertyEditor() }); + + var ctMain = MockedContentTypes.CreateSimpleContentType(); + //not assigned to tab + ctMain.AddPropertyType(new PropertyType(Constants.PropertyEditors.TextboxAlias, DataTypeDatabaseType.Ntext) + { + Alias = "umbracoUrlName", Name = "Slug", Description = "", Mandatory = false, SortOrder = 1, DataTypeDefinitionId = -88 + }); + MockedContentTypes.EnsureAllIds(ctMain, 8888); + var ctChild1 = MockedContentTypes.CreateSimpleContentType("child1", "Child 1", ctMain, true); + ctChild1.AddPropertyType(new PropertyType(Constants.PropertyEditors.TextboxAlias, DataTypeDatabaseType.Ntext) + { + Alias = "someProperty", + Name = "Some Property", + Description = "", + Mandatory = false, + SortOrder = 1, + DataTypeDefinitionId = -88 + }, "Another tab"); + MockedContentTypes.EnsureAllIds(ctChild1, 7777); + var contentType = MockedContentTypes.CreateSimpleContentType("child2", "Child 2", ctChild1, true, "CustomGroup"); + //not assigned to tab + contentType.AddPropertyType(new PropertyType(Constants.PropertyEditors.TextboxAlias, DataTypeDatabaseType.Ntext) + { + Alias = "umbracoUrlAlias", Name = "AltUrl", Description = "", Mandatory = false, SortOrder = 1, DataTypeDefinitionId = -88 + }); + MockedContentTypes.EnsureAllIds(contentType, 6666); + + + //Act + + var result = Mapper.Map(contentType); + + //Assert + + Assert.AreEqual(contentType.Alias, result.Alias); + Assert.AreEqual(contentType.Description, result.Description); + Assert.AreEqual(contentType.Icon, result.Icon); + Assert.AreEqual(contentType.Id, result.Id); + Assert.AreEqual(contentType.Name, result.Name); + Assert.AreEqual(contentType.ParentId, result.ParentId); + Assert.AreEqual(contentType.Path, result.Path); + Assert.AreEqual(contentType.Thumbnail, result.Thumbnail); + Assert.AreEqual(contentType.IsContainer, result.IsContainer); + Assert.AreEqual(contentType.CreateDate, result.CreateDate); + Assert.AreEqual(contentType.UpdateDate, result.UpdateDate); + Assert.AreEqual(contentType.DefaultTemplate.Alias, result.DefaultTemplate.Alias); + + //TODO: Now we need to assert all of the more complicated parts + + Assert.AreEqual(contentType.CompositionPropertyGroups.Select(x => x.Name).Distinct().Count(), result.Groups.Count(x => x.Id != -666)); + Assert.AreEqual(1, result.Groups.Count(x => x.Id == -666)); + Assert.AreEqual(contentType.PropertyGroups.Count(), result.Groups.Count(x => x.Inherited == false && x.Id != -666)); + + var allPropertiesMapped = result.Groups.SelectMany(x => x.Properties).ToArray(); + var allPropertyIdsMapped = allPropertiesMapped.Select(x => x.Id).ToArray(); + var allSourcePropertyIds = contentType.CompositionPropertyTypes.Select(x => x.Id).ToArray(); + + Assert.AreEqual(contentType.PropertyTypes.Count(), allPropertiesMapped.Count(x => x.Inherited == false)); + Assert.AreEqual(allPropertyIdsMapped.Count(), allSourcePropertyIds.Count()); + Assert.IsTrue(allPropertyIdsMapped.ContainsAll(allSourcePropertyIds)); + + Assert.AreEqual(2, result.Groups.Count(x => x.ParentTabContentTypes.Any())); + Assert.IsTrue(result.Groups.SelectMany(x => x.ParentTabContentTypes).ContainsAll(new[] {ctMain.Id, ctChild1.Id})); + + Assert.AreEqual(contentType.AllowedTemplates.Count(), result.AllowedTemplates.Count()); + for (var i = 0; i < contentType.AllowedTemplates.Count(); i++) + { + Assert.AreEqual(contentType.AllowedTemplates.ElementAt(i).Id, result.AllowedTemplates.ElementAt(i).Id); + } + + Assert.AreEqual(contentType.AllowedContentTypes.Count(), result.AllowedContentTypes.Count()); + for (var i = 0; i < contentType.AllowedContentTypes.Count(); i++) + { + Assert.AreEqual(contentType.AllowedContentTypes.ElementAt(i).Id.Value, result.AllowedContentTypes.ElementAt(i)); + } + + } + + private ContentTypeDisplay CreateSimpleContentTypeDisplay() { return new ContentTypeDisplay @@ -359,6 +473,113 @@ namespace Umbraco.Tests.Models.Mapping } } } + }; + } + + private ContentTypeDisplay CreateCompositionContentTypeDisplay() + { + return new ContentTypeDisplay + { + Alias = "test", + AllowAsRoot = true, + AllowedTemplates = new List + { + new EntityBasic + { + Id = 555, + Alias = "template1", + Name = "Template1" + }, + new EntityBasic + { + Id = 556, + Alias = "template2", + Name = "Template2" + } + }, + AllowedContentTypes = new[] { 666, 667 }, + AvailableCompositeContentTypes = new List(), + DefaultTemplate = new EntityBasic() { Alias = "test" }, + Description = "hello world", + Icon = "tree-icon", + Id = 1234, + Key = new Guid("8A60656B-3866-46AB-824A-48AE85083070"), + Name = "My content type", + Path = "-1,1234", + ParentId = -1, + Thumbnail = "tree-thumb", + IsContainer = true, + Groups = new List() + { + new PropertyGroupDisplay + { + Id = 987, + Name = "Tab 1", + ParentGroupId = -1, + SortOrder = 0, + Inherited = false, + Properties = new List + { + new PropertyTypeDisplay + { + Alias = "property1", + Description = "this is property 1", + Inherited = false, + Label = "Property 1", + Validation = new PropertyTypeValidation + { + Mandatory = false, + Pattern = "" + }, + Editor = "myPropertyType", + Value = "value 1", + //View = ??? - isn't this the same as editor? + Config = new Dictionary + { + {"item1", "value1"}, + {"item2", "value2"} + }, + SortOrder = 0, + DataTypeId = 555, + View = "blah" + } + } + }, + new PropertyGroupDisplay + { + Id = 894, + Name = "Tab 2", + ParentGroupId = -1, + SortOrder = 0, + Inherited = true, + Properties = new List + { + new PropertyTypeDisplay + { + Alias = "parentProperty", + Description = "this is a property from the parent", + Inherited = true, + Label = "Parent property", + Validation = new PropertyTypeValidation + { + Mandatory = false, + Pattern = "" + }, + Editor = "myPropertyType", + Value = "parent value", + //View = ??? - isn't this the same as editor? + Config = new Dictionary + { + {"item1", "value1"} + }, + SortOrder = 0, + DataTypeId = 555, + View = "blah" + } + } + + } + } }; } diff --git a/src/Umbraco.Tests/Persistence/BaseTableByTableTest.cs b/src/Umbraco.Tests/Persistence/BaseTableByTableTest.cs index 2467bf8a54..7bc4b2b76f 100644 --- a/src/Umbraco.Tests/Persistence/BaseTableByTableTest.cs +++ b/src/Umbraco.Tests/Persistence/BaseTableByTableTest.cs @@ -258,6 +258,7 @@ namespace Umbraco.Tests.Persistence using (Transaction transaction = Database.GetTransaction()) { DatabaseSchemaHelper.CreateTable(); + DatabaseSchemaHelper.CreateTable(); DatabaseSchemaHelper.CreateTable(); //transaction.Complete(); @@ -577,18 +578,6 @@ namespace Umbraco.Tests.Persistence } } - [Test] - public void Can_Create_umbracoUserLogins_Table() - { - - using (Transaction transaction = Database.GetTransaction()) - { - DatabaseSchemaHelper.CreateTable(); - - //transaction.Complete(); - } - } - [Test] public void Can_Create_umbracoUser_Table() { diff --git a/src/Umbraco.Tests/Persistence/Repositories/ContentRepositoryTest.cs b/src/Umbraco.Tests/Persistence/Repositories/ContentRepositoryTest.cs index 8b7d87a0a9..089e9ebaf9 100644 --- a/src/Umbraco.Tests/Persistence/Repositories/ContentRepositoryTest.cs +++ b/src/Umbraco.Tests/Persistence/Repositories/ContentRepositoryTest.cs @@ -47,7 +47,7 @@ namespace Umbraco.Tests.Persistence.Repositories var templateRepository = new TemplateRepository(unitOfWork, CacheHelper, Logger, SqlSyntax, Mock.Of(), Mock.Of(), Mock.Of()); var tagRepository = new TagRepository(unitOfWork, CacheHelper, Logger, SqlSyntax); contentTypeRepository = new ContentTypeRepository(unitOfWork, CacheHelper, Logger, SqlSyntax, templateRepository); - var repository = new ContentRepository(unitOfWork, CacheHelper, Logger, SqlSyntax, contentTypeRepository, templateRepository, tagRepository); + var repository = new ContentRepository(unitOfWork, CacheHelper, Logger, SqlSyntax, contentTypeRepository, templateRepository, tagRepository, Mock.Of()); return repository; } diff --git a/src/Umbraco.Tests/Persistence/Repositories/ContentTypeRepositoryTest.cs b/src/Umbraco.Tests/Persistence/Repositories/ContentTypeRepositoryTest.cs index eba0b7a6b0..81a1892f7b 100644 --- a/src/Umbraco.Tests/Persistence/Repositories/ContentTypeRepositoryTest.cs +++ b/src/Umbraco.Tests/Persistence/Repositories/ContentTypeRepositoryTest.cs @@ -45,7 +45,7 @@ namespace Umbraco.Tests.Persistence.Repositories var templateRepository = new TemplateRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of(), SqlSyntax, Mock.Of(), Mock.Of(), Mock.Of()); var tagRepository = new TagRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of(), SqlSyntax); contentTypeRepository = new ContentTypeRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of(), SqlSyntax, templateRepository); - var repository = new ContentRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of(), SqlSyntax, contentTypeRepository, templateRepository, tagRepository); + var repository = new ContentRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of(), SqlSyntax, contentTypeRepository, templateRepository, tagRepository, Mock.Of()); return repository; } @@ -328,6 +328,25 @@ namespace Umbraco.Tests.Persistence.Repositories } } + [Test] + public void Can_Perform_Get_By_Guid_On_ContentTypeRepository() + { + // Arrange + var provider = new PetaPocoUnitOfWorkProvider(Logger); + var unitOfWork = provider.GetUnitOfWork(); + using (var repository = CreateRepository(unitOfWork)) + { + var contentType = repository.Get(NodeDto.NodeIdSeed + 1); + + // Act + contentType = repository.Get(contentType.Key); + + // Assert + Assert.That(contentType, Is.Not.Null); + Assert.That(contentType.Id, Is.EqualTo(NodeDto.NodeIdSeed + 1)); + } + } + [Test] public void Can_Perform_GetAll_On_ContentTypeRepository() { @@ -350,6 +369,29 @@ namespace Umbraco.Tests.Persistence.Repositories } } + [Test] + public void Can_Perform_GetAll_By_Guid_On_ContentTypeRepository() + { + // Arrange + var provider = new PetaPocoUnitOfWorkProvider(Logger); + var unitOfWork = provider.GetUnitOfWork(); + using (var repository = CreateRepository(unitOfWork)) + { + var allGuidIds = repository.GetAll().Select(x => x.Key).ToArray(); + + // Act + var contentTypes = repository.GetAll(allGuidIds); + int count = + DatabaseContext.Database.ExecuteScalar( + "SELECT COUNT(*) FROM umbracoNode WHERE nodeObjectType = @NodeObjectType", + new { NodeObjectType = new Guid(Constants.ObjectTypes.DocumentType) }); + + // Assert + Assert.That(contentTypes.Any(), Is.True); + Assert.That(contentTypes.Count(), Is.EqualTo(count)); + } + } + [Test] public void Can_Perform_Exists_On_ContentTypeRepository() { diff --git a/src/Umbraco.Tests/Persistence/Repositories/DataTypeDefinitionRepositoryTest.cs b/src/Umbraco.Tests/Persistence/Repositories/DataTypeDefinitionRepositoryTest.cs index f3d7aaa0f1..289bd628ee 100644 --- a/src/Umbraco.Tests/Persistence/Repositories/DataTypeDefinitionRepositoryTest.cs +++ b/src/Umbraco.Tests/Persistence/Repositories/DataTypeDefinitionRepositoryTest.cs @@ -1,6 +1,7 @@ using System; using System.Data; using System.Linq; +using System.Text.RegularExpressions; using Moq; using NUnit.Framework; using Umbraco.Core; @@ -40,6 +41,23 @@ namespace Umbraco.Tests.Persistence.Repositories return dataTypeDefinitionRepository; } + [TestCase("UmbracoPreVal87-21,3,48", 3, true)] + [TestCase("UmbracoPreVal87-21,33,48", 3, false)] + [TestCase("UmbracoPreVal87-21,33,48", 33, true)] + [TestCase("UmbracoPreVal87-21,3,48", 33, false)] + [TestCase("UmbracoPreVal87-21,3,48", 21, true)] + [TestCase("UmbracoPreVal87-21,3,48", 48, true)] + [TestCase("UmbracoPreVal87-22,33,48", 2, false)] + [TestCase("UmbracoPreVal87-22,33,48", 22, true)] + [TestCase("UmbracoPreVal87-22,33,44", 4, false)] + [TestCase("UmbracoPreVal87-22,33,44", 44, true)] + [TestCase("UmbracoPreVal87-22,333,44", 33, false)] + [TestCase("UmbracoPreVal87-22,333,44", 333, true)] + public void Pre_Value_Cache_Key_Tests(string cacheKey, int preValueId, bool outcome) + { + Assert.AreEqual(outcome, Regex.IsMatch(cacheKey, DataTypeDefinitionRepository.GetCacheKeyRegex(preValueId))); + } + [Test] public void Can_Create() { diff --git a/src/Umbraco.Tests/Persistence/Repositories/DictionaryRepositoryTest.cs b/src/Umbraco.Tests/Persistence/Repositories/DictionaryRepositoryTest.cs index 25fcc5e13a..d21da8c6e2 100644 --- a/src/Umbraco.Tests/Persistence/Repositories/DictionaryRepositoryTest.cs +++ b/src/Umbraco.Tests/Persistence/Repositories/DictionaryRepositoryTest.cs @@ -161,37 +161,6 @@ namespace Umbraco.Tests.Persistence.Repositories } - [Test] - public void Get_Ignores_Item_WhenLanguageMissing() - { - // Arrange - var language = ServiceContext.LocalizationService.GetLanguageByCultureCode("en-US"); - var itemMissingLanguage = new DictionaryItem("I have invalid language"); - var translations = new List - { - new DictionaryTranslation(new Language("") { Id = 0 }, ""), - new DictionaryTranslation(language, "I have language") - }; - itemMissingLanguage.Translations = translations; - ServiceContext.LocalizationService.Save(itemMissingLanguage);//Id 3? - - var provider = new PetaPocoUnitOfWorkProvider(Logger); - var unitOfWork = provider.GetUnitOfWork(); - LanguageRepository languageRepository; - using (var repository = CreateRepository(unitOfWork, out languageRepository)) - { - // Act - var dictionaryItem = repository.Get(3); - - // Assert - Assert.That(dictionaryItem, Is.Not.Null); - Assert.That(dictionaryItem.ItemKey, Is.EqualTo("I have invalid language")); - Assert.That(dictionaryItem.Translations.Any(), Is.True); - Assert.That(dictionaryItem.Translations.Any(x => x == null), Is.False); - Assert.That(dictionaryItem.Translations.First().Value, Is.EqualTo("I have language")); - Assert.That(dictionaryItem.Translations.Count(), Is.EqualTo(1)); - } - } [Test] public void Can_Perform_GetAll_On_DictionaryRepository() diff --git a/src/Umbraco.Tests/Persistence/Repositories/DomainRepositoryTest.cs b/src/Umbraco.Tests/Persistence/Repositories/DomainRepositoryTest.cs index f394bafb1f..08fae6d3ef 100644 --- a/src/Umbraco.Tests/Persistence/Repositories/DomainRepositoryTest.cs +++ b/src/Umbraco.Tests/Persistence/Repositories/DomainRepositoryTest.cs @@ -25,7 +25,7 @@ namespace Umbraco.Tests.Persistence.Repositories var templateRepository = new TemplateRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Logger, SqlSyntax, Mock.Of(), Mock.Of(), Mock.Of()); var tagRepository = new TagRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Logger, SqlSyntax); contentTypeRepository = new ContentTypeRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Logger, SqlSyntax, templateRepository); - contentRepository = new ContentRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Logger, SqlSyntax, contentTypeRepository, templateRepository, tagRepository); + contentRepository = new ContentRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Logger, SqlSyntax, contentTypeRepository, templateRepository, tagRepository, Mock.Of()); languageRepository = new LanguageRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Logger, SqlSyntax); var domainRepository = new DomainRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Logger, SqlSyntax, contentRepository, languageRepository); return domainRepository; diff --git a/src/Umbraco.Tests/Persistence/Repositories/MediaRepositoryTest.cs b/src/Umbraco.Tests/Persistence/Repositories/MediaRepositoryTest.cs index a26c9ead5d..60c49f89cd 100644 --- a/src/Umbraco.Tests/Persistence/Repositories/MediaRepositoryTest.cs +++ b/src/Umbraco.Tests/Persistence/Repositories/MediaRepositoryTest.cs @@ -3,6 +3,7 @@ using System.Linq; using System.Xml.Linq; using Moq; using NUnit.Framework; +using Umbraco.Core.Configuration.UmbracoSettings; using Umbraco.Core.Logging; using Umbraco.Core.Models; using Umbraco.Core.Models.EntityBase; @@ -36,7 +37,7 @@ namespace Umbraco.Tests.Persistence.Repositories { mediaTypeRepository = new MediaTypeRepository(unitOfWork, CacheHelper, Mock.Of(), SqlSyntax); var tagRepository = new TagRepository(unitOfWork, CacheHelper, Mock.Of(), SqlSyntax); - var repository = new MediaRepository(unitOfWork, CacheHelper, Mock.Of(), SqlSyntax, mediaTypeRepository, tagRepository); + var repository = new MediaRepository(unitOfWork, CacheHelper, Mock.Of(), SqlSyntax, mediaTypeRepository, tagRepository, Mock.Of()); return repository; } diff --git a/src/Umbraco.Tests/Persistence/Repositories/MediaTypeRepositoryTest.cs b/src/Umbraco.Tests/Persistence/Repositories/MediaTypeRepositoryTest.cs index 55a4b38ba4..d0d66c5479 100644 --- a/src/Umbraco.Tests/Persistence/Repositories/MediaTypeRepositoryTest.cs +++ b/src/Umbraco.Tests/Persistence/Repositories/MediaTypeRepositoryTest.cs @@ -135,6 +135,26 @@ namespace Umbraco.Tests.Persistence.Repositories } } + [Test] + public void Can_Perform_Get_By_Guid_On_MediaTypeRepository() + { + // Arrange + var provider = new PetaPocoUnitOfWorkProvider(Logger); + var unitOfWork = provider.GetUnitOfWork(); + using (var repository = CreateRepository(unitOfWork)) + { + var mediaType = repository.Get(1033); //File + + // Act + mediaType = repository.Get(mediaType.Key); + + // Assert + Assert.That(mediaType, Is.Not.Null); + Assert.That(mediaType.Id, Is.EqualTo(1033)); + Assert.That(mediaType.Name, Is.EqualTo(Constants.Conventions.MediaTypes.File)); + } + } + [Test] public void Can_Perform_GetAll_On_MediaTypeRepository() { @@ -156,6 +176,31 @@ namespace Umbraco.Tests.Persistence.Repositories } } + [Test] + public void Can_Perform_GetAll_By_Guid_On_MediaTypeRepository() + { + // Arrange + var provider = new PetaPocoUnitOfWorkProvider(Logger); + var unitOfWork = provider.GetUnitOfWork(); + using (var repository = CreateRepository(unitOfWork)) + { + var allGuidIds = repository.GetAll().Select(x => x.Key).ToArray(); + + // Act + + var mediaTypes = repository.GetAll(allGuidIds); + + int count = + DatabaseContext.Database.ExecuteScalar( + "SELECT COUNT(*) FROM umbracoNode WHERE nodeObjectType = @NodeObjectType", + new { NodeObjectType = new Guid(Constants.ObjectTypes.MediaType) }); + + // Assert + Assert.That(mediaTypes.Any(), Is.True); + Assert.That(mediaTypes.Count(), Is.EqualTo(count)); + } + } + [Test] public void Can_Perform_Exists_On_MediaTypeRepository() { diff --git a/src/Umbraco.Tests/Persistence/Repositories/MemberRepositoryTest.cs b/src/Umbraco.Tests/Persistence/Repositories/MemberRepositoryTest.cs index d03eeaa475..64e8587e00 100644 --- a/src/Umbraco.Tests/Persistence/Repositories/MemberRepositoryTest.cs +++ b/src/Umbraco.Tests/Persistence/Repositories/MemberRepositoryTest.cs @@ -4,6 +4,7 @@ using System.Xml.Linq; using Moq; using NUnit.Framework; using Umbraco.Core; +using Umbraco.Core.Configuration.UmbracoSettings; using Umbraco.Core.Logging; using Umbraco.Core.Models; using Umbraco.Core.Models.Rdbms; @@ -38,7 +39,7 @@ namespace Umbraco.Tests.Persistence.Repositories memberTypeRepository = new MemberTypeRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of(), SqlSyntax); memberGroupRepository = new MemberGroupRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of(), SqlSyntax, CacheHelper.CreateDisabledCacheHelper()); var tagRepo = new TagRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of(), SqlSyntax); - var repository = new MemberRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of(), SqlSyntax, memberTypeRepository, memberGroupRepository, tagRepo); + var repository = new MemberRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of(), SqlSyntax, memberTypeRepository, memberGroupRepository, tagRepo, Mock.Of()); return repository; } diff --git a/src/Umbraco.Tests/Persistence/Repositories/MemberTypeRepositoryTest.cs b/src/Umbraco.Tests/Persistence/Repositories/MemberTypeRepositoryTest.cs index 1360500d96..1c4e5e4c2b 100644 --- a/src/Umbraco.Tests/Persistence/Repositories/MemberTypeRepositoryTest.cs +++ b/src/Umbraco.Tests/Persistence/Repositories/MemberTypeRepositoryTest.cs @@ -98,6 +98,30 @@ namespace Umbraco.Tests.Persistence.Repositories } } + [Test] + public void Can_Get_All_Member_Types_By_Guid_Ids() + { + var provider = new PetaPocoUnitOfWorkProvider(Logger); + var unitOfWork = provider.GetUnitOfWork(); + using (var repository = CreateRepository(unitOfWork)) + { + var memberType1 = MockedContentTypes.CreateSimpleMemberType(); + repository.AddOrUpdate(memberType1); + unitOfWork.Commit(); + + var memberType2 = MockedContentTypes.CreateSimpleMemberType(); + memberType2.Name = "AnotherType"; + memberType2.Alias = "anotherType"; + repository.AddOrUpdate(memberType2); + unitOfWork.Commit(); + + var result = repository.GetAll(memberType1.Key, memberType2.Key); + + //there are 3 because of the Member type created for init data + Assert.AreEqual(2, result.Count()); + } + } + //NOTE: This tests for left join logic (rev 7b14e8eacc65f82d4f184ef46c23340c09569052) [Test] public void Can_Get_All_Members_When_No_Properties_Assigned() @@ -125,6 +149,7 @@ namespace Umbraco.Tests.Persistence.Repositories } } + [Test] public void Can_Get_Member_Type_By_Id() { @@ -140,6 +165,21 @@ namespace Umbraco.Tests.Persistence.Repositories } } + [Test] + public void Can_Get_Member_Type_By_Guid_Id() + { + var provider = new PetaPocoUnitOfWorkProvider(Logger); + var unitOfWork = provider.GetUnitOfWork(); + using (var repository = CreateRepository(unitOfWork)) + { + IMemberType memberType = MockedContentTypes.CreateSimpleMemberType(); + repository.AddOrUpdate(memberType); + unitOfWork.Commit(); + memberType = repository.Get(memberType.Key); + Assert.That(memberType, Is.Not.Null); + } + } + [Test] public void Built_In_Member_Type_Properties_Are_Automatically_Added_When_Creating() { diff --git a/src/Umbraco.Tests/Persistence/Repositories/PublicAccessRepositoryTest.cs b/src/Umbraco.Tests/Persistence/Repositories/PublicAccessRepositoryTest.cs index 77a252a129..4fa212f9bc 100644 --- a/src/Umbraco.Tests/Persistence/Repositories/PublicAccessRepositoryTest.cs +++ b/src/Umbraco.Tests/Persistence/Repositories/PublicAccessRepositoryTest.cs @@ -230,7 +230,7 @@ namespace Umbraco.Tests.Persistence.Repositories var templateRepository = new TemplateRepository(unitOfWork, CacheHelper, Logger, SqlSyntax, Mock.Of(), Mock.Of(), Mock.Of()); var tagRepository = new TagRepository(unitOfWork, CacheHelper, Logger, SqlSyntax); contentTypeRepository = new ContentTypeRepository(unitOfWork, CacheHelper, Logger, SqlSyntax, templateRepository); - var repository = new ContentRepository(unitOfWork, CacheHelper, Logger, SqlSyntax, contentTypeRepository, templateRepository, tagRepository); + var repository = new ContentRepository(unitOfWork, CacheHelper, Logger, SqlSyntax, contentTypeRepository, templateRepository, tagRepository, Mock.Of()); return repository; } diff --git a/src/Umbraco.Tests/Persistence/Repositories/TagRepositoryTest.cs b/src/Umbraco.Tests/Persistence/Repositories/TagRepositoryTest.cs index 93089b6e93..d8232d9aaf 100644 --- a/src/Umbraco.Tests/Persistence/Repositories/TagRepositoryTest.cs +++ b/src/Umbraco.Tests/Persistence/Repositories/TagRepositoryTest.cs @@ -942,7 +942,7 @@ namespace Umbraco.Tests.Persistence.Repositories var templateRepository = new TemplateRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of(), SqlSyntax, Mock.Of(), Mock.Of(), Mock.Of()); var tagRepository = new TagRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of(), SqlSyntax); contentTypeRepository = new ContentTypeRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of(), SqlSyntax, templateRepository); - var repository = new ContentRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of(), SqlSyntax, contentTypeRepository, templateRepository, tagRepository); + var repository = new ContentRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of(), SqlSyntax, contentTypeRepository, templateRepository, tagRepository, Mock.Of()); return repository; } @@ -950,7 +950,7 @@ namespace Umbraco.Tests.Persistence.Repositories { var tagRepository = new TagRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of(), SqlSyntax); mediaTypeRepository = new MediaTypeRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of(), SqlSyntax); - var repository = new MediaRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of(), SqlSyntax, mediaTypeRepository, tagRepository); + var repository = new MediaRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of(), SqlSyntax, mediaTypeRepository, tagRepository, Mock.Of()); return repository; } } diff --git a/src/Umbraco.Tests/Persistence/Repositories/TemplateRepositoryTest.cs b/src/Umbraco.Tests/Persistence/Repositories/TemplateRepositoryTest.cs index 7630e0aaf7..fb76f4402b 100644 --- a/src/Umbraco.Tests/Persistence/Repositories/TemplateRepositoryTest.cs +++ b/src/Umbraco.Tests/Persistence/Repositories/TemplateRepositoryTest.cs @@ -406,7 +406,7 @@ namespace Umbraco.Tests.Persistence.Repositories { var tagRepository = new TagRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of(), SqlSyntax); var contentTypeRepository = new ContentTypeRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of(), SqlSyntax, templateRepository); - var contentRepo = new ContentRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of(), SqlSyntax, contentTypeRepository, templateRepository, tagRepository); + var contentRepo = new ContentRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of(), SqlSyntax, contentTypeRepository, templateRepository, tagRepository, Mock.Of()); using (contentRepo) { diff --git a/src/Umbraco.Tests/Routing/UmbracoModuleTests.cs b/src/Umbraco.Tests/Routing/UmbracoModuleTests.cs index 2eb59aba64..3c3686aded 100644 --- a/src/Umbraco.Tests/Routing/UmbracoModuleTests.cs +++ b/src/Umbraco.Tests/Routing/UmbracoModuleTests.cs @@ -28,7 +28,7 @@ namespace Umbraco.Tests.Routing //create the module _module = new UmbracoModule(); - SettingsForTests.ConfigurationStatus = UmbracoVersion.GetSemanticVersion().ToString(); + SettingsForTests.ConfigurationStatus = UmbracoVersion.GetSemanticVersion().ToSemanticString(); //SettingsForTests.ReservedPaths = "~/umbraco,~/install/"; //SettingsForTests.ReservedUrls = "~/config/splashes/booting.aspx,~/install/default.aspx,~/config/splashes/noNodes.aspx,~/VSEnterpriseHelper.axd"; diff --git a/src/Umbraco.Tests/Scheduling/BackgroundTaskRunnerTests.cs b/src/Umbraco.Tests/Scheduling/BackgroundTaskRunnerTests.cs index b541182de0..e6fc492350 100644 --- a/src/Umbraco.Tests/Scheduling/BackgroundTaskRunnerTests.cs +++ b/src/Umbraco.Tests/Scheduling/BackgroundTaskRunnerTests.cs @@ -525,15 +525,11 @@ namespace Umbraco.Tests.Scheduling var waitHandle = new ManualResetEvent(false); using (var runner = new BackgroundTaskRunner(new BackgroundTaskRunnerOptions(), _logger)) { - runner.TaskCompleted += (sender, args) => runCount++; - runner.TaskStarting += async (sender, args) => + runner.TaskCompleted += (sender, args) => { - //wait for each task to finish once it's started - await sender.CurrentThreadingTask; + runCount++; if (runCount > 3) - { waitHandle.Set(); - } }; var task = new MyRecurringTask(runner, 200, 500); @@ -548,7 +544,10 @@ namespace Umbraco.Tests.Scheduling Assert.GreaterOrEqual(runCount, 4); // stops recurring - runner.Shutdown(false, false); + runner.Shutdown(false, true); + + // check that task has been disposed (timer has been killed, etc) + Assert.IsTrue(task.Disposed); } } @@ -595,15 +594,12 @@ namespace Umbraco.Tests.Scheduling var waitHandle = new ManualResetEvent(false); using (var runner = new BackgroundTaskRunner(new BackgroundTaskRunnerOptions(), _logger)) { - runner.TaskCompleted += (sender, args) => runCount++; - runner.TaskStarting += async (sender, args) => + runner.TaskCompleted += (sender, args) => { - //wait for each task to finish once it's started - await sender.CurrentThreadingTask; + runCount++; if (runCount > 3) - { waitHandle.Set(); - } + }; var task = new MyDelayedRecurringTask(runner, 2000, 1000); @@ -727,37 +723,31 @@ namespace Umbraco.Tests.Scheduling } } - private class MyDelayedRecurringTask : DelayedRecurringTaskBase + private class MyDelayedRecurringTask : RecurringTaskBase { public bool HasRun { get; private set; } - public MyDelayedRecurringTask(IBackgroundTaskRunner runner, int delayMilliseconds, int periodMilliseconds) + public MyDelayedRecurringTask(IBackgroundTaskRunner runner, int delayMilliseconds, int periodMilliseconds) : base(runner, delayMilliseconds, periodMilliseconds) { } - private MyDelayedRecurringTask(MyDelayedRecurringTask source) - : base(source) - { } - public override bool IsAsync { get { return false; } } - public override void PerformRun() + public override bool PerformRun() { HasRun = true; + return true; // repeat } - public override Task PerformRunAsync(CancellationToken token) + public override Task PerformRunAsync(CancellationToken token) { throw new NotImplementedException(); } - protected override MyDelayedRecurringTask GetRecurring() - { - return new MyDelayedRecurringTask(this); - } + public override bool RunsOnShutdown { get { return true; } } } private class MyDelayedTask : ILatchedBackgroundTask @@ -811,29 +801,23 @@ namespace Umbraco.Tests.Scheduling { } } - private class MyRecurringTask : RecurringTaskBase + private class MyRecurringTask : RecurringTaskBase { private readonly int _runMilliseconds; - - public MyRecurringTask(IBackgroundTaskRunner runner, int runMilliseconds, int periodMilliseconds) - : base(runner, periodMilliseconds) + public MyRecurringTask(IBackgroundTaskRunner runner, int runMilliseconds, int periodMilliseconds) + : base(runner, 0, periodMilliseconds) { _runMilliseconds = runMilliseconds; } - private MyRecurringTask(MyRecurringTask source, int runMilliseconds) - : base(source) - { - _runMilliseconds = runMilliseconds; - } - - public override void PerformRun() + public override bool PerformRun() { Thread.Sleep(_runMilliseconds); + return true; // repeat } - public override Task PerformRunAsync(CancellationToken token) + public override Task PerformRunAsync(CancellationToken token) { throw new NotImplementedException(); } @@ -843,10 +827,15 @@ namespace Umbraco.Tests.Scheduling get { return false; } } - protected override MyRecurringTask GetRecurring() + public override bool RunsOnShutdown { get { return false; } } + + protected override void Dispose(bool disposing) { - return new MyRecurringTask(this, _runMilliseconds); + Disposed = true; + base.Dispose(disposing); } + + public bool Disposed { get; private set; } } private class MyTask : BaseTask diff --git a/src/Umbraco.Tests/ServerEnvironmentHelperTests.cs b/src/Umbraco.Tests/ServerEnvironmentHelperTests.cs index 237c6cb17d..a1f71f4f0d 100644 --- a/src/Umbraco.Tests/ServerEnvironmentHelperTests.cs +++ b/src/Umbraco.Tests/ServerEnvironmentHelperTests.cs @@ -1,92 +1,105 @@ using System.Configuration; +using System.IO; using System.Linq; using Moq; using NUnit.Framework; using Umbraco.Core; using Umbraco.Core.Configuration.UmbracoSettings; +using Umbraco.Core.Logging; +using Umbraco.Core.Profiling; using Umbraco.Core.Sync; +using Umbraco.Tests.TestHelpers; namespace Umbraco.Tests { [TestFixture] public class ServerEnvironmentHelperTests { - [Test] - public void Get_Base_Url_Single_Server_Orig_Request_Url_No_SSL() + private ILogger _logger; + + // note: in tests, read appContext._umbracoApplicationUrl and not the property, + // because reading the property does run some code, as long as the field is null. + + [TestFixtureSetUp] + public void InitializeFixture() { - var appContext = new ApplicationContext(null) - { - OriginalRequestUrl = "test.com" - }; - - ConfigurationManager.AppSettings.Set("umbracoUseSSL", "false"); - - var result = ServerEnvironmentHelper.GetCurrentServerUmbracoBaseUrl( - appContext, - Mock.Of( - section => - section.DistributedCall == Mock.Of(callSection => callSection.Servers == Enumerable.Empty()) - && section.ScheduledTasks == Mock.Of())); - - - Assert.AreEqual("http://test.com/", result); + _logger = new Logger(new FileInfo(TestHelper.MapPathForTest("~/unit-test-log4net.config"))); } [Test] - public void Get_Base_Url_Single_Server_Orig_Request_Url_With_SSL() + public void SetApplicationUrlWhenNoSettings() { var appContext = new ApplicationContext(null) { - OriginalRequestUrl = "test.com" + UmbracoApplicationUrl = null // NOT set }; - ConfigurationManager.AppSettings.Set("umbracoUseSSL", "true"); + ConfigurationManager.AppSettings.Set("umbracoUseSSL", "true"); // does not make a diff here - var result = ServerEnvironmentHelper.GetCurrentServerUmbracoBaseUrl( - appContext, + ServerEnvironmentHelper.TrySetApplicationUrlFromSettings(appContext, _logger, Mock.Of( section => section.DistributedCall == Mock.Of(callSection => callSection.Servers == Enumerable.Empty()) + && section.WebRouting == Mock.Of(wrSection => wrSection.UmbracoApplicationUrl == (string) null) && section.ScheduledTasks == Mock.Of())); - Assert.AreEqual("https://test.com/", result); + // still NOT set + Assert.IsNull(appContext._umbracoApplicationUrl); } [Test] - public void Get_Base_Url_Single_Server_Via_Config_Url_No_SSL() + public void SetApplicationUrlFromDcSettingsNoSsl() { var appContext = new ApplicationContext(null); ConfigurationManager.AppSettings.Set("umbracoUseSSL", "false"); - var result = ServerEnvironmentHelper.GetCurrentServerUmbracoBaseUrl( - appContext, + ServerEnvironmentHelper.TrySetApplicationUrlFromSettings(appContext, _logger, Mock.Of( section => section.DistributedCall == Mock.Of(callSection => callSection.Servers == Enumerable.Empty()) - && section.ScheduledTasks == Mock.Of(tasksSection => tasksSection.BaseUrl == "mycoolhost.com/hello/world"))); + && section.WebRouting == Mock.Of(wrSection => wrSection.UmbracoApplicationUrl == (string) null) + && section.ScheduledTasks == Mock.Of(tasksSection => tasksSection.BaseUrl == "mycoolhost.com/hello/world/"))); - Assert.AreEqual("http://mycoolhost.com/hello/world/", result); + Assert.AreEqual("http://mycoolhost.com/hello/world", appContext._umbracoApplicationUrl); } [Test] - public void Get_Base_Url_Single_Server_Via_Config_Url_With_SSL() + public void SetApplicationUrlFromDcSettingsSsl() { var appContext = new ApplicationContext(null); ConfigurationManager.AppSettings.Set("umbracoUseSSL", "true"); - var result = ServerEnvironmentHelper.GetCurrentServerUmbracoBaseUrl( - appContext, + ServerEnvironmentHelper.TrySetApplicationUrlFromSettings(appContext, _logger, Mock.Of( section => section.DistributedCall == Mock.Of(callSection => callSection.Servers == Enumerable.Empty()) + && section.WebRouting == Mock.Of(wrSection => wrSection.UmbracoApplicationUrl == (string) null) && section.ScheduledTasks == Mock.Of(tasksSection => tasksSection.BaseUrl == "mycoolhost.com/hello/world"))); - Assert.AreEqual("https://mycoolhost.com/hello/world/", result); + Assert.AreEqual("https://mycoolhost.com/hello/world", appContext._umbracoApplicationUrl); + } + + [Test] + public void SetApplicationUrlFromWrSettingsSsl() + { + var appContext = new ApplicationContext(null); + + ConfigurationManager.AppSettings.Set("umbracoUseSSL", "true"); // does not make a diff here + + ServerEnvironmentHelper.TrySetApplicationUrlFromSettings(appContext, _logger, + Mock.Of( + section => + section.DistributedCall == Mock.Of(callSection => callSection.Servers == Enumerable.Empty()) + && section.WebRouting == Mock.Of(wrSection => wrSection.UmbracoApplicationUrl == "httpx://whatever.com/hello/world/") + && section.ScheduledTasks == Mock.Of(tasksSection => tasksSection.BaseUrl == "mycoolhost.com/hello/world"))); + + + Assert.AreEqual("httpx://whatever.com/hello/world", appContext._umbracoApplicationUrl); } } } \ No newline at end of file diff --git a/src/Umbraco.Tests/Services/ContentServicePerformanceTest.cs b/src/Umbraco.Tests/Services/ContentServicePerformanceTest.cs index 4a26d917e1..316d957a0c 100644 --- a/src/Umbraco.Tests/Services/ContentServicePerformanceTest.cs +++ b/src/Umbraco.Tests/Services/ContentServicePerformanceTest.cs @@ -151,7 +151,7 @@ namespace Umbraco.Tests.Services using (var tRepository = new TemplateRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Logger, SqlSyntax, Mock.Of(), Mock.Of(), Mock.Of())) using (var tagRepo = new TagRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Logger, SqlSyntax)) using (var ctRepository = new ContentTypeRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Logger, SqlSyntax, tRepository)) - using (var repository = new ContentRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Logger, SqlSyntax, ctRepository, tRepository, tagRepo)) + using (var repository = new ContentRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Logger, SqlSyntax, ctRepository, tRepository, tagRepo, Mock.Of())) { // Act Stopwatch watch = Stopwatch.StartNew(); @@ -182,7 +182,7 @@ namespace Umbraco.Tests.Services using (var tRepository = new TemplateRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Logger, SqlSyntax, Mock.Of(), Mock.Of(), Mock.Of())) using (var tagRepo = new TagRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Logger, SqlSyntax)) using (var ctRepository = new ContentTypeRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Logger, SqlSyntax, tRepository)) - using (var repository = new ContentRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Logger, SqlSyntax, ctRepository, tRepository, tagRepo)) + using (var repository = new ContentRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Logger, SqlSyntax, ctRepository, tRepository, tagRepo, Mock.Of())) { // Act Stopwatch watch = Stopwatch.StartNew(); @@ -212,7 +212,7 @@ namespace Umbraco.Tests.Services using (var tRepository = new TemplateRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Logger, SqlSyntax, Mock.Of(), Mock.Of(), Mock.Of())) using (var tagRepo = new TagRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Logger, SqlSyntax)) using (var ctRepository = new ContentTypeRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Logger, SqlSyntax, tRepository)) - using (var repository = new ContentRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Logger, SqlSyntax, ctRepository, tRepository, tagRepo)) + using (var repository = new ContentRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Logger, SqlSyntax, ctRepository, tRepository, tagRepo, Mock.Of())) { // Act @@ -245,7 +245,7 @@ namespace Umbraco.Tests.Services using (var tRepository = new TemplateRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Logger, SqlSyntax, Mock.Of(), Mock.Of(), Mock.Of())) using (var tagRepo = new TagRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Logger, SqlSyntax)) using (var ctRepository = new ContentTypeRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Logger, SqlSyntax, tRepository)) - using (var repository = new ContentRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Logger, SqlSyntax, ctRepository, tRepository, tagRepo)) + using (var repository = new ContentRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Logger, SqlSyntax, ctRepository, tRepository, tagRepo, Mock.Of())) { // Act diff --git a/src/Umbraco.Tests/Services/ContentServiceTests.cs b/src/Umbraco.Tests/Services/ContentServiceTests.cs index f2f858ec26..176db015f8 100644 --- a/src/Umbraco.Tests/Services/ContentServiceTests.cs +++ b/src/Umbraco.Tests/Services/ContentServiceTests.cs @@ -1550,7 +1550,7 @@ namespace Umbraco.Tests.Services var templateRepository = new TemplateRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of(), SqlSyntax, Mock.Of(), Mock.Of(), Mock.Of()); var tagRepository = new TagRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of(), SqlSyntax); contentTypeRepository = new ContentTypeRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of(), SqlSyntax, templateRepository); - var repository = new ContentRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of(), SqlSyntax, contentTypeRepository, templateRepository, tagRepository); + var repository = new ContentRepository(unitOfWork, CacheHelper.CreateDisabledCacheHelper(), Mock.Of(), SqlSyntax, contentTypeRepository, templateRepository, tagRepository, Mock.Of()); return repository; } } diff --git a/src/Umbraco.Tests/Services/LocalizationServiceTests.cs b/src/Umbraco.Tests/Services/LocalizationServiceTests.cs index 40597dc285..fd0fd1437d 100644 --- a/src/Umbraco.Tests/Services/LocalizationServiceTests.cs +++ b/src/Umbraco.Tests/Services/LocalizationServiceTests.cs @@ -179,7 +179,7 @@ namespace Umbraco.Tests.Services Assert.Greater(item.Id, 0); Assert.IsTrue(item.HasIdentity); - Assert.AreEqual(new Guid(Constants.Conventions.Localization.DictionaryItemRootId), item.ParentId); + Assert.IsFalse(item.ParentId.HasValue); Assert.AreEqual("Testing123", item.ItemKey); Assert.AreEqual(1, item.Translations.Count()); } @@ -197,7 +197,7 @@ namespace Umbraco.Tests.Services Assert.IsNotNull(item); Assert.Greater(item.Id, 0); Assert.IsTrue(item.HasIdentity); - Assert.AreEqual(new Guid(Constants.Conventions.Localization.DictionaryItemRootId), item.ParentId); + Assert.IsFalse(item.ParentId.HasValue); Assert.AreEqual("Testing12345", item.ItemKey); var allLangs = ServiceContext.LocalizationService.GetAllLanguages(); Assert.Greater(allLangs.Count(), 0); diff --git a/src/Umbraco.Tests/TestHelpers/BaseDatabaseFactoryTest.cs b/src/Umbraco.Tests/TestHelpers/BaseDatabaseFactoryTest.cs index d94fc24168..70eac1b07d 100644 --- a/src/Umbraco.Tests/TestHelpers/BaseDatabaseFactoryTest.cs +++ b/src/Umbraco.Tests/TestHelpers/BaseDatabaseFactoryTest.cs @@ -97,7 +97,7 @@ namespace Umbraco.Tests.TestHelpers InitializeDatabase(); //ensure the configuration matches the current version for tests - SettingsForTests.ConfigurationStatus = UmbracoVersion.GetSemanticVersion().ToString(); + SettingsForTests.ConfigurationStatus = UmbracoVersion.GetSemanticVersion().ToSemanticString(); } } diff --git a/src/Umbraco.Tests/TestHelpers/Entities/MockedContentTypes.cs b/src/Umbraco.Tests/TestHelpers/Entities/MockedContentTypes.cs index 356abe65b2..0eeb79af4e 100644 --- a/src/Umbraco.Tests/TestHelpers/Entities/MockedContentTypes.cs +++ b/src/Umbraco.Tests/TestHelpers/Entities/MockedContentTypes.cs @@ -1,4 +1,5 @@ using System; +using System.Linq; using Umbraco.Core; using Umbraco.Core.Models; @@ -181,11 +182,24 @@ namespace Umbraco.Tests.TestHelpers.Entities contentCollection.Add(new PropertyType(Constants.PropertyEditors.TinyMCEAlias, DataTypeDatabaseType.Ntext) { Alias = RandomAlias("bodyText", randomizeAliases), Name = "Body Text", Description = "", Mandatory = false, SortOrder = 2, DataTypeDefinitionId = -87 }); contentCollection.Add(new PropertyType(Constants.PropertyEditors.TextboxAlias, DataTypeDatabaseType.Ntext) { Alias = RandomAlias("author", randomizeAliases) , Name = "Author", Description = "Name of the author", Mandatory = false, SortOrder = 3, DataTypeDefinitionId = -88 }); - contentType.PropertyGroups.Add(new PropertyGroup(contentCollection) { Name = propertyGroupName, SortOrder = 1 }); + var pg = new PropertyGroup(contentCollection) {Name = propertyGroupName, SortOrder = 1}; + contentType.PropertyGroups.Add(pg); + + if (parent != null) + { + var foundPg = parent.PropertyGroups.FirstOrDefault(x => x.Name == propertyGroupName); + if (foundPg != null) + { + //this exists on the parent, so set the parent id + pg.ParentId = foundPg.Id; + } + } //ensure that nothing is marked as dirty contentType.ResetDirtyProperties(false); + contentType.SetDefaultTemplate(new Template("Textpage", "textpage")); + return contentType; } @@ -399,6 +413,21 @@ namespace Umbraco.Tests.TestHelpers.Entities return contentType; } + public static void EnsureAllIds(ContentType contentType, int seedId) + { + //ensure everything has ids + contentType.Id = seedId; + var itemid = seedId + 1; + foreach (var propertyGroup in contentType.PropertyGroups) + { + propertyGroup.Id = itemid++; + } + foreach (var propertyType in contentType.PropertyTypes) + { + propertyType.Id = itemid++; + } + } + private static string RandomAlias(string alias, bool randomizeAliases) { if (randomizeAliases) diff --git a/src/Umbraco.Tests/Umbraco.Tests.csproj b/src/Umbraco.Tests/Umbraco.Tests.csproj index bc278b1bfa..517bfacc25 100644 --- a/src/Umbraco.Tests/Umbraco.Tests.csproj +++ b/src/Umbraco.Tests/Umbraco.Tests.csproj @@ -178,6 +178,9 @@ + + + @@ -446,7 +449,7 @@ - + diff --git a/src/Umbraco.Web.UI.Client/src/views/content/content.delete.controller.js b/src/Umbraco.Web.UI.Client/src/views/content/content.delete.controller.js index be27f3a663..d7ff1843c7 100644 --- a/src/Umbraco.Web.UI.Client/src/views/content/content.delete.controller.js +++ b/src/Umbraco.Web.UI.Client/src/views/content/content.delete.controller.js @@ -31,7 +31,13 @@ function ContentDeleteController($scope, contentResource, treeService, navigatio //if the current edited item is the same one as we're deleting, we need to navigate elsewhere if (editorState.current && editorState.current.id == $scope.currentNode.id) { - $location.path("/content/content/edit/" + $scope.currentNode.parentId); + + //If the deleted item lived at the root then just redirect back to the root, otherwise redirect to the item's parent + var location = "/content"; + if ($scope.currentNode.parentId.toString() !== "-1") + location = "/content/content/edit/" + $scope.currentNode.parentId; + + $location.path(location); } navigationService.hideMenu(); diff --git a/src/Umbraco.Web.UI.Client/src/views/media/media.delete.controller.js b/src/Umbraco.Web.UI.Client/src/views/media/media.delete.controller.js index eab7bbe4ad..350821d975 100644 --- a/src/Umbraco.Web.UI.Client/src/views/media/media.delete.controller.js +++ b/src/Umbraco.Web.UI.Client/src/views/media/media.delete.controller.js @@ -31,7 +31,13 @@ function MediaDeleteController($scope, mediaResource, treeService, navigationSer //if the current edited item is the same one as we're deleting, we need to navigate elsewhere if (editorState.current && editorState.current.id == $scope.currentNode.id) { - $location.path("/media/media/edit/" + $scope.currentNode.parentId); + + //If the deleted item lived at the root then just redirect back to the root, otherwise redirect to the item's parent + var location = "/media"; + if ($scope.currentNode.parentId.toString() !== "-1") + location = "/media/media/edit/" + $scope.currentNode.parentId; + + $location.path(location); } navigationService.hideMenu(); diff --git a/src/Umbraco.Web.UI.Client/src/views/propertyeditors/datepicker/datepicker.controller.js b/src/Umbraco.Web.UI.Client/src/views/propertyeditors/datepicker/datepicker.controller.js index 4e540eb5fa..1fa210a19f 100644 --- a/src/Umbraco.Web.UI.Client/src/views/propertyeditors/datepicker/datepicker.controller.js +++ b/src/Umbraco.Web.UI.Client/src/views/propertyeditors/datepicker/datepicker.controller.js @@ -135,18 +135,20 @@ function dateTimePickerController($scope, notificationsService, assetsService, a $scope.model.value = null; } }); + //unbind doc click event! + $scope.$on('$destroy', function () { + unsubscribe(); + }); }); }); }); - //unbind doc click event! $scope.$on('$destroy', function () { $(document).unbind("click", $scope.hidePicker); - unsubscribe(); }); } diff --git a/src/Umbraco.Web.UI/Umbraco.Web.UI.csproj b/src/Umbraco.Web.UI/Umbraco.Web.UI.csproj index e2b2d7b924..ed269cddde 100644 --- a/src/Umbraco.Web.UI/Umbraco.Web.UI.csproj +++ b/src/Umbraco.Web.UI/Umbraco.Web.UI.csproj @@ -114,9 +114,9 @@ False ..\packages\AutoMapper.3.3.1\lib\net40\AutoMapper.Net4.dll - + False - ..\packages\ClientDependency.1.8.3.1\lib\net45\ClientDependency.Core.dll + ..\packages\ClientDependency.1.8.4\lib\net45\ClientDependency.Core.dll False @@ -151,12 +151,12 @@ ..\packages\Lucene.Net.2.9.4.1\lib\net40\Lucene.Net.dll - ..\packages\Microsoft.AspNet.Identity.Core.2.2.0\lib\net45\Microsoft.AspNet.Identity.Core.dll + ..\packages\Microsoft.AspNet.Identity.Core.2.2.1\lib\net45\Microsoft.AspNet.Identity.Core.dll True False - ..\packages\Microsoft.AspNet.Identity.Owin.2.2.0\lib\net45\Microsoft.AspNet.Identity.Owin.dll + ..\packages\Microsoft.AspNet.Identity.Owin.2.2.1\lib\net45\Microsoft.AspNet.Identity.Owin.dll diff --git a/src/Umbraco.Web.UI/config/ClientDependency.config b/src/Umbraco.Web.UI/config/ClientDependency.config index 7269594985..456473e07d 100644 --- a/src/Umbraco.Web.UI/config/ClientDependency.config +++ b/src/Umbraco.Web.UI/config/ClientDependency.config @@ -10,7 +10,7 @@ NOTES: * Compression/Combination/Minification is not enabled unless debug="false" is specified on the 'compiliation' element in the web.config * A new version will invalidate both client and server cache and create new persisted files --> - + diff --git a/src/Umbraco.Web.UI/config/log4net.config b/src/Umbraco.Web.UI/config/log4net.config index 0a0e9e4ff7..497fd4471f 100644 --- a/src/Umbraco.Web.UI/config/log4net.config +++ b/src/Umbraco.Web.UI/config/log4net.config @@ -6,19 +6,22 @@ - - + - + + + + + diff --git a/src/Umbraco.Web.UI/packages.config b/src/Umbraco.Web.UI/packages.config index 12afdc860d..8ba6906e86 100644 --- a/src/Umbraco.Web.UI/packages.config +++ b/src/Umbraco.Web.UI/packages.config @@ -1,7 +1,7 @@  - + @@ -9,8 +9,8 @@ - - + + diff --git a/src/Umbraco.Web.UI/umbraco/config/lang/de.xml b/src/Umbraco.Web.UI/umbraco/config/lang/de.xml index 92e76f26a7..c6f87964e7 100644 --- a/src/Umbraco.Web.UI/umbraco/config/lang/de.xml +++ b/src/Umbraco.Web.UI/umbraco/config/lang/de.xml @@ -8,6 +8,7 @@ Hostnamen verwalten Protokoll Durchsuchen + Dokumententyp ändern Kopieren Erstellen Paket erstellen @@ -23,6 +24,7 @@ Benachrichtigungen Öffentlicher Zugriff Veröffentlichen + Veröffentlichung zurück nehmen Aktualisieren Erneut veröffentlichen Berechtigungen @@ -33,33 +35,39 @@ Zur Veröffentlichung einreichen Übersetzen Aktualisieren - Veröffentlichung zurücknehmen + Standard Wert + Zugriff verweigert Neue Domain hinzufügen + Entfernen + Ungültiges Element + Format der Domain ungültig + Die Domain ist bereits zugeordnet + Sprache Domain Domain '%0%' hinzugefügt Domain '%0%' entfernt Die Domain '%0%' ist bereits zugeordnet - Beispiel: example.com, www.example.com Domain '%0%' aktualisiert Domains bearbeiten - Erlaubnis verweigert. - entfernen - Ungültiges Element. - Format der Domain ungültig. - Domain wurde bereits zugewiesen. - Sprache +
1-Level Pfade in Domains werden unterstützt, z.B. "example.com/en". Diese sollten aber nach Möglichkeit vermieden werden. Besser sollten + die Sprachkultur-Einstellungen verwendet werden.]]> Vererben - Kultur - Domains - Definiert die Kultureinstellung für untergeordnete Elemente dieses Elements oder vererbt vom übergeordneten Element. Wird auch auf das aktuelle Element angewendet, sofern auf tieferer Ebene keine Domain zugeordnet ist. - + Sprachkultur + Definiert die Sprachkultureinstellung für untergeordnete Elemente dieses Elements oder vererbt vom übergeordneten Element. Wird auch auf das aktuelle Element angewendet, sofern auf tieferer Ebene keine Domain zugeordnet ist. + + Domains + Ansicht für - Fett + Auswählen + Verzeichnis wählen + Etwas anders machen + Fett Ausrücken Formularelement einfügen Graphische Überschrift einfügen @@ -74,34 +82,59 @@ Aufzählung Nummerierung Makro einfügen - Abbildung einfügen + Bild einfügen Datenbeziehungen bearbeiten + Zürück zur Übersicht Speichern Speichern und veröffentlichen Speichern und zur Abnahme übergeben Vorschau + Die Vorschaufunktion ist deaktiviert, da keine Vorlage zugewiesen ist Stil auswählen Stil anzeigen Tabelle einfügen - Die Vorschaufunktion ist deaktiviert, da keine Vorlage zugewiesen ist - Auswählen - Etwas anders machen + + + Um einen Dokumententyp zu ändern muss zunächst ein gültiger Dokumententyp in der Liste für diesen Inhalt ausgewählt werden. + Danach muss die Zuweisung der Eigenschaften vom aktuellen zum neuen Dokumententyp bestätigt und/oder geändert werden und auf Speichern geklickt werden. + Der Inhalt wurde neu veröffentlicht. + Aktuelle Eigenschaft + Aktueller Doumententyp + Der Dokumententyp kann nicht geändert werden, da es keine alternativen gültigen Eigenschaften für dieses Dokument gibt. Eine Alternative wird gültig sein, wenn es unter dem übergeordenten Knoten des ausgewählten Dokuments erlaubt ist und alle bestehenden untergeordneten Dokumente unter diesem erstellt werden dürfen. + Dokumententyp ändern + Eigenschaften zuweisen + Zu Eigenschaft zuweisen + Neue Vorlage + Neue Eigenschaft + keine + Inhalt + Neuen Dokumententyp auswählen + Der Dokumententyp des ausgewählten Dokuments wurde erfolgreich geändert zu [new type] und zu folgenden Eigenschaften zugewiesen: + zu + Zuweisung der Eigenschaft konnte nicht abgeschlossen werden, weil es eine oder mehr Eigenschaften mehr gibt als für eine Zuweisung definiert wurden. + Nur wecheselnde Eigenschaften sind gültig für das aktuell angezeigte Dokument. + Ist veröffentlicht Über dieses Dokument Alias (Wie würden Sie das Bild über das Telefon beschreiben?) Alternative Links Klicken, um das Dokument zu bearbeiten Erstellt von + Ursprünglicher Author + Geändert von Erstellt am + Erstellungszeitpunkt des Dokuments Dokumenttyp In Bearbeitung Veröffentlichung aufheben am Dieses Dokument wurde nach dem Veröffentlichen bearbeitet. Dieses Dokument ist nicht veröffentlicht. Zuletzt veröffentlicht + Es gibt keine anzeigbaren Elemente in dieser Liste. Medientyp + Link zu Medienobjekt(en) Mitgliedergruppe Mitgliederrolle Mitglieder-Typ @@ -109,29 +142,31 @@ Name des Dokument Eigenschaften Dieses Dokument ist veröffentlicht aber nicht sichtbar, da das übergeordnete Dokument '%0%' nicht publiziert ist + Ups! Dieses Dokument ist veröffentlicht, aber befindet sich nicht im internen Cache (Systemfehler) Veröffentlichen Publikationsstatus Veröffentlichen am + Veröffentlichung aufheben am Datum entfernen Sortierung abgeschlossen Um die Dokumente zu sortieren, ziehen Sie sie einfach an die gewünschte Position. Sie können mehrere Zeilen markieren indem Sie die Umschalttaste ("Shift") oder die Steuerungstaste ("Strg") gedrückt halten Statistiken Titel (optional) + Alternativer Text (optional) Typ - Ausblenden + Veröffentlichung zurück nehmen Zuletzt bearbeitet am + Letzter Änderungszeitpunkt des Dokuments Datei entfernen Link zum Dokument - Verweis auf Medienobjekt(e) - Ups! Dieses Dokument ist veröffentlicht aber nicht im internen Cache aufzufinden: Systemfehler. - Ursprünglicher Autor - Aktualisiert von - Erstellungszeitpunkt des Dokuments - Veröffentlichung widerrufen am - Letzter Änderungszeitpunkt des Dokuments Mitglied der Gruppe(n) Kein Mitglied der Gruppe(n) Untergeordnete Elemente + Ziel + + + Klicken zum Hochladen + Dateien hierher ziehen... An welcher Stellen wollen Sie das Element erstellen @@ -197,10 +232,24 @@ Bearbeiten Sie nachfolgend die verschiedenen Sprachversionen für den Wörterbucheintrag '<em>%0%</em>'. <br/>Unter dem links angezeigten Menüpunkt 'Sprachen' können Sie weitere hinzufügen. - Name der Kultur + Name der Sprachkultur + + + + +Benutzername eingeben + Passwort eingeben + Benenne %0%... + Name eingeben... + Suchbegriff eingeben... + Tippen zum Filtern... + Tippen für Schlagworte hinzuzufügen (drücke Enter nach jedem Schlagwort)... + Als Wurzel-Knoten erlauben + Nur Dokumententype mit dieser Markierung können auf Ebene 1 im Inhalts- und Medienverzeichnisbaum erstellt werden Dokumenttypen, die unterhalb dieses Typs erlaubt sind + Dokumententyp-Kompositionen Erstellen Registerkarte löschen Beschreibung @@ -208,6 +257,11 @@ Registerkarte Illustration Listenansicht aktivieren + Konfiguriert das Dokument zur Darstellung einer sortierbaren und durchsuchbaren Liste mit untergeordneten Dokumenten. Die untergeordneten Elemente werden im Verzeichnisbaum nicht mehr angezeigt. + Aktuelle Listenansicht + Datentyp der aktiven Listenansicht + Erstelle benutzerdefinierte Listenansicht + Entferne benutzerdefinierte Listenansicht Vorgabewert hinzufügen @@ -256,6 +310,7 @@ Info Aktion + Aktionen Hinzufügen Alias Sind Sie sicher? @@ -305,6 +360,7 @@ Abmelden Makro Verschieben + Mehr Name Neu Weiter @@ -324,6 +380,7 @@ Verbleibend Umbenennen Erneuern + Pflichtangaben Wiederholen Berechtigungen Suchen @@ -347,11 +404,11 @@ Breite Ja Ordner - Aktionen - Mehr - Pflichtangabe Suchergebnisse + + + Hintergrundfarbe Fett @@ -381,7 +438,7 @@ Keine Sorge - Dabei werden keine Inhalte gelöscht und alles wird weiterhin funktionieren! </p> - Die Datenbank wurde auf die Version %0% aktualisiert. Klicken Sie auf <strong>weiter</strong>, um fortzufahren. +Die Datenbank wurde auf die Version %0% aktualisiert. Klicken Sie auf <strong>weiter</strong>, um fortzufahren. Die Datenbank ist fertig eingerichtet. Klicken Sie auf <strong>"weiter"</strong>, um mit der Einrichtung fortzufahren. <strong>Das Kennwort des Standard-Benutzers muss geändert werden!</strong> <strong>Der Standard-Benutzer wurde deaktiviert oder hat keinen Zugriff auf Umbraco.</strong></p><p>Es sind keine weiteren Aktionen notwendig. Klicken Sie auf <b>Weiter</b> um fortzufahren. @@ -457,26 +514,27 @@ Wenn Sie sich für Runway entscheiden, können Sie optional Blöcke nutzen, die Dieser Assistent führt Sie durch die Einrichtung einer neuen Installation von <strong>Umbraco %0%</strong> oder einem Upgrade von Version 3.0.<br /><br />Klicken Sie auf <strong>weiter</strong>, um zu beginnen. - Code der Kultur - Name der Kultur + Code der Sprachkultur + Name der Sprachkultur Sie haben keine Tätigkeiten mehr durchgeführt und werden automatisch abgemeldet in Erneuern Sie, um Ihre Arbeit zu speichern ... - <p style="text-align:right;">&copy; 2001 - %0% <br /><a href="http://umbraco.com" style="text-decoration: none" target="_blank">umbraco.org</a></p> - Einen wunderbaren Sonntag - Frohen freundlichen Freitag - Donnerwetter Donnerstag - Schönen Montag - Einen großartigen Dienstag - Wunderbaren Mittwoch - Wunderbaren sonnigen Samstag + Einen wunderbaren Sonntag + Frohen freundlichen Freitag + Donnerwetter Donnerstag + Schönen Montag + Einen großartigen Dienstag + Wunderbaren Mittwoch + Wunderbaren sonnigen Samstag Hier anmelden: + Die Sitzung ist abgelaufen + <p style="text-align:right;">&copy; 2001 - %0% <br /><a href="http://umbraco.com" style="text-decoration: none" target="_blank">umbraco.org</a></p> - Dashboard + Armaturenbrett Bereiche Inhalt @@ -507,30 +565,33 @@ Wenn Sie sich für Runway entscheiden, können Sie optional Blöcke nutzen, die Ihr freundlicher Umbraco-Robot -<p>Hallo %0%,</p> +Hi %0%

-<p>die Aufgabe <strong>'%1%'</strong> (von Benutzer '%3%') an der Seite <a href="http://%4%/actions/preview.aspx?id=%5%"><strong>'%2%'</strong></a> wurde ausgeführt.</p> -<div style="margin: 8px 0; padding: 8px; display: block;"> - <br /> - <a style="color: white; font-weight: bold; background-color: #66cc66; text-decoration : none; margin-right: 20px; border: 8px solid #66cc66; width: 150px;" href="http://%4%/Umbraco/actions/publish.aspx?id=%5%">&nbsp;&nbsp;VERÖFFENTLICHEN&nbsp;&nbsp;</a> &nbsp; - <a style="color: white; font-weight: bold; background-color: #5372c3; text-decoration : none; margin-right: 20px; border: 8px solid #5372c3; width: 150px;" href="http://%4%/Umbraco/actions/editContent.aspx?id=%5%">&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;BEARBEITEN&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;</a> &nbsp; - <a style="color: white; font-weight: bold; background-color: #ca4a4a; text-decoration : none; margin-right: 20px; border: 8px solid #ca4a4a; width: 150px;" href="http://%4%/Umbraco/actions/delete.aspx?id=%5%">&nbsp;&nbsp;&nbsp;&nbsp;LÖSCHEN&nbsp;&nbsp;&nbsp;&nbsp;</a> - <br /> -</div> -<p> - <h3>Zusammenfassung der Aktualisierung:</h3> - <table style="width: 100%;"> - %6% - </table> - </p> -<div style="margin: 8px 0; padding: 8px; display: block;"> - <br /> - <a style="color: white; font-weight: bold; background-color: #66cc66; text-decoration : none; margin-right: 20px; border: 8px solid #66cc66; width: 150px;" href="http://%4%/Umbraco/actions/publish.aspx?id=%5%">&nbsp;&nbsp;VERÖFFENTLICHEN&nbsp;&nbsp;</a> &nbsp; - <a style="color: white; font-weight: bold; background-color: #5372c3; text-decoration : none; margin-right: 20px; border: 8px solid #5372c3; width: 150px;" href="http://%4%/Umbraco/actions/editContent.aspx?id=%5%">&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;BEARBEITEN&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;</a> &nbsp; - <a style="color: white; font-weight: bold; background-color: #ca4a4a; text-decoration : none; margin-right: 20px; border: 8px solid #ca4a4a; width: 150px;" href="http://%4%/Umbraco/actions/delete.aspx?id=%5%">&nbsp;&nbsp;&nbsp;&nbsp;LÖSCHEN&nbsp;&nbsp;&nbsp;&nbsp;</a> - <br /> -</div> -<p>Einen schönen Tag wünscht<br />Ihr freundlicher Umbraco-Robot</p> +

Dies ist eine automatisch E-Mail, welche Sie informiert, dass die Aufgabe '%1%' + an der Seite '%2%' + vom Benutzer '%3%' ausgeführt wurde. +

+ +

+

Zusammenfassung der Aktualisierung:

+ + %6% +
+

+ + + +

Einen schönen Tag wünscht

+ Ihr freundlicher Umbraco-Robot +

]]> [%0%] Benachrichtigung: %1% ausgeführt an Seite '%2%' Benachrichtigungen @@ -599,17 +660,17 @@ Wenn Sie sich für Runway entscheiden, können Sie optional Blöcke nutzen, die %0% kann nicht veröffentlicht werden, da die Veröffentlichung zeitlich geplant ist. - Neuer externer Link - Neuer interner Link - Link hinzufügen + Externer Link eingeben + Interne Seite auswählen + Link hinzufügen Beschriftung - interne Seite - URL - nach unten - nach oben - In neuem Fenster öffnen - Link entfernen - + In neuem Fenster öffnen + Neue Beschriftung eingeben + Link eingeben + + + Zurücksetzen + Aktuelle Version Zeigt die Unterschiede zwischen der aktuellen und der ausgewählten Version an.<br />Text in <del>rot</del> fehlen in der ausgewählten Version, <ins>grün</ins> markierter Text wurde hinzugefügt. @@ -635,8 +696,9 @@ Wenn Sie sich für Runway entscheiden, können Sie optional Blöcke nutzen, die Statistiken Übersetzung Benutzer - Umbraco Contour + Umbraco Forms Hilfe + Analytics Standardvorlage @@ -647,6 +709,7 @@ Wenn Sie sich für Runway entscheiden, können Sie optional Blöcke nutzen, die Typ Stylesheet Stylesheet-Eigenschaft + Skript Registerkarte Registerkartenbeschriftung Registerkarten @@ -654,6 +717,8 @@ Wenn Sie sich für Runway entscheiden, können Sie optional Blöcke nutzen, die Masterdokumenttyp aktiviert als Masterdokumenttyp. Register vom Masterdokumenttyp werden nicht angezeigt und können nur im Masterdokumenttyp selbst bearbeitet werden Für dieses Register sind keine Eigenschaften definiert. Klicken Sie oben auf "neue Eigenschaft hinzufügen", um eine neue Eigenschaft hinzuzufügen. + Master Dokumententyp + Erstelle zugehörige Vorlage Sortierung abgeschlossen. @@ -734,7 +799,63 @@ Wenn Sie sich für Runway entscheiden, können Sie optional Blöcke nutzen, die Schnellübersicht zu den verfügbaren Umbraco-Feldern Vorlage - + + Typ auswählen + Wählen Sie ein Layout für diese Seite + und fügen Sie ihr erstes Element hinzu.]]> + + Klicken zum Einfügen + Klicken zum Bild Einfügen + Bildbeschriftung... + Schreibe hier... + + Grid Layouts + Layouts sind der gesamte Arbeitsbereich des Grid Editors. Sie brauchen aber meistens nur ein oder zwei unterschiedliche Layouts. + Grid Layout hinzufügen + Layout einstellen (Spaltenbreite festlegen und zusätzliche Bereiche hinzufügen) + + Zeilenkonfiguration + Zeilen sind vordefinierte und horizontal angeordnete Zellen + Zeilenkonfiguration hinzufügen + Zeilen einstellen (Zellenbreite festlegen und zusätzliche Zellen hinzufügen) + + Spalten + Gesamtanzahl von allen kombinierten Spalten im Grid Layout + + Einstellungen + Konfiguriere, welche Einstellungen der Editor ändern kann + + + Stilangaben + Konfiguriere, welche Stilangaben Editoren ändern können + + Einstellungen werden nur mit eingetragener und gültiger JSON Konfiguration gespeichert + + Allen Editoren erlauben + Alle Zeilenkonfigurationen erlauben + + + + + + + + + + + + + + + + + + + + + + + Alternatives Feld Alternativer Text Groß- und Kleinschreibung @@ -820,7 +941,7 @@ Ihr freundlicher Umbraco-Robot Mitgliedergruppen Mitgliederrollen Mitglieder-Typen - Dokumenttypen + Dokumententypen Pakete Pakete Python-Dateien @@ -832,6 +953,7 @@ Ihr freundlicher Umbraco-Robot Stylesheets Vorlagen XSLT-Dateien + Analysen Neues Update verfügbar @@ -842,7 +964,9 @@ Ihr freundlicher Umbraco-Robot Administrator Feld für Kategorie - Kennwort ändern + Passwort ändern + Neues Passwort + Neues Kennwort (Bestätigung) Sie können Ihr Kennwort für den Zugriff auf den Umbraco-Verwaltungsbereich ändern, indem Sie das nachfolgende Formular ausfüllen und auf die 'Kennwort ändern'-Schaltfläche klicken Schnittstelle für externe Editoren Feld für Beschreibung @@ -856,7 +980,9 @@ Ihr freundlicher Umbraco-Robot Freigegebene Bereiche Zugang sperren Kennwort + Kennwort zurücksetzen Ihr Kennwort wurde geändert! + Bitte bestätigen Sie das neue Kennwort Aktuelle Kennwort Ungültig aktuelle Kennwort Geben Sie Ihr neues Kennwort ein @@ -873,10 +999,7 @@ Ihr freundlicher Umbraco-Robot Rolle Rollen Autor - Neues Kennwort - Neues Kennwort (Bestätigung) - Bitte bestätigen Sie das neue Kennwort - Kennwort zurücksetzen + Übersetzer Ihr Profil Ihr Verlauf Sitzung läuft ab in diff --git a/src/Umbraco.Web.UI/umbraco/config/lang/ja.xml b/src/Umbraco.Web.UI/umbraco/config/lang/ja.xml index cd0bfe03d7..237f0cc4b3 100644 --- a/src/Umbraco.Web.UI/umbraco/config/lang/ja.xml +++ b/src/Umbraco.Web.UI/umbraco/config/lang/ja.xml @@ -8,6 +8,7 @@ ドメインの割り当て 動作記録 ノードの参照 + ドキュメントタイプの変更 コピー 新規作成 パッケージの作成 @@ -26,6 +27,7 @@ 公開を止める 最新の情報に更新 サイトのリフレッシュ + 復元 アクセス権 以前の版に戻る 公開に送る @@ -34,22 +36,35 @@ 公開する 翻訳 更新 + 初期値 + アクセスが拒否されました ドメインの割り当て + ドメインの削除 + 適当でないノード名 適当でないホスト名 + そのホスト名は既に利用されています + 言語コード ドメイン ドメイン '%0%' が新たに割り当てられました ドメイン '%0%' は削除されました ドメイン '%0%' は既に割り当てられています - 例: yourdomain.com, www.yourdomain.com ドメイン '%0%' は更新されました ドメインの編集 + + Inherit + カルチャの割り当て + + ドメインの割り当て これらを表示 + 選択 + 現在のフォルダを選択 + その他のアクション 太字 インデント解除 フィールドから挿入 @@ -67,6 +82,7 @@ マクロの挿入 画像の挿入 関係性の編集 + リストに戻る 保存 保存及び公開 保存して承認に送る @@ -76,20 +92,45 @@ スタイルの表示 表の挿入 + + ドキュメントタイプを変更するには、まず有効なドキュメントタイプのリストから選択します + 確認および現在のドキュメントタイプからのマッピングを割り当て、保存します。 + コンテントは再公開されています + 現在のプロパティ + 現在のドキュメントタイプ + 有効な代替タイプが存在しないため変更することができません。選択されたコンテントの親の下に許可されたドキュメントタイプへのみ変更ができます + ドキュメントタイプを変更しました + プロパティを割り当てる + 割り当てるプロパティ + 新しいテンプレート + 新しいドキュメントタイプ + None + コンテント + ドキュメントタイプを変更する + プロパティが以下のように割り当てられました + から + 1つ以上のプロパティを割り当てられませんでした。プロパティが定義が重複しています + 有効なドキュメントタイプのみが表示されます + + 公開されました このページについて エイリアス (画像を電話でわかるように言葉で説明) 別名のリンク クリックでアイテムを編集する 作成者 + 作成者 + 更新者 作成日時 + このドキュメントが作成された日時 ドキュメントタイプ 変種中 公開終了日時 このページは公開後変更されています このページは公開されていません 公開日時 + リストに表示するアイテムはありません メディアタイプ メディアの項目へのリンク メンバーグループ @@ -99,24 +140,38 @@ タイトル プロパティ このページは公開されましたが、親ページの '%0%' が非公開のため閲覧できません + このコンテントは公開されていますがキャッシュされていません(内部エラー) 公開 公開状態 公開開始日時 + 公開停止日時 日時の消去 並び順が更新されました ノードをドラッグ、クリック、または列のヘッダーをクリックする事でノードを簡単にソートできます。SHIFT、CONTROLキーを使い複数のノードを選択する事もできます。 統計 タイトル (オプション) + 代替テキスト (オプション) 型 非公開 最終更新日時 + このドキュメントが最後に更新された日時 ファイルの消去 ページへのリンク + グループのメンバー + グループのメンバーではありません + 子コンテンツ + ターゲット + + + クリックしてアップロードする + ファイルをここへドロップ.. どこに新しい %0% を作りますか ここに作成 型とタイトルを選んでください + "document types".]]> + "media types".]]> ウェブサイトを参照する @@ -181,14 +236,32 @@ ]]> カルチャ名 + + ユーザー名を入力... + パスワードを入力... + %0%と命名します... + ここに名称を入力してください... + 検索する... + 条件で絞り込む... + タグを追加します... + + ルートノードとして許可する + これを有効にするとコンテンツとメディアツリーのルートレベルに作成することができます 子ノードとして許可するタイプ + Document Type Compositions 新規作成 削除 説明 新規見出し 見出し サムネイル + リストビューを有効にする + 子ノードをツリーに表示せずにリストビューに表示します + 現在のリストビュー + 有効なリストビューデータタイプ + カスタムリストビューを作成する + カスタムリストビューを削除する 値の前に追加 @@ -217,7 +290,8 @@ %0% は正しい書式ではありません - 注意! CodeMirrorが設定で有効かされていますが、 Internet Explorerでは不安定なので無効化してください。 + 指定されたファイルタイプは管理者のみに許可されます + 注意! CodeMirrorが設定で有効化されていますが、 Internet Explorerでは不安定なので無効化してください。 新しいプロパティ型のエイリアスと名前の両方を設定してください！ 特定のファイルまたはフォルタの読み込み/書き込みアクセスに問題があります タイトルを入力してください @@ -232,10 +306,12 @@ このセルは結合されたものではないので分離する事はできません。 XSLTソースにエラーがあります 1つ以上のエラーがあるのでこのXSLTは保存できませんでした + このプロパティに使用されているデータタイプにエラーがあります Umbracoについて アクション + アクション選択 追加 エイリアス 確かですか? @@ -285,6 +361,7 @@ ログアウト マクロ 移動 + もっと 名前 新規 次へ @@ -304,6 +381,7 @@ 残り 名前の変更 更新 + この項目は必須です 再試行 許可 検索 @@ -313,7 +391,7 @@ サイズ 並べ替え 型 - 探す型... + 検索... 上 更新 アップグレード @@ -327,6 +405,7 @@ 幅 はい フォルダー + 検索結果 背景色 @@ -348,10 +427,10 @@ ]]> 次へを押して続行してください。]]> データベースを見つけられません！"web.config"ファイルの中の"接続文字列"を確認してください。

-

続行するには"web.config"ファイルを編集(Visual Studioないし使い慣れたテキストエディタで)し、下の方にスクロールし、"UmbracoDbDSN"という名前のキーでデータベースの接続文字列を追加して保存します。

+

続行するには"web.config"ファイルを編集(Visual Studioないし使い慣れたテキストエディタで)し、下の方にスクロールし、"umbracoDbDSN"という名前のキーでデータベースの接続文字列を追加して保存します。

再施行ボタンをクリックして - 続けます。
+ 続けます。
 より詳細にはこちらの web.config を編集します。

]]> 必要ならISPに連絡するなどしてみてください。 @@ -380,7 +459,7 @@

]]> 始めに、ビデオによる解説を見ましょう - 次へボタンをクリック(またはweb.configのUmbracoConfigurationStatusを編集)すると、あなたはここに示されるこのソフトウェアのライセンスを承諾したと見做されます。注意として、UmbracoはMITライセンスをフレームワークへ、フリーウェアライセンスをUIへ、それぞれ異なる2つのライセンスを採用しています。 + 次へボタンをクリック(またはweb.configのumbracoConfigurationStatusを編集)すると、あなたはここに示されるこのソフトウェアのライセンスを承諾したと見做されます。注意として、UmbracoはMITライセンスをフレームワークへ、フリーウェアライセンスをUIへ、それぞれ異なる2つのライセンスを採用しています。 まだインストールは完了していません。 影響するファイルとフォルダ Umbracoに必要なアクセス権の設定についての詳細はこちらをどうぞ @@ -408,7 +487,7 @@ スクラッチから始めたい どうしたらいいの？) + (どうしたらいいの？) 後からRunwayをインストールする事もできます。そうしたくなった時は、Developerセクションのパッケージへどうぞ。 ]]> Umbracoプラットフォームのクリーンセットアップが完了しました。この後はどうしますか？ @@ -444,7 +523,7 @@ Runwayをインストールして作られた新しいウェブサイトがど 我々の認めるコミュニティから手助けを得られるでしょう。どうしたら簡単なサイトを構築できるか、どうしたらパッケージを使えるかについてのビデオや文書、またUmbracoの用語のクイックガイドも見る事ができます。]]> Umbraco %0% のインストールは完了、準備が整いました /web.config fileを手作業で編集し、'%0%'の下にあるUmbracoConfigurationStatusキーを設定してください。]]> + /web.config fileを手作業で編集し、'%0%'の下にあるumbracoConfigurationStatusキーを設定してください。]]> 今すぐ開始できます。
もしUmbracoの初心者なら、 私たちの初心者向けのたくさんの情報を参考にしてください。]]> Umbracoの開始 @@ -453,7 +532,7 @@ Runwayをインストールして作られた新しいウェブサイトがど Umbraco Version 3 Umbraco Version 4 見る - Umbraco %0% の新規インストールまたは3.0からの更新について設定方法を案内します。 + umbraco %0% の新規インストールまたは3.0からの更新について設定方法を案内します。

"次へ"を押してウィザードを開始します。]]> @@ -466,7 +545,16 @@ Runwayをインストールして作られた新しいウェブサイトがど 作業を保存して今すぐ更新 - © 2001 - %0%
umbraco.com

]]> + Happy super sunday + Happy manic monday + Happy tubular tuesday + Happy wonderful wednesday + Happy thunder thursday + Happy funky friday + Happy caturday + ウェブサイトにログインします。 + セッションタイムアウトしました。 + © 2001 - %0%
umbraco.org

]]> Umbraco にようこそ。ユーザー名とパスワードを入力してください: @@ -549,7 +637,7 @@ Runwayをインストールして作られた新しいウェブサイトがど 本当にアンインストールしますか パッケージのアンインストールが終了しました パッケージが正常にアンインストールされました - パッケージのアンンストール + パッケージのアンインストール 注意: 全ての、文書やメディアなどに依存したアイテムを削除する場合はそれらの作業を一端止めてからアンインストールしなければシステムが不安定になる恐れがあります。 疑問点などあればパッケージの作者へ連絡してください。]]> @@ -558,6 +646,7 @@ Runwayをインストールして作られた新しいウェブサイトがど 更新の手順 このパッケージの更新があります。Umbracoのパッケージリポジトリから直接ダウンロードできます。 パッケージのバージョン + パッケージのバージョン履歴 パッケージのウェブサイトを見る @@ -585,14 +674,15 @@ Runwayをインストールして作られた新しいウェブサイトがど 単一のログインとパスワードで単純に保護したい場合に適します + - - - + ]]> 非公開の子ページも含めます 公開を進めています - 少々お待ちください... %1% ページ中 %0% ページが公開されました... @@ -615,6 +705,9 @@ Runwayをインストールして作られた新しいウェブサイトがど 新規ウィンドウで開く リンクを削除 + + リセット + 現在の版 赤 の文字列は以前の版にはない部分で、緑の文字列は以前の版にのみある部分です。]]> @@ -640,6 +733,9 @@ Runwayをインストールして作られた新しいウェブサイトがど 統計 翻訳 ユーザー + ヘルプ + フォーム + アナリティクス 既定のテンプレート @@ -649,6 +745,7 @@ Runwayをインストールして作られた新しいウェブサイトがど ノードのタイプ タイプ スタイルシート + スクリプト スタイルシートのプロパティ タブ タブの名前 @@ -656,6 +753,9 @@ Runwayをインストールして作られた新しいウェブサイトがど マスターコンテンツタイプが有効 このコンテンツタイプの使用 マスターコンテンツタイプについては、マスターコンテンツタイプからのタブは表示されず、マスターコンテンツタイプでのみ編集することができます。 + このタブにはプロパティが定義されていません、上部のリンクから新しいプロパティを作成してください + マスタードキュメントタイプ + テンプレートを作成する ソートが完了しました。 @@ -684,6 +784,8 @@ Runwayをインストールして作られた新しいウェブサイトがど 変更を適用する為に公開する事を忘れないでください 承認へ送りました 変更は承認へと送られます + メディアを保存しました + メディアをエラーなく保存しました メンバーを保存しました スタイルシートのプロパティを保存しました スタイルシートを保存しました @@ -729,15 +831,53 @@ Runwayをインストールして作られた新しいウェブサイトがど コンテンツ領域プレースホルダーの挿入 dictionary item の挿入 マクロの挿入 - Umbraco ページフィールドの挿入 + umbraco ページフィールドの挿入 マスターテンプレート - Umbraco テンプレートタグのクイックガイド + umbraco テンプレートタグのクイックガイド テンプレート + + + 挿入するアイテムを選択する + ここからレイアウトを選択します + 最初の要素を追加します]]> + + クリックして埋め込む + クリックして画像を挿入する + キャプション... + ここに記入する... + + レイアウト + レイアウトは通常1つまたは2つの異なるレイアウトを必要とする、グリッドエディタの全体的な作業エリアです + レイアウトを追加する + 追加のセクションの横幅を設定し、レイアウトを調整する + + 行の構成 + 定義された構成の行が水平に配置されます + 行の構成を追加 + 追加のセルのセル幅を設定することで調整します + + 列 + グリッドレイアウトの列を合計した数 + + 設定 + 編集者が設定できる項目 + + + スタイル + 編集者が設定できるスタイル + + 入力されたJSONが正しい場合のみ設定が保存されます + + すべてのエディタを許可する + すべての行の構成を許可する + + 代替フィールド 代替テキスト 大文字小文字変換 + エンコーディング フィールドの選択 改行コードの変換 改行コードをhtmlタグ &lt;br&gt; に変換する @@ -838,6 +978,7 @@ Runwayをインストールして作られた新しいウェブサイトがど スタイルシート テンプレート XSLT ファイル + アナリティクス 新しい更新があります @@ -864,6 +1005,7 @@ Runwayをインストールして作られた新しいウェブサイトがど セクション Umbracoへのアクセスを無効にする パスワード + パスワードのリセット パスワードが変更されました! 新しいパスワードの確認 新しいパスワードの入力 @@ -882,5 +1024,9 @@ Runwayをインストールして作られた新しいウェブサイトがど ユーザーの種類 ユーザーの種類 投稿者 + 翻訳者 + あなたのプロフィール + あなたの最新の履歴 + セッションの期限 diff --git a/src/Umbraco.Web.UI/umbraco/config/lang/ru.xml b/src/Umbraco.Web.UI/umbraco/config/lang/ru.xml index 41dd15fbf2..df1273ae99 100644 --- a/src/Umbraco.Web.UI/umbraco/config/lang/ru.xml +++ b/src/Umbraco.Web.UI/umbraco/config/lang/ru.xml @@ -27,6 +27,7 @@ Опубликовать Обновить узлы Опубликовать весь сайт + Восстановить Разрешения Откатить Направить на публикацию @@ -81,6 +82,7 @@ Вставить макрос Вставить изображение Править связи + Вернуться к списку Сохранить Сохранить и опубликовать Сохранить и направить на публикацию @@ -99,7 +101,8 @@ Узел переопубликован. Текущее свойство Текущий тип - Тип документа не может быть изменен, так как для данного расположения нет разрешенных альтернатив. + Тип документа не может быть изменен, так как для данного расположения нет разрешенных альтернатив. + Альтернативный тип станет доступным, если его разрешить как тип, пригодный для создания дочерних узлов внутри родительского узла данного документа. Тип документа изменен Сопоставление свойств Сопоставлено свойству @@ -121,7 +124,8 @@ Алиас (как бы Вы описали изображение по телефону) Альтернативные ссылки - Дочерние узлы + Альтернативный текст (необязательно) + Элементы списка Нажмите для правки этого элемента Создано пользователем Исходный автор @@ -130,9 +134,11 @@ Тип документа Редактирование Скрыть + Опубликовано Этот документ был изменен после публикации Этот документ не опубликован Документ опубликован + В этом списке пока нет элементов. Ссылка на медиа-элементы Тип медиа-контента Группа участников @@ -165,9 +171,9 @@ Где вы хотите создать новый %0% - Создать в - "document types".]]> - "media types".]]> + Создать в узле + "Типы документов".]]> + "Типы медиа-материалов".]]> Выберите тип и заголовок @@ -234,12 +240,20 @@ Название языка (культуры) + Допустим как корневой + Только узлы таких типов (с установленным флагом) могут быть созданы в корневом уровне дерева содержимого или медиа-библиотеки Допустимые типы дочерних узлов + Составные типы документов Создать + Создать пользовательский список + Текущий список + Текущий тип данных в виде списка Удалить вкладку Описание Включить представление в виде списка + Включает представление узлов, дочерних к узлу данного типа, в виде сортируемого списка с функцией фильтра и поиска. Такие дочерние узлы при этом перестают быть видимыми в дереве. Новая вкладка + Удалить пользовательский список Вкладка Миниатюра @@ -266,7 +280,7 @@ %0% должно быть целочисленным значением %0% в %1% является обязательным полем %0% является обязательным полем - %0% в %1%: данные введены в некорректном формате + %0% в %1%: данные в некорректном формате %0% - данные в некорректном формате @@ -394,9 +408,38 @@ Шрифт Текст + + снизу и добавьте Ваш первый элемент]]> + Добавить шаблон сетки + Настройте шаблон, задавая ширину колонок или добавляя дополнительные секции + Добавить конфигурацию строки + Настройте строку, задавая ширину ячеек или добавляя дополнительные ячейки + Добавить новые строки + Доступны все редакторы + Доступны все конфигурации строк + Кликните для встраивания + Кликните для вставки изображения + Колонки + Суммарное число колонок в шаблоне сетки + Шаблоны сетки + Шаблоны являются рабочим пространством для редактора сетки, обычно Вам понадобится не более одного или двух шаблонов + Вставить элемент + Заголовок для изображения... + Напишите... + Конфигурации строк + Строки - это последовательности ячеек с горизонтальным расположением + Установки будут сохранены только если они указаны в корректном формате json + Установки + Задайте установки, доступные редакторам для изменения + Стили + Задайте стили, доступные редакторам для изменения + Страница + + Сбросить + Программа установки не может установить подключение к базе данных. Невозможно сохранить изменения в файл web.config. Пожалуйста, вручную измените настройки строки подключения к базе данных. @@ -533,7 +576,7 @@ Рыбный день Слава Богу, сегодня пятница Понедельник начинается в субботу - Введите имя пользователя и пароль + Укажите имя пользователя и пароль Время сессии истекло @@ -643,11 +686,12 @@ Вставить с очисткой форматирования (рекомендуется) - Введите имя... - Введите фильтр... + Укажите имя... + Укажите теги (нажимайте Enter после каждого тега)... + Укажите фильтр... Назовите %0%... Пароль - Введите для поиска... + Что искать... Имя пользователя @@ -692,16 +736,13 @@ ]]> - Добавить внешнюю ссылку - Добавить внутреннюю ссылку - Добавить ссылку Заголовок - Внутренняя страница - Внешний URL - Переместить вниз - Переместить вверх - Открывать в новом окне - Удалить ссылку + Укажите заголовок + выбрать страницу сайта + указать внешнюю ссылку + Укажите ссылку + Ссылка + В новом окне Текущая версия @@ -716,10 +757,12 @@ Править файл скрипта + Аналитика Смотритель Содержимое Курьер Для Разработчиков + Формы Помощь Мастер конфигурирования Umbraco Медиа-материалы @@ -734,9 +777,11 @@ в качестве родительского типа. Вкладки родительского типа не показаны и могут быть изменены непосредственно в родительском типе Родительский тип контента разрешен Данный тип контента использует + Создать шаблон для документов этого типа Шаблон по-умолчанию Словарная статья Чтобы импортировать тип документа, найдите файл ".udt" на своем компьютере, нажав на кнопку "Обзор", затем нажмите "Импортировать" (на следующем экране будет запрошено подтверждение для этой операции). + Родительский тип документа Заголовок новой вкладки Тип узла (документа) Для данной вкладки не определены свойства. Кликните по ссылке "Click here to add a new property" сверху, чтобы создать новое свойство. @@ -906,6 +951,7 @@ Загрузить переведенный xml + Аналитика Обзор кэша Корзина Созданные пакеты @@ -975,6 +1021,7 @@ Поиск всех дочерних документов Сессия истекает через Начальный узел содержимого + Переводчик Имя пользователя Разрешения для пользователя Тип пользователя diff --git a/src/Umbraco.Web.UI/umbraco/config/lang/sv.xml b/src/Umbraco.Web.UI/umbraco/config/lang/sv.xml index b619025624..84b885a931 100644 --- a/src/Umbraco.Web.UI/umbraco/config/lang/sv.xml +++ b/src/Umbraco.Web.UI/umbraco/config/lang/sv.xml @@ -554,6 +554,7 @@ Fyll i ditt lösenord Skriv för att söka... Fyll i ditt lösenord + Skriv för att lägga till taggar (och tryck enter efter varje tagg)... Rollbaserat lösenordsskydd @@ -587,16 +588,16 @@ ok för att publicera %0%. Därmed blir innehållet publikt.

Du kan publicera denna sida och alla dess undersidor genom att kryssa i publicera alla undersidor. ]]> - Lägg till extern länk - Lägg till intern länk - Lägg till + ange en extern länk + ange en intern sida Rubrik - Intern sida - URL - Flytta ner - Flytta upp + Länk Öppna i nytt fönster - Ta bort länk + Ange visningstext + Ange adress + + + Återställ Nuvarande version @@ -644,6 +645,8 @@ Flik Fliknamn Flikar + Huvuddokumenttyp + Skapa matchande mall Sortering klar @@ -885,6 +888,7 @@ Användartyper Skribent Din nuvarande historik + Översättare Din profil \ No newline at end of file diff --git a/src/Umbraco.Web/Editors/AuthenticationController.cs b/src/Umbraco.Web/Editors/AuthenticationController.cs index e3e2abf42f..95f985148c 100644 --- a/src/Umbraco.Web/Editors/AuthenticationController.cs +++ b/src/Umbraco.Web/Editors/AuthenticationController.cs @@ -31,6 +31,7 @@ using Microsoft.AspNet.Identity.Owin; using Umbraco.Core.Logging; using Newtonsoft.Json.Linq; using Umbraco.Core.Models.Identity; +using Umbraco.Web.Security.Identity; using IUser = Umbraco.Core.Models.Membership.IUser; namespace Umbraco.Web.Editors @@ -47,6 +48,7 @@ namespace Umbraco.Web.Editors { private BackOfficeUserManager _userManager; + private BackOfficeSignInManager _signInManager; protected BackOfficeUserManager UserManager { @@ -64,6 +66,24 @@ namespace Umbraco.Web.Editors return _userManager; } } + + protected BackOfficeSignInManager SignInManager + { + get + { + if (_signInManager == null) + { + var mgr = TryGetOwinContext().Result.Get(); + if (mgr == null) + { + throw new NullReferenceException("Could not resolve an instance of " + typeof(BackOfficeSignInManager) + " from the " + typeof(IOwinContext)); + } + _signInManager = mgr; + } + return _signInManager; + } + } + [WebApi.UmbracoAuthorize] [ValidateAngularAntiForgeryToken] @@ -76,7 +96,7 @@ namespace Umbraco.Web.Editors if (result.Succeeded) { var user = await UserManager.FindByIdAsync(User.Identity.GetUserId()); - await SignInAsync(user, isPersistent: false); + await SignInManager.SignInAsync(user, isPersistent: false, rememberBrowser: false); return Request.CreateResponse(HttpStatusCode.OK); } else @@ -146,36 +166,73 @@ namespace Umbraco.Web.Editors if (http.Success == false) throw new InvalidOperationException("This method requires that an HttpContext be active"); - if (UmbracoContext.Security.ValidateBackOfficeCredentials(loginModel.Username, loginModel.Password)) + var result = await SignInManager.PasswordSignInAsync( + loginModel.Username, loginModel.Password, isPersistent: true, shouldLockout: true); + + switch (result) { - //get the user - var user = Security.GetBackOfficeUser(loginModel.Username); - var userDetail = Mapper.Map(user); + case SignInStatus.Success: - //create a response with the userDetail object - var response = Request.CreateResponse(HttpStatusCode.OK, userDetail); + //get the user + var user = Security.GetBackOfficeUser(loginModel.Username); + var userDetail = Mapper.Map(user); - //set the response cookies with the ticket (NOTE: This needs to be done with the custom webapi extension because - // we cannot mix HttpContext.Response.Cookies and the way WebApi/Owin work) - var ticket = response.UmbracoLoginWebApi(user); + //create a response with the userDetail object + var response = Request.CreateResponse(HttpStatusCode.OK, userDetail); - //Identity does some of it's own checks as well so we need to use it's sign in process too... this will essentially re-create the - // ticket/cookie above but we need to create the ticket now so we can assign the Current Thread User/IPrinciple below - await SignInAsync(Mapper.Map(user), isPersistent: true); - //This ensure the current principal is set, otherwise any logic executing after this wouldn't actually be authenticated - http.Result.AuthenticateCurrentRequest(ticket, false); - - //update the userDetail and set their remaining seconds - userDetail.SecondsUntilTimeout = ticket.GetRemainingAuthSeconds(); + //set the response cookies with the ticket (NOTE: This needs to be done with the custom webapi extension because + // we cannot mix HttpContext.Response.Cookies and the way WebApi/Owin work) + var ticket = response.UmbracoLoginWebApi(user); - return response; + //This ensure the current principal is set, otherwise any logic executing after this wouldn't actually be authenticated + http.Result.AuthenticateCurrentRequest(ticket, false); + + //update the userDetail and set their remaining seconds + userDetail.SecondsUntilTimeout = ticket.GetRemainingAuthSeconds(); + + return response; + + case SignInStatus.RequiresVerification: + + var twofactorOptions = UserManager as IUmbracoBackOfficeTwoFactorOptions; + if (twofactorOptions == null) + { + throw new HttpResponseException( + Request.CreateErrorResponse( + HttpStatusCode.BadRequest, + "UserManager does not implement " + typeof(IUmbracoBackOfficeTwoFactorOptions))); + } + + var twofactorView = twofactorOptions.GetTwoFactorView( + TryGetOwinContext().Result, + UmbracoContext, + loginModel.Username); + + if (twofactorView.IsNullOrWhiteSpace()) + { + throw new HttpResponseException( + Request.CreateErrorResponse( + HttpStatusCode.BadRequest, + typeof(IUmbracoBackOfficeTwoFactorOptions) + ".GetTwoFactorView returned an empty string")); + } + + //create a with information to display a custom two factor send code view + var verifyResponse = Request.CreateResponse(HttpStatusCode.OK, new + { + twoFactorView = twofactorView + }); + + return verifyResponse; + + case SignInStatus.LockedOut: + case SignInStatus.Failure: + default: + //return BadRequest (400), we don't want to return a 401 because that get's intercepted + // by our angular helper because it thinks that we need to re-perform the request once we are + // authorized and we don't want to return a 403 because angular will show a warning msg indicating + // that the user doesn't have access to perform this function, we just want to return a normal invalid msg. + throw new HttpResponseException(HttpStatusCode.BadRequest); } - - //return BadRequest (400), we don't want to return a 401 because that get's intercepted - // by our angular helper because it thinks that we need to re-perform the request once we are - // authorized and we don't want to return a 403 because angular will show a warning msg indicating - // that the user doesn't have access to perform this function, we just want to return a normal invalid msg. - throw new HttpResponseException(HttpStatusCode.BadRequest); } @@ -199,24 +256,5 @@ namespace Umbraco.Web.Editors } } - private async Task SignInAsync(BackOfficeIdentityUser user, bool isPersistent) - { - var owinContext = TryGetOwinContext().Result; - - owinContext.Authentication.SignOut(Core.Constants.Security.BackOfficeExternalAuthenticationType); - - var nowUtc = DateTime.Now.ToUniversalTime(); - - owinContext.Authentication.SignIn( - new AuthenticationProperties() - { - IsPersistent = isPersistent, - AllowRefresh = true, - IssuedUtc = nowUtc, - ExpiresUtc = nowUtc.AddMinutes(GlobalSettings.TimeOutInMinutes) - }, - await user.GenerateUserIdentityAsync(UserManager)); - } - } } \ No newline at end of file diff --git a/src/Umbraco.Web/Editors/BackOfficeController.cs b/src/Umbraco.Web/Editors/BackOfficeController.cs index 8c1c23fbcb..ea4a21d840 100644 --- a/src/Umbraco.Web/Editors/BackOfficeController.cs +++ b/src/Umbraco.Web/Editors/BackOfficeController.cs @@ -37,6 +37,7 @@ using System.Web; using AutoMapper; using Microsoft.AspNet.Identity.Owin; using Umbraco.Core.Models.Identity; +using Umbraco.Core.Models.Membership; using Umbraco.Core.Security; using Task = System.Threading.Tasks.Task; using Umbraco.Web.Security.Identity; @@ -51,12 +52,23 @@ namespace Umbraco.Web.Editors public class BackOfficeController : UmbracoController { private BackOfficeUserManager _userManager; + private BackOfficeSignInManager _signInManager; + + protected BackOfficeSignInManager SignInManager + { + get { return _signInManager ?? (_signInManager = OwinContext.Get()); } + } protected BackOfficeUserManager UserManager { get { return _userManager ?? (_userManager = OwinContext.GetUserManager()); } } + protected IAuthenticationManager AuthenticationManager + { + get { return OwinContext.Authentication; } + } + /// /// Render the default view /// @@ -93,7 +105,7 @@ namespace Umbraco.Web.Editors { var cultureInfo = string.IsNullOrWhiteSpace(culture) //if the user is logged in, get their culture, otherwise default to 'en' - ? User.Identity.IsAuthenticated + ? Security.IsAuthenticated() ? Security.CurrentUser.GetUserCulture(Services.TextService) : CultureInfo.GetCultureInfo("en") : CultureInfo.GetCultureInfo(culture); @@ -449,7 +461,7 @@ namespace Umbraco.Web.Editors var loginInfo = await OwinContext.Authentication.GetExternalLoginInfoAsync( Core.Constants.Security.BackOfficeExternalAuthenticationType); - if (loginInfo == null) + if (loginInfo == null || loginInfo.ExternalIdentity.IsAuthenticated == false) { return defaultResponse(); } @@ -474,11 +486,14 @@ namespace Umbraco.Web.Editors // that the ticket is created and stored and that the user is logged in. //sign in - await SignInAsync(user, isPersistent: false); + await SignInManager.SignInAsync(user, isPersistent: false, rememberBrowser: false); } else { - ViewBag.ExternalSignInError = new[] { "The requested provider (" + loginInfo.Login.LoginProvider + ") has not been linked to to an account" }; + if (await AutoLinkAndSignInExternalAccount(loginInfo) == false) + { + ViewBag.ExternalSignInError = new[] { "The requested provider (" + loginInfo.Login.LoginProvider + ") has not been linked to to an account" }; + } //Remove the cookie otherwise this message will keep appearing if (Response.Cookies[Core.Constants.Security.BackOfficeExternalCookieName] != null) @@ -490,27 +505,103 @@ namespace Umbraco.Web.Editors return response(); } - private async Task SignInAsync(BackOfficeIdentityUser user, bool isPersistent) + private async Task AutoLinkAndSignInExternalAccount(ExternalLoginInfo loginInfo) { - OwinContext.Authentication.SignOut(Core.Constants.Security.BackOfficeExternalAuthenticationType); + //Here we can check if the provider associated with the request has been configured to allow + // new users (auto-linked external accounts). This would never be used with public providers such as + // Google, unless you for some reason wanted anybody to be able to access the backend if they have a Google account + // .... not likely! - var nowUtc = DateTime.Now.ToUniversalTime(); + var authType = OwinContext.Authentication.GetExternalAuthenticationTypes().FirstOrDefault(x => x.AuthenticationType == loginInfo.Login.LoginProvider); + if (authType == null) + { + Logger.Warn("Could not find external authentication provider registered: " + loginInfo.Login.LoginProvider); + return false; + } - OwinContext.Authentication.SignIn( - new AuthenticationProperties() + var autoLinkOptions = authType.GetExternalAuthenticationOptions(); + if (autoLinkOptions != null) + { + if (autoLinkOptions.ShouldAutoLinkExternalAccount(UmbracoContext, loginInfo)) { - IsPersistent = isPersistent, - AllowRefresh = true, - IssuedUtc = nowUtc, - ExpiresUtc = nowUtc.AddMinutes(GlobalSettings.TimeOutInMinutes) - }, - await user.GenerateUserIdentityAsync(UserManager)); - } + //we are allowing auto-linking/creating of local accounts + if (loginInfo.Email.IsNullOrWhiteSpace()) + { + ViewBag.ExternalSignInError = new[] { "The requested provider (" + loginInfo.Login.LoginProvider + ") has not provided an email address, the account cannot be linked." }; + } + else + { - private IAuthenticationManager AuthenticationManager - { - get { return OwinContext.Authentication; } - } + //Now we need to perform the auto-link, so first we need to lookup/create a user with the email address + var foundByEmail = Services.UserService.GetByEmail(loginInfo.Email); + if (foundByEmail != null) + { + ViewBag.ExternalSignInError = new[] { "A user with this email address already exists locally. You will need to login locally to Umbraco and link this external provider: " + loginInfo.Login.LoginProvider }; + } + else + { + var defaultUserType = autoLinkOptions.GetDefaultUserType(UmbracoContext, loginInfo); + var userType = Services.UserService.GetUserTypeByAlias(defaultUserType); + if (userType == null) + { + ViewBag.ExternalSignInError = new[] { "Could not auto-link this account, the specified User Type does not exist: " + defaultUserType }; + } + else + { + + var autoLinkUser = new BackOfficeIdentityUser() + { + Email = loginInfo.Email, + Name = loginInfo.ExternalIdentity.Name, + UserTypeAlias = userType.Alias, + AllowedSections = autoLinkOptions.GetDefaultAllowedSections(UmbracoContext, loginInfo), + Culture = autoLinkOptions.GetDefaultCulture(UmbracoContext, loginInfo), + UserName = loginInfo.Email + }; + + //call the callback if one is assigned + if (autoLinkOptions.OnAutoLinking != null) + { + autoLinkOptions.OnAutoLinking(autoLinkUser, loginInfo); + } + + var userCreationResult = await UserManager.CreateAsync(autoLinkUser); + + if (userCreationResult.Succeeded == false) + { + ViewBag.ExternalSignInError = userCreationResult.Errors; + } + else + { + var linkResult = await UserManager.AddLoginAsync(autoLinkUser.Id, loginInfo.Login); + if (linkResult.Succeeded == false) + { + ViewBag.ExternalSignInError = linkResult.Errors; + + //If this fails, we should really delete the user since it will be in an inconsistent state! + var deleteResult = await UserManager.DeleteAsync(autoLinkUser); + if (deleteResult.Succeeded == false) + { + //DOH! ... this isn't good, combine all errors to be shown + ViewBag.ExternalSignInError = linkResult.Errors.Concat(deleteResult.Errors); + } + } + else + { + //sign in + await SignInManager.SignInAsync(autoLinkUser, isPersistent: false, rememberBrowser: false); + } + } + } + } + + } + } + return true; + } + + return false; + } /// /// Returns the server variables regarding the application state @@ -526,7 +617,7 @@ namespace Umbraco.Web.Editors {"assemblyVersion", UmbracoVersion.AssemblyVersion} }; - var version = UmbracoVersion.GetSemanticVersion().ToString(); + var version = UmbracoVersion.GetSemanticVersion().ToSemanticString(); app.Add("version", version); app.Add("cdf", ClientDependency.Core.Config.ClientDependencySettings.Instance.Version); diff --git a/src/Umbraco.Web/Editors/ContentTypeController.cs b/src/Umbraco.Web/Editors/ContentTypeController.cs index 28db55522f..307704f193 100644 --- a/src/Umbraco.Web/Editors/ContentTypeController.cs +++ b/src/Umbraco.Web/Editors/ContentTypeController.cs @@ -28,6 +28,8 @@ namespace Umbraco.Web.Editors /// An API controller used for dealing with content types /// [PluginController("UmbracoApi")] + [UmbracoTreeAuthorize(Constants.Trees.DocumentTypes)] + [EnableOverrideAuthorization] public class ContentTypeController : ContentTypeControllerBase { private ICultureDictionary _cultureDictionary; @@ -150,6 +152,7 @@ namespace Umbraco.Web.Editors /// Returns the allowed child content type objects for the content item id passed in /// /// + [UmbracoTreeAuthorize(Constants.Trees.DocumentTypes, Constants.Trees.Content)] public IEnumerable GetAllowedChildren(int contentId) { if (contentId == Constants.System.RecycleBinContent) @@ -169,7 +172,7 @@ namespace Umbraco.Web.Editors var contentItem = Services.ContentService.GetById(contentId); if (contentItem == null) { - throw new HttpResponseException(HttpStatusCode.NotFound); + return Enumerable.Empty(); } var ids = contentItem.ContentType.AllowedContentTypes.Select(x => x.Id.Value).ToArray(); diff --git a/src/Umbraco.Web/Editors/DataTypeController.cs b/src/Umbraco.Web/Editors/DataTypeController.cs index b46013a8bb..71aa20f9e4 100644 --- a/src/Umbraco.Web/Editors/DataTypeController.cs +++ b/src/Umbraco.Web/Editors/DataTypeController.cs @@ -34,6 +34,11 @@ namespace Umbraco.Web.Editors [EnableOverrideAuthorization] public class DataTypeController : UmbracoAuthorizedJsonController { + /// + /// Gets data type by name + /// + /// + /// public DataTypeDisplay GetByName(string name) { var dataType = Services.DataTypeService.GetDataTypeDefinitionByName(name); @@ -45,10 +50,6 @@ namespace Umbraco.Web.Editors /// /// /// - /// - /// Permission is granted to this method if the user has access to any of these trees: DataTypes, Content or Media - /// - [UmbracoTreeAuthorize(Constants.Trees.DataTypes, Constants.Trees.Content, Constants.Trees.Media)] public DataTypeDisplay GetById(int id) { var dataType = Services.DataTypeService.GetDataTypeDefinitionById(id); @@ -59,98 +60,6 @@ namespace Umbraco.Web.Editors return Mapper.Map(dataType); } - /// - /// Gets the content json for all data types - /// - /// - /// - /// - /// Permission is granted to this method if the user has access to any of these trees: DataTypes, Content or Media - /// - [UmbracoTreeAuthorize(Constants.Trees.DataTypes, Constants.Trees.Content, Constants.Trees.Media)] - public IEnumerable GetAll() - { - return Services.DataTypeService - .GetAllDataTypeDefinitions() - .Select(x => Mapper.Map(x)).Where(x => x.IsSystemDataType == false); - } - - /// - /// Gets the content json for all data types added by the user - /// - /// - /// - /// - /// Permission is granted to this method if the user has access to any of these trees: DataTypes, Content or Media - /// - [UmbracoTreeAuthorize(Constants.Trees.DataTypes, Constants.Trees.Content, Constants.Trees.Media)] - public IEnumerable GetAllUserConfigured() - { - //find all user configured for re-reference - return Services.DataTypeService - .GetAllDataTypeDefinitions() - .Where(x => x.Id > 1045) - .Select(x => Mapper.Map(x)).Where(x => x.IsSystemDataType == false); - - //find all custom editors added by non-core manifests - - //find the rest - } - - /// - /// Gets the content json for all user added property editors - /// - /// - /// - /// - /// Permission is granted to this method if the user has access to any of these trees: DataTypes, Content or Media - /// - [UmbracoTreeAuthorize(Constants.Trees.DataTypes, Constants.Trees.Content, Constants.Trees.Media)] - public IEnumerable GetAllUserPropertyEditors() - { - return PropertyEditorResolver.Current.PropertyEditors - .OrderBy(x => x.Name) - .Where(x => x.ValueEditor.View.IndexOf("app_plugins", StringComparison.InvariantCultureIgnoreCase) >= 0) - .Select(Mapper.Map); - } - - - [UmbracoTreeAuthorize(Constants.Trees.DataTypes, Constants.Trees.Content, Constants.Trees.Media)] - public IDictionary> GetAllDataTypesAndEditors() - { - var datadefs = Services.DataTypeService - .GetAllDataTypeDefinitions(); - var editors = PropertyEditorResolver.Current.PropertyEditors.Where(x => datadefs.Any(y => y.PropertyEditorAlias == x.Alias) == false); - - var datatypes = new List(); - - foreach (var datadef in datadefs) - datatypes.Add(Mapper.Map(datadef)); - - foreach (var unusedEditor in editors) - datatypes.Add(Mapper.Map(unusedEditor)); - - var grouped = datatypes.GroupBy(x => x.Group.ToLower()).ToDictionary(group => group.Key, group => group.AsEnumerable()); - return grouped; - } - - - /// - /// Gets the content json for all property editors - /// - /// - /// - /// - /// Permission is granted to this method if the user has access to any of these trees: DataTypes, Content or Media - /// - [UmbracoTreeAuthorize(Constants.Trees.DataTypes, Constants.Trees.Content, Constants.Trees.Media)] - public IEnumerable GetAllPropertyEditors() - { - return PropertyEditorResolver.Current.PropertyEditors - .OrderBy(x => x.Name) - .Select(Mapper.Map); - } - /// /// Deletes a data type wth a given ID /// @@ -297,5 +206,112 @@ namespace Umbraco.Web.Editors //now return the updated model return display; } + + #region ReadOnly actions to return basic data - allow access for: content ,media, members, settings, developer + /// + /// Gets the content json for all data types + /// + /// + /// + /// Permission is granted to this method if the user has access to any of these sections: Content, media, settings, developer, members + /// + [UmbracoApplicationAuthorize( + Constants.Applications.Content, Constants.Applications.Media, Constants.Applications.Members, + Constants.Applications.Settings, Constants.Applications.Developer)] + public IEnumerable GetAll() + { + return Services.DataTypeService + .GetAllDataTypeDefinitions() + .Select(Mapper.Map).Where(x => x.IsSystemDataType == false); + } + + /// + /// Gets the content json for all data types added by the user + /// + /// + /// + /// Permission is granted to this method if the user has access to any of these sections: Content, media, settings, developer, members + /// + [UmbracoApplicationAuthorize( + Constants.Applications.Content, Constants.Applications.Media, Constants.Applications.Members, + Constants.Applications.Settings, Constants.Applications.Developer)] + public IEnumerable GetAllUserConfigured() + { + //find all user configured for re-reference + return Services.DataTypeService + .GetAllDataTypeDefinitions() + //TODO: This is pretty nasty :( + .Where(x => x.Id > 1045) + .Select(Mapper.Map).Where(x => x.IsSystemDataType == false); + + //find all custom editors added by non-core manifests + + //find the rest + } + + /// + /// Gets the content json for all user added property editors + /// + /// + /// + /// Permission is granted to this method if the user has access to any of these sections: Content, media, settings, developer, members + /// + [UmbracoTreeAuthorize( + Constants.Applications.Content, Constants.Applications.Media, Constants.Applications.Members, + Constants.Applications.Settings, Constants.Applications.Developer)] + public IEnumerable GetAllUserPropertyEditors() + { + return PropertyEditorResolver.Current.PropertyEditors + .OrderBy(x => x.Name) + .Where(x => x.ValueEditor.View.IndexOf("app_plugins", StringComparison.InvariantCultureIgnoreCase) >= 0) + .Select(Mapper.Map); + } + + /// + /// Returns all configured data types and all potential data types that could exist based on unused property editors grouped + /// by their property editor defined group. + /// + /// + /// + /// Permission is granted to this method if the user has access to any of these sections: Content, media, settings, developer, members + /// + [UmbracoTreeAuthorize( + Constants.Applications.Content, Constants.Applications.Media, Constants.Applications.Members, + Constants.Applications.Settings, Constants.Applications.Developer)] + public IDictionary> GetAllDataTypesAndEditors() + { + var datadefs = Services.DataTypeService + .GetAllDataTypeDefinitions(); + var editors = PropertyEditorResolver.Current.PropertyEditors.Where(x => datadefs.Any(y => y.PropertyEditorAlias == x.Alias) == false); + + var datatypes = datadefs.Select(Mapper.Map).ToList(); + + datatypes.AddRange(editors.Select(Mapper.Map)); + + var grouped = datatypes + .GroupBy(x => x.Group.IsNullOrWhiteSpace() ? "" : x.Group.ToLower()) + .ToDictionary(group => group.Key, group => group.AsEnumerable()); + + return grouped; + } + + + /// + /// Gets all property editors defined + /// + /// + /// + /// Permission is granted to this method if the user has access to any of these sections: Content, media, settings, developer, members + /// + [UmbracoTreeAuthorize( + Constants.Applications.Content, Constants.Applications.Media, Constants.Applications.Members, + Constants.Applications.Settings, Constants.Applications.Developer)] + public IEnumerable GetAllPropertyEditors() + { + return PropertyEditorResolver.Current.PropertyEditors + .OrderBy(x => x.Name) + .Select(Mapper.Map); + } + #endregion } } \ No newline at end of file diff --git a/src/Umbraco.Web/Editors/MediaTypeController.cs b/src/Umbraco.Web/Editors/MediaTypeController.cs index e8cad40803..fd77a35037 100644 --- a/src/Umbraco.Web/Editors/MediaTypeController.cs +++ b/src/Umbraco.Web/Editors/MediaTypeController.cs @@ -9,6 +9,8 @@ using Umbraco.Web.Models.ContentEditing; using Umbraco.Web.Models.Mapping; using Umbraco.Web.Mvc; using Umbraco.Web.WebApi; +using Umbraco.Web.WebApi.Filters; +using Constants = Umbraco.Core.Constants; namespace Umbraco.Web.Editors { @@ -21,6 +23,8 @@ namespace Umbraco.Web.Editors /// An API controller used for dealing with media types /// [PluginController("UmbracoApi")] + [UmbracoTreeAuthorize(Constants.Trees.MediaTypes)] + [EnableOverrideAuthorization] public class MediaTypeController : ContentTypeControllerBase { /// @@ -44,6 +48,7 @@ namespace Umbraco.Web.Editors /// Returns the allowed child content type objects for the content item id passed in /// /// + [UmbracoTreeAuthorize(Constants.Trees.DocumentTypes, Constants.Trees.Content, Constants.Trees.Media)] public IEnumerable GetAllowedChildren(int contentId) { if (contentId == Core.Constants.System.RecycleBinMedia) @@ -59,7 +64,7 @@ namespace Umbraco.Web.Editors var contentItem = Services.MediaService.GetById(contentId); if (contentItem == null) { - throw new HttpResponseException(HttpStatusCode.NotFound); + return Enumerable.Empty(); } var ids = contentItem.ContentType.AllowedContentTypes.Select(x => x.Id.Value).ToArray(); diff --git a/src/Umbraco.Web/Editors/MemberTypeController.cs b/src/Umbraco.Web/Editors/MemberTypeController.cs index 7b884c095f..b21f45510e 100644 --- a/src/Umbraco.Web/Editors/MemberTypeController.cs +++ b/src/Umbraco.Web/Editors/MemberTypeController.cs @@ -24,6 +24,8 @@ namespace Umbraco.Web.Editors /// An API controller used for dealing with content types /// [PluginController("UmbracoApi")] + [UmbracoTreeAuthorize(Constants.Trees.MemberTypes)] + [EnableOverrideAuthorization] public class MemberTypeController : UmbracoAuthorizedJsonController { /// @@ -47,7 +49,7 @@ namespace Umbraco.Web.Editors private readonly MembershipProvider _provider; - public Umbraco.Web.Models.ContentEditing.MemberTypeDisplay GetById(int id) + public MemberTypeDisplay GetById(int id) { var ct = Services.MemberTypeService.Get(id); if (ct == null) @@ -55,19 +57,19 @@ namespace Umbraco.Web.Editors throw new HttpResponseException(HttpStatusCode.NotFound); } - var dto = Mapper.Map(ct); + var dto = Mapper.Map(ct); return dto; } - public Umbraco.Web.Models.ContentEditing.MemberTypeDisplay GetEmpty() + public MemberTypeDisplay GetEmpty() { var ct = new MemberType(-1); - var dto = Mapper.Map(ct); + var dto = Mapper.Map(ct); return dto; } - /// TODO: Move to base content type controller + // TODO: Move to base content type controller public ContentPropertyDisplay GetPropertyTypeScaffold(int id) { var dataTypeDiff = Services.DataTypeService.GetDataTypeDefinitionById(id); @@ -89,7 +91,6 @@ namespace Umbraco.Web.Editors }; } - /// /// Returns all member types /// @@ -109,10 +110,10 @@ namespace Umbraco.Web.Editors var ctService = ApplicationContext.Services.MemberTypeService; - ///TODO: warn on content type alias conflicts - ///TODO: warn on property alias conflicts + //TODO: warn on content type alias conflicts + //TODO: warn on property alias conflicts - ///TODO: Validate the submitted model + //TODO: Validate the submitted model //filter out empty properties contentType.Groups = contentType.Groups.Where(x => x.Name.IsNullOrWhiteSpace() == false).ToList(); diff --git a/src/Umbraco.Web/HtmlHelperBackOfficeExtensions.cs b/src/Umbraco.Web/HtmlHelperBackOfficeExtensions.cs index e3f58bb69e..75e628851e 100644 --- a/src/Umbraco.Web/HtmlHelperBackOfficeExtensions.cs +++ b/src/Umbraco.Web/HtmlHelperBackOfficeExtensions.cs @@ -47,10 +47,10 @@ namespace Umbraco.Web "; return html.Raw(str); - } + } /// - /// Used to render the script tag that will pass in the angular externalLoginInfo service on page load + /// Used to render the script that will pass in the angular externalLoginInfo service on page load /// /// /// @@ -67,10 +67,6 @@ namespace Umbraco.Web }) .ToArray(); - - //define a callback that is executed when we bootstrap angular, this is used to inject angular values - //with server side info - var sb = new StringBuilder(); sb.AppendLine(); sb.AppendLine(@"var errors = [];"); diff --git a/src/Umbraco.Web/Install/FilePermissionHelper.cs b/src/Umbraco.Web/Install/FilePermissionHelper.cs index 013f40fc0e..b5bc908fde 100644 --- a/src/Umbraco.Web/Install/FilePermissionHelper.cs +++ b/src/Umbraco.Web/Install/FilePermissionHelper.cs @@ -98,7 +98,7 @@ namespace Umbraco.Web.Install // that and we might get lock issues. try { - var xmlFile = content.Instance.UmbracoXmlDiskCacheFileName + ".tmp"; + var xmlFile = content.GetUmbracoXmlDiskFileName() + ".tmp"; SaveAndDeleteFile(xmlFile); return true; } diff --git a/src/Umbraco.Web/Install/InstallSteps/SetUmbracoVersionStep.cs b/src/Umbraco.Web/Install/InstallSteps/SetUmbracoVersionStep.cs index d52579772c..b8be5b7a22 100644 --- a/src/Umbraco.Web/Install/InstallSteps/SetUmbracoVersionStep.cs +++ b/src/Umbraco.Web/Install/InstallSteps/SetUmbracoVersionStep.cs @@ -34,7 +34,7 @@ namespace Umbraco.Web.Install.InstallSteps DistributedCache.Instance.RefreshAllPageCache(); // Update configurationStatus - GlobalSettings.ConfigurationStatus = UmbracoVersion.GetSemanticVersion().ToString(); + GlobalSettings.ConfigurationStatus = UmbracoVersion.GetSemanticVersion().ToSemanticString(); // Update ClientDependency version var clientDependencyConfig = new ClientDependencyConfiguration(_applicationContext.ProfilingLogger.Logger); diff --git a/src/Umbraco.Web/Models/Mapping/ContentTypeModelMapper.cs b/src/Umbraco.Web/Models/Mapping/ContentTypeModelMapper.cs index 29745ff941..3b55658343 100644 --- a/src/Umbraco.Web/Models/Mapping/ContentTypeModelMapper.cs +++ b/src/Umbraco.Web/Models/Mapping/ContentTypeModelMapper.cs @@ -49,16 +49,18 @@ namespace Umbraco.Web.Models.Mapping //mapped in aftermap .ForMember(dto => dto.AllowedContentTypes, expression => expression.Ignore()) .ForMember(dto => dto.AllowedTemplates, expression => expression.Ignore()) - - + //ignore, we'll do this in after map .ForMember(dto => dto.PropertyGroups, expression => expression.Ignore()) .AfterMap((source, dest) => { var addedProperties = new List(); - //get all properties from groups that are not generic properties (-666 id) - foreach (var groupDisplay in source.Groups.Where(x => x.Id != -666)) + + //get all properties from groups that are not generic properties or inhertied (-666 id) + var selfNonGenericGroups = source.Groups.Where(x => x.Inherited == false && x.Id != -666).ToArray(); + + foreach (var groupDisplay in selfNonGenericGroups) { //use underlying logic to add the property group which should wire most things up for us dest.AddPropertyGroup(groupDisplay.Name); @@ -73,9 +75,17 @@ namespace Umbraco.Web.Models.Mapping } } + //Groups to remove + var groupsToRemove = dest.PropertyGroups.Select(x => x.Name).Except(selfNonGenericGroups.Select(x => x.Name)).ToArray(); + foreach (var toRemove in groupsToRemove) + { + dest.RemovePropertyGroup(toRemove); + } + //add generic properties var genericProperties = source.Groups.FirstOrDefault(x => x.Id == -666); - if(genericProperties != null){ + if(genericProperties != null) + { foreach (var propertyTypeDisplay in genericProperties.Properties.Where(x => x.Inherited == false)) { dest.AddPropertyType(Mapper.Map(propertyTypeDisplay)); @@ -127,6 +137,7 @@ namespace Umbraco.Web.Models.Mapping config.CreateMap() .ForMember(display => display.AllowAsRoot, expression => expression.MapFrom(type => type.AllowedAsRoot)) + .ForMember(display => display.ListViewEditorName, expression => expression.Ignore()) //Ignore because this is not actually used for content types .ForMember(display => display.Trashed, expression => expression.Ignore()) diff --git a/src/Umbraco.Web/Models/Mapping/DataTypeModelMapper.cs b/src/Umbraco.Web/Models/Mapping/DataTypeModelMapper.cs index 1530787d7e..97f08bc695 100644 --- a/src/Umbraco.Web/Models/Mapping/DataTypeModelMapper.cs +++ b/src/Umbraco.Web/Models/Mapping/DataTypeModelMapper.cs @@ -34,20 +34,28 @@ namespace Umbraco.Web.Models.Mapping Constants.System.DefaultMembersListViewDataTypeId }; - config.CreateMap(); + config.CreateMap() + .ForMember(x => x.IsSystemDataType, expression => expression.Ignore()) + .ForMember(x => x.Id, expression => expression.Ignore()) + .ForMember(x => x.Trashed, expression => expression.Ignore()) + .ForMember(x => x.Key, expression => expression.Ignore()) + .ForMember(x => x.ParentId, expression => expression.Ignore()) + .ForMember(x => x.Path, expression => expression.Ignore()) + .ForMember(x => x.AdditionalData, expression => expression.Ignore()); config.CreateMap() .ForMember(x => x.Icon, expression => expression.Ignore()) .ForMember(x => x.Alias, expression => expression.Ignore()) + .ForMember(x => x.Group, expression => expression.Ignore()) .ForMember(x => x.IsSystemDataType, expression => expression.MapFrom(definition => systemIds.Contains(definition.Id))) - .AfterMap( (def,basic) => + .AfterMap((def, basic) => { var editor = PropertyEditorResolver.Current.GetByAlias(def.PropertyEditorAlias); - if(editor != null){ + if (editor != null) + { basic.Group = editor.Group; basic.Icon = editor.Icon; } - }); config.CreateMap() @@ -59,7 +67,17 @@ namespace Umbraco.Web.Models.Mapping .ForMember(x => x.Notifications, expression => expression.Ignore()) .ForMember(x => x.Icon, expression => expression.Ignore()) .ForMember(x => x.Alias, expression => expression.Ignore()) - .ForMember(x => x.IsSystemDataType, expression => expression.MapFrom(definition => systemIds.Contains(definition.Id))); + .ForMember(x => x.Group, expression => expression.Ignore()) + .ForMember(x => x.IsSystemDataType, expression => expression.MapFrom(definition => systemIds.Contains(definition.Id))) + .AfterMap((def, basic) => + { + var editor = PropertyEditorResolver.Current.GetByAlias(def.PropertyEditorAlias); + if (editor != null) + { + basic.Group = editor.Group; + basic.Icon = editor.Icon; + } + }); //gets a list of PreValueFieldDisplay objects from the data type definition config.CreateMap>() diff --git a/src/Umbraco.Web/Models/Mapping/MemberTypeModelMapper.cs b/src/Umbraco.Web/Models/Mapping/MemberTypeModelMapper.cs index 54d726b8e5..b03b7a6ebd 100644 --- a/src/Umbraco.Web/Models/Mapping/MemberTypeModelMapper.cs +++ b/src/Umbraco.Web/Models/Mapping/MemberTypeModelMapper.cs @@ -46,6 +46,8 @@ namespace Umbraco.Web.Models.Mapping //only map id if set to something higher then zero .ForMember(dto => dto.Id, expression => expression.Condition(display => (Convert.ToInt32(display.Id) > 0))) .ForMember(dto => dto.Id, expression => expression.MapFrom(display => Convert.ToInt32(display.Id))) + .ForMember(dto => dto.AllowedAsRoot, expression => expression.Ignore()) + .ForMember(dto => dto.IsContainer, expression => expression.Ignore()) .ForMember(dto => dto.CreatorId, expression => expression.Ignore()) .ForMember(dto => dto.Level, expression => expression.Ignore()) .ForMember(dto => dto.SortOrder, expression => expression.Ignore()) diff --git a/src/Umbraco.Web/Models/Mapping/PropertyTypeGroupResolver.cs b/src/Umbraco.Web/Models/Mapping/PropertyTypeGroupResolver.cs index c34a1acc1f..ae300a824e 100644 --- a/src/Umbraco.Web/Models/Mapping/PropertyTypeGroupResolver.cs +++ b/src/Umbraco.Web/Models/Mapping/PropertyTypeGroupResolver.cs @@ -1,180 +1,192 @@ -using AutoMapper; -using System; -using System.Collections.Generic; -using System.Linq; -using System.Text; -using System.Threading.Tasks; -using Umbraco.Core; -using Umbraco.Core.Models; -using Umbraco.Core.PropertyEditors; -using Umbraco.Web.Models.ContentEditing; - -namespace Umbraco.Web.Models.Mapping -{ - - - internal class PropertyTypeGroupResolver : ValueResolver> - { - private readonly ApplicationContext _applicationContext; - private readonly Lazy _propertyEditorResolver; - - public PropertyTypeGroupResolver(ApplicationContext applicationContext, Lazy propertyEditorResolver) - { - _applicationContext = applicationContext; - _propertyEditorResolver = propertyEditorResolver; - } - - - protected override IEnumerable ResolveCore(IContentTypeComposition source) - { - var groups = new Dictionary(); - - //for storing generic properties - var genericProperties = new List(); - - - //iterate through all composite types - foreach (var ct in source.ContentTypeComposition) - { - //process each tab - foreach(var tab in ct.CompositionPropertyGroups){ - var group = new PropertyGroupDisplay() { Id = tab.Id, Inherited = true, Name = tab.Name, SortOrder = tab.SortOrder }; - group.ContentTypeId = ct.Id; - group.ParentTabContentTypes = new[] { ct.Id }; - group.ParentTabContentTypeNames = new[] { ct.Name }; - - if (tab.ParentId.HasValue) - group.ParentGroupId = tab.ParentId.Value; - - group.Properties = MapProperties(tab.PropertyTypes, ct, tab.Id, true); - groups.Add(tab.Id, group); - } - - //process inherited generic properties - var inheritedGenProperties = ct.CompositionPropertyTypes.Where(x => x.PropertyGroupId == null); - if (inheritedGenProperties.Any()) - genericProperties.AddRange(MapProperties(inheritedGenProperties, ct, 0, true)); - } - - - - //pull from own groups - foreach (var ownTab in source.CompositionPropertyGroups) - { - PropertyGroupDisplay group; - - //if already added - if (groups.ContainsKey(ownTab.Id)) - group = groups[ownTab.Id]; - - //if parent - else if (ownTab.ParentId.HasValue && groups.ContainsKey(ownTab.ParentId.Value)) - group = groups[ownTab.ParentId.Value]; - - else - { - //if own - group = new PropertyGroupDisplay() { Id = ownTab.Id, Inherited = false, Name = ownTab.Name, SortOrder = ownTab.SortOrder, ContentTypeId = source.Id }; - groups.Add(ownTab.Id, group); - } - - //merge the properties - var mergedProperties = new List(); - mergedProperties.AddRange(group.Properties); - - var newproperties = MapProperties( ownTab.PropertyTypes , source, ownTab.Id, false).Where(x => mergedProperties.Any( y => y.Id == x.Id ) == false); - mergedProperties.AddRange(newproperties); - - group.Properties = mergedProperties.OrderBy(x => x.SortOrder); - } - - - //get all generic properties not already mapped to the generic props collection - var ownGenericProperties = source.CompositionPropertyTypes.Where(x => x.PropertyGroupId == null && !genericProperties.Any(y => y.Id == x.Id)); - genericProperties.AddRange(MapProperties(ownGenericProperties, source, 0, false)); - - if (genericProperties.Any()) - { - var genericTab = new PropertyGroupDisplay() { Id = -666, Name = "Generic properties", ParentGroupId = 0, ContentTypeId = source.Id, SortOrder = 999, Inherited = false }; - genericTab.Properties = genericProperties; - groups.Add(0, genericTab); - } - - - //merge tabs based on names (magic and insanity) - var nameGroupedGroups = groups.Values.GroupBy(x => x.Name); - if (nameGroupedGroups.Any(x => x.Count() > 1)) - { - var sortedGroups = new List(); - - foreach (var groupOfGroups in nameGroupedGroups) - { - //single name groups - if(groupOfGroups.Count() == 1) - sortedGroups.Add(groupOfGroups.First()); - else{ - //multiple name groups - - //find the mother tab - if we have our own use it. otherwise pick a random inherited one - since it wont matter - var mainTab = groupOfGroups.FirstOrDefault(x => x.Inherited == false); - if (mainTab == null) - mainTab = groupOfGroups.First(); - - - //take all properties from all the other tabs and merge into one tab - var properties = new List(); +using AutoMapper; +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; +using Umbraco.Core; +using Umbraco.Core.Models; +using Umbraco.Core.PropertyEditors; +using Umbraco.Web.Models.ContentEditing; + +namespace Umbraco.Web.Models.Mapping +{ + + + internal class PropertyTypeGroupResolver : ValueResolver> + { + private readonly ApplicationContext _applicationContext; + private readonly Lazy _propertyEditorResolver; + + public PropertyTypeGroupResolver(ApplicationContext applicationContext, Lazy propertyEditorResolver) + { + _applicationContext = applicationContext; + _propertyEditorResolver = propertyEditorResolver; + } + + /// + /// Will recursively check all compositions (of compositions) to find the content type that contains the + /// tabId being searched for. + /// + /// + /// + /// + private IContentTypeComposition GetContentTypeFromTabId(IContentTypeComposition ct, int tabId) + { + if (ct.PropertyGroups.Any(x => x.Id == tabId)) return ct; + + foreach (var composition in ct.ContentTypeComposition) + { + var found = GetContentTypeFromTabId(composition, tabId); + if (found != null) return found; + } + + return null; + } + + protected override IEnumerable ResolveCore(IContentTypeComposition source) + { + var groups = new Dictionary(); + + //for storing generic properties + var genericProperties = new List(); + + //add groups directly assigned to this content type + foreach (var tab in source.PropertyGroups) + { + var group = new PropertyGroupDisplay() + { + Id = tab.Id, Inherited = false, Name = tab.Name, SortOrder = tab.SortOrder, ContentTypeId = source.Id + }; + + if (tab.ParentId.HasValue) + group.ParentGroupId = tab.ParentId.Value; + + group.Properties = MapProperties(tab.PropertyTypes, source, tab.Id, false); + groups.Add(tab.Id, group); + } + + //add groups not assigned to this content type (via compositions) + foreach (var tab in source.CompositionPropertyGroups) + { + if (groups.ContainsKey(tab.Id)) continue; + + var composition = GetContentTypeFromTabId(source, tab.Id); + if (composition == null) + throw new InvalidOperationException("The tabId " + tab.Id + " was not found on any of the content type's compositions"); + + var group = new PropertyGroupDisplay() + { + Id = tab.Id, Inherited = true, Name = tab.Name, SortOrder = tab.SortOrder, ContentTypeId = composition.Id, + ParentTabContentTypes = new[] {composition.Id}, + ParentTabContentTypeNames = new[] {composition.Name} + }; + + if (tab.ParentId.HasValue) + group.ParentGroupId = tab.ParentId.Value; + + group.Properties = MapProperties(tab.PropertyTypes, composition, tab.Id, true); + groups.Add(tab.Id, group); + } + + //process generic properties assigned to this content item (without a group) + + //NOTE: -666 is just a thing that is checked during mapping the other direction, it's a 'special' id + + var entityGenericProperties = source.PropertyTypes.Where(x => x.PropertyGroupId == null); + genericProperties.AddRange(MapProperties(entityGenericProperties, source, -666, false)); + + //process generic properties from compositions (ensures properties are flagged as inherited) + var currentGenericPropertyIds = genericProperties.Select(x => x.Id).ToArray(); + var compositionGenericProperties = source.CompositionPropertyTypes + .Where(x => x.PropertyGroupId == null && currentGenericPropertyIds.Contains(x.Id) == false); + genericProperties.AddRange(MapProperties(compositionGenericProperties, source, -666, true)); + + //now add the group if there are any generic props + if (genericProperties.Any()) + { + var genericTab = new PropertyGroupDisplay + { + Id = -666, Name = "Generic properties", ParentGroupId = 0, ContentTypeId = source.Id, SortOrder = 999, Inherited = false, Properties = genericProperties + }; + groups.Add(0, genericTab); + } + + + //merge tabs based on names (magic and insanity) + var nameGroupedGroups = groups.Values.GroupBy(x => x.Name).ToArray(); + if (nameGroupedGroups.Any(x => x.Count() > 1)) + { + var sortedGroups = new List(); + + foreach (var groupOfGroups in nameGroupedGroups) + { + //single name groups + if (groupOfGroups.Count() == 1) + { + sortedGroups.Add(groupOfGroups.First()); + } + else + { + //multiple name groups + + //find the mother tab - if we have our own use it. otherwise pick a random inherited one - since it wont matter + var mainTab = groupOfGroups.FirstOrDefault(x => x.Inherited == false) ?? groupOfGroups.First(); + + //take all properties from all the other tabs and merge into one tab + var properties = new List(); properties.AddRange(groupOfGroups.Where(x => x.Id != mainTab.Id).SelectMany(x => x.Properties)); - properties.AddRange(mainTab.Properties); - mainTab.Properties = properties; - - //lock the tab - mainTab.Inherited = true; - + properties.AddRange(mainTab.Properties); + mainTab.Properties = properties; + + //lock the tab + mainTab.Inherited = true; + //collect all the involved content types var parents = groupOfGroups.Where(x => x.ContentTypeId != source.Id).ToList(); - mainTab.ParentTabContentTypes = parents.Select(x => x.ContentTypeId); - mainTab.ParentTabContentTypeNames = parents.SelectMany(x => x.ParentTabContentTypeNames); - sortedGroups.Add(mainTab); - } - } - - return sortedGroups.OrderBy(x => x.SortOrder); - } - - - return groups.Values.OrderBy(x => x.SortOrder); - } - - private IEnumerable MapProperties(IEnumerable properties, IContentTypeBase contentType, int groupId, bool inherited) - { - var mappedProperties = new List(); - foreach (var p in properties.Where(x => x.DataTypeDefinitionId != 0) ) - { - var editor = _propertyEditorResolver.Value.GetByAlias(p.PropertyEditorAlias); - var preVals = _applicationContext.Services.DataTypeService.GetPreValuesCollectionByDataTypeId(p.DataTypeDefinitionId); - - mappedProperties.Add( - new PropertyTypeDisplay() - { - Id = p.Id, - Alias = p.Alias, - Description = p.Description, - Editor = p.PropertyEditorAlias, - Validation = new PropertyTypeValidation() { Mandatory = p.Mandatory, Pattern = p.ValidationRegExp }, - Label = p.Name, - View = editor.ValueEditor.View, - Config = editor.PreValueEditor.ConvertDbToEditor(editor.DefaultPreValues, preVals) , - Value = "", - ContentTypeId = contentType.Id, - ContentTypeName = contentType.Name, - GroupId = groupId, - Inherited = inherited, - DataTypeId = p.DataTypeDefinitionId, - SortOrder = p.SortOrder - }); - } - - return mappedProperties; - } - } -} + mainTab.ParentTabContentTypes = parents.SelectMany(x => x.ParentTabContentTypes).ToArray(); + mainTab.ParentTabContentTypeNames = parents.SelectMany(x => x.ParentTabContentTypeNames).ToArray(); + sortedGroups.Add(mainTab); + } + } + + return sortedGroups.OrderBy(x => x.SortOrder); + } + + + return groups.Values.OrderBy(x => x.SortOrder); + } + + private IEnumerable MapProperties(IEnumerable properties, IContentTypeBase contentType, int groupId, bool inherited) + { + var mappedProperties = new List(); + foreach (var p in properties.Where(x => x.DataTypeDefinitionId != 0) ) + { + var editor = _propertyEditorResolver.Value.GetByAlias(p.PropertyEditorAlias); + var preVals = _applicationContext.Services.DataTypeService.GetPreValuesCollectionByDataTypeId(p.DataTypeDefinitionId); + + mappedProperties.Add( + new PropertyTypeDisplay() + { + Id = p.Id, + Alias = p.Alias, + Description = p.Description, + Editor = p.PropertyEditorAlias, + Validation = new PropertyTypeValidation() { Mandatory = p.Mandatory, Pattern = p.ValidationRegExp }, + Label = p.Name, + View = editor.ValueEditor.View, + Config = editor.PreValueEditor.ConvertDbToEditor(editor.DefaultPreValues, preVals) , + Value = "", + ContentTypeId = contentType.Id, + ContentTypeName = contentType.Name, + GroupId = groupId, + Inherited = inherited, + DataTypeId = p.DataTypeDefinitionId, + SortOrder = p.SortOrder + }); + } + + return mappedProperties; + } + } +} diff --git a/src/Umbraco.Web/PropertyEditors/FileUploadPropertyEditor.cs b/src/Umbraco.Web/PropertyEditors/FileUploadPropertyEditor.cs index b74109b555..72beb09e69 100644 --- a/src/Umbraco.Web/PropertyEditors/FileUploadPropertyEditor.cs +++ b/src/Umbraco.Web/PropertyEditors/FileUploadPropertyEditor.cs @@ -44,6 +44,8 @@ namespace Umbraco.Web.PropertyEditors args.MediaFilesToDelete.AddRange(ServiceDeleted(args.DeletedEntities.Cast())); ContentService.EmptiedRecycleBin += (sender, args) => args.Files.AddRange(ServiceEmptiedRecycleBin(args.AllPropertyData)); + MemberService.Deleted += (sender, args) => + args.MediaFilesToDelete.AddRange(ServiceDeleted(args.DeletedEntities.Cast())); } /// diff --git a/src/Umbraco.Web/PropertyEditors/ImageCropperPropertyEditor.cs b/src/Umbraco.Web/PropertyEditors/ImageCropperPropertyEditor.cs index 32e5371929..9858217a5b 100644 --- a/src/Umbraco.Web/PropertyEditors/ImageCropperPropertyEditor.cs +++ b/src/Umbraco.Web/PropertyEditors/ImageCropperPropertyEditor.cs @@ -40,6 +40,8 @@ namespace Umbraco.Web.PropertyEditors args.MediaFilesToDelete.AddRange(ServiceDeleted(args.DeletedEntities.Cast())); ContentService.EmptiedRecycleBin += (sender, args) => args.Files.AddRange(ServiceEmptiedRecycleBin(args.AllPropertyData)); + MemberService.Deleted += (sender, args) => + args.MediaFilesToDelete.AddRange(ServiceDeleted(args.DeletedEntities.Cast())); } /// diff --git a/src/Umbraco.Web/PublishedCache/XmlPublishedCache/PublishedMediaCache.cs b/src/Umbraco.Web/PublishedCache/XmlPublishedCache/PublishedMediaCache.cs index a10d110255..2e437ccc97 100644 --- a/src/Umbraco.Web/PublishedCache/XmlPublishedCache/PublishedMediaCache.cs +++ b/src/Umbraco.Web/PublishedCache/XmlPublishedCache/PublishedMediaCache.cs @@ -218,7 +218,7 @@ namespace Umbraco.Web.PublishedCache.XmlPublishedCache } } - LogHelper.Debug( + LogHelper.Warn( "Could not retrieve media {0} from Examine index, reverting to looking up media via legacy library.GetMedia method", () => id); @@ -236,7 +236,7 @@ namespace Umbraco.Web.PublishedCache.XmlPublishedCache : ConvertFromXPathNavigator(media.Current); } - LogHelper.Debug( + LogHelper.Warn( "Could not retrieve media {0} from Examine index or from legacy library.GetMedia method", () => id); diff --git a/src/Umbraco.Web/PublishedCache/XmlPublishedCache/XmlCacheFilePersister.cs b/src/Umbraco.Web/PublishedCache/XmlPublishedCache/XmlCacheFilePersister.cs index 137ed11482..ef84f31473 100644 --- a/src/Umbraco.Web/PublishedCache/XmlPublishedCache/XmlCacheFilePersister.cs +++ b/src/Umbraco.Web/PublishedCache/XmlPublishedCache/XmlCacheFilePersister.cs @@ -17,12 +17,11 @@ namespace Umbraco.Web.PublishedCache.XmlPublishedCache /// if multiple threads are performing publishing tasks that the file will be persisted in accordance with the final resulting /// xml structure since the file writes are queued. /// - internal class XmlCacheFilePersister : ILatchedBackgroundTask + internal class XmlCacheFilePersister : LatchedBackgroundTaskBase { private readonly IBackgroundTaskRunner _runner; private readonly content _content; private readonly ProfilingLogger _logger; - private readonly ManualResetEventSlim _latch = new ManualResetEventSlim(false); private readonly object _locko = new object(); private bool _released; private Timer _timer; @@ -39,7 +38,7 @@ namespace Umbraco.Web.PublishedCache.XmlPublishedCache private const int MaxWaitMilliseconds = 30000; // save the cache after some time (ie no more than 30s of changes) // save the cache when the app goes down - public bool RunsOnShutdown { get { return true; } } + public override bool RunsOnShutdown { get { return true; } } // initialize the first instance, which is inactive (not touched yet) public XmlCacheFilePersister(IBackgroundTaskRunner runner, content content, ProfilingLogger logger) @@ -150,21 +149,11 @@ namespace Umbraco.Web.PublishedCache.XmlPublishedCache // if running (because of shutdown) this will have no effect // else it tells the runner it is time to run the task - _latch.Set(); + Release(); } } - public WaitHandle Latch - { - get { return _latch.WaitHandle; } - } - - public bool IsLatched - { - get { return true; } - } - - public async Task RunAsync(CancellationToken token) + public override async Task RunAsync(CancellationToken token) { lock (_locko) { @@ -189,15 +178,12 @@ namespace Umbraco.Web.PublishedCache.XmlPublishedCache } } - public bool IsAsync + public override bool IsAsync { get { return true; } } - public void Dispose() - { } - - public void Run() + public override void Run() { lock (_locko) { diff --git a/src/Umbraco.Web/Scheduling/BackgroundTaskRunner.cs b/src/Umbraco.Web/Scheduling/BackgroundTaskRunner.cs index 3cac89c8de..388012930b 100644 --- a/src/Umbraco.Web/Scheduling/BackgroundTaskRunner.cs +++ b/src/Umbraco.Web/Scheduling/BackgroundTaskRunner.cs @@ -391,6 +391,7 @@ namespace Umbraco.Web.Scheduling // still latched & not running on shutdown = stop here if (dbgTask.IsLatched && dbgTask.RunsOnShutdown == false) { + dbgTask.Dispose(); // will not run TaskSourceCompleted(taskSource, token); return; } @@ -448,7 +449,7 @@ namespace Umbraco.Web.Scheduling try { - using (bgTask) // ensure it's disposed + try { if (bgTask.IsAsync) //configure await = false since we don't care about the context, we're on a background thread. @@ -456,6 +457,12 @@ namespace Umbraco.Web.Scheduling else bgTask.Run(); } + finally // ensure we disposed - unless latched (again) + { + var lbgTask = bgTask as ILatchedBackgroundTask; + if (lbgTask == null || lbgTask.IsLatched == false) + bgTask.Dispose(); + } } catch (Exception e) { diff --git a/src/Umbraco.Web/Scheduling/DelayedRecurringTaskBase.cs b/src/Umbraco.Web/Scheduling/DelayedRecurringTaskBase.cs deleted file mode 100644 index af3dedbe70..0000000000 --- a/src/Umbraco.Web/Scheduling/DelayedRecurringTaskBase.cs +++ /dev/null @@ -1,74 +0,0 @@ -using System; -using System.Threading; -using System.Threading.Tasks; - -namespace Umbraco.Web.Scheduling -{ - /// - /// Provides a base class for recurring background tasks. - /// - /// The type of the managed tasks. - internal abstract class DelayedRecurringTaskBase : RecurringTaskBase, ILatchedBackgroundTask - where T : class, IBackgroundTask - { - private readonly ManualResetEventSlim _latch; - private Timer _timer; - - protected DelayedRecurringTaskBase(IBackgroundTaskRunner runner, int delayMilliseconds, int periodMilliseconds) - : base(runner, periodMilliseconds) - { - if (delayMilliseconds > 0) - { - _latch = new ManualResetEventSlim(false); - _timer = new Timer(_ => - { - _timer.Dispose(); - _timer = null; - _latch.Set(); - }); - _timer.Change(delayMilliseconds, 0); - } - } - - protected DelayedRecurringTaskBase(DelayedRecurringTaskBase source) - : base(source) - { - // no latch on recurring instances - _latch = null; - } - - public override void Run() - { - if (_latch != null) - _latch.Dispose(); - base.Run(); - } - - public override async Task RunAsync(CancellationToken token) - { - if (_latch != null) - _latch.Dispose(); - await base.RunAsync(token); - } - - public WaitHandle Latch - { - get - { - if (_latch == null) - throw new InvalidOperationException("The task is not latched."); - return _latch.WaitHandle; - } - } - - public bool IsLatched - { - get { return _latch != null && _latch.IsSet == false; } - } - - public virtual bool RunsOnShutdown - { - get { return true; } - } - } -} diff --git a/src/Umbraco.Web/Scheduling/KeepAlive.cs b/src/Umbraco.Web/Scheduling/KeepAlive.cs index c1b43b57c6..d5ffbc811d 100644 --- a/src/Umbraco.Web/Scheduling/KeepAlive.cs +++ b/src/Umbraco.Web/Scheduling/KeepAlive.cs @@ -1,47 +1,76 @@ using System; using System.Net; +using System.Net.Http; +using System.Threading; +using System.Threading.Tasks; using Umbraco.Core; -using Umbraco.Core.Configuration; using Umbraco.Core.Configuration.UmbracoSettings; using Umbraco.Core.Logging; -using Umbraco.Core.Sync; namespace Umbraco.Web.Scheduling { - internal class KeepAlive + internal class KeepAlive : RecurringTaskBase { - public static void Start(ApplicationContext appContext, IUmbracoSettingsSection settings) + private readonly ApplicationContext _appContext; + + public KeepAlive(IBackgroundTaskRunner runner, int delayMilliseconds, int periodMilliseconds, + ApplicationContext appContext) + : base(runner, delayMilliseconds, periodMilliseconds) { - using (DisposableTimer.DebugDuration(() => "Keep alive executing", () => "Keep alive complete")) - { - var umbracoBaseUrl = ServerEnvironmentHelper.GetCurrentServerUmbracoBaseUrl( - appContext, - settings); + _appContext = appContext; + } - if (string.IsNullOrWhiteSpace(umbracoBaseUrl)) - { - LogHelper.Warn("No url for service (yet), skip."); - } - else - { - var url = string.Format("{0}ping.aspx", umbracoBaseUrl.EnsureEndsWith('/')); + public override bool PerformRun() + { + throw new NotImplementedException(); + } - try + public override async Task PerformRunAsync(CancellationToken token) + { + if (_appContext == null) return true; // repeat... + + string umbracoAppUrl = null; + + try + { + using (DisposableTimer.DebugDuration(() => "Keep alive executing", () => "Keep alive complete")) + { + umbracoAppUrl = _appContext.UmbracoApplicationUrl; + if (umbracoAppUrl.IsNullOrWhiteSpace()) { - using (var wc = new WebClient()) - { - wc.DownloadString(url); - } + LogHelper.Warn("No url for service (yet), skip."); + return true; // repeat } - catch (Exception ee) + + var url = umbracoAppUrl + "/ping.aspx"; + using (var wc = new HttpClient()) { - LogHelper.Error( - string.Format("Error in ping. The base url used in the request was: {0}, see http://our.umbraco.org/documentation/Using-Umbraco/Config-files/umbracoSettings/#ScheduledTasks documentation for details on setting a baseUrl if this is in error", umbracoBaseUrl) - , ee); + var request = new HttpRequestMessage() + { + RequestUri = new Uri(url), + Method = HttpMethod.Get + }; + + var result = await wc.SendAsync(request, token); } } } - + catch (Exception e) + { + LogHelper.Error(string.Format("Failed (at \"{0}\").", umbracoAppUrl), e); + } + + return true; // repeat + } + + public override bool IsAsync + { + get { return true; } + } + + public override bool RunsOnShutdown + { + get { return false; } } } } \ No newline at end of file diff --git a/src/Umbraco.Web/Scheduling/LatchedBackgroundTaskBase.cs b/src/Umbraco.Web/Scheduling/LatchedBackgroundTaskBase.cs new file mode 100644 index 0000000000..c024382ee8 --- /dev/null +++ b/src/Umbraco.Web/Scheduling/LatchedBackgroundTaskBase.cs @@ -0,0 +1,77 @@ +using System; +using System.Threading; +using System.Threading.Tasks; + +namespace Umbraco.Web.Scheduling +{ + internal abstract class LatchedBackgroundTaskBase : ILatchedBackgroundTask + { + private readonly ManualResetEventSlim _latch; + private bool _disposed; + + protected LatchedBackgroundTaskBase() + { + _latch = new ManualResetEventSlim(false); + } + + /// + /// Implements IBackgroundTask.Run(). + /// + public abstract void Run(); + + /// + /// Implements IBackgroundTask.RunAsync(). + /// + public abstract Task RunAsync(CancellationToken token); + + /// + /// Indicates whether the background task can run asynchronously. + /// + public abstract bool IsAsync { get; } + + public WaitHandle Latch + { + get { return _latch.WaitHandle; } + } + + public bool IsLatched + { + get { return _latch.IsSet == false; } + } + + protected void Release() + { + _latch.Set(); + } + + protected void Reset() + { + _latch.Reset(); + } + + public abstract bool RunsOnShutdown { get; } + + public void Dispose() + { + Dispose(true); + GC.SuppressFinalize(this); + } + + // the task is going to be disposed again after execution, + // unless it is latched again, thus indicating it wants to + // remain active + + protected virtual void Dispose(bool disposing) + { + // lock on _latch instead of creating a new object as _timer is + // private, non-null, readonly - so safe here + lock (_latch) + { + if (_disposed) return; + _disposed = true; + + _latch.Dispose(); + } + } + } +} diff --git a/src/Umbraco.Web/Scheduling/LogScrubber.cs b/src/Umbraco.Web/Scheduling/LogScrubber.cs index 14f534653d..f920b5bb9d 100644 --- a/src/Umbraco.Web/Scheduling/LogScrubber.cs +++ b/src/Umbraco.Web/Scheduling/LogScrubber.cs @@ -7,15 +7,16 @@ using umbraco.BusinessLogic; using Umbraco.Core; using Umbraco.Core.Configuration.UmbracoSettings; using Umbraco.Core.Logging; +using Umbraco.Core.Sync; namespace Umbraco.Web.Scheduling { - internal class LogScrubber : DelayedRecurringTaskBase + internal class LogScrubber : RecurringTaskBase { private readonly ApplicationContext _appContext; private readonly IUmbracoSettingsSection _settings; - public LogScrubber(IBackgroundTaskRunner runner, int delayMilliseconds, int periodMilliseconds, + public LogScrubber(IBackgroundTaskRunner runner, int delayMilliseconds, int periodMilliseconds, ApplicationContext appContext, IUmbracoSettingsSection settings) : base(runner, delayMilliseconds, periodMilliseconds) { @@ -23,20 +24,8 @@ namespace Umbraco.Web.Scheduling _settings = settings; } - public LogScrubber(LogScrubber source) - : base(source) - { - _appContext = source._appContext; - _settings = source._settings; - } - - protected override LogScrubber GetRecurring() - { - return new LogScrubber(this); - } - // maximum age, in minutes - private int GetLogScrubbingMaximumAge(IUmbracoSettingsSection settings) + private static int GetLogScrubbingMaximumAge(IUmbracoSettingsSection settings) { var maximumAge = 24 * 60; // 24 hours, in minutes try @@ -46,7 +35,7 @@ namespace Umbraco.Web.Scheduling } catch (Exception e) { - LogHelper.Error("Unable to locate a log scrubbing maximum age. Defaulting to 24 hours.", e); + LogHelper.Error("Unable to locate a log scrubbing maximum age. Defaulting to 24 hours.", e); } return maximumAge; @@ -67,15 +56,25 @@ namespace Umbraco.Web.Scheduling return interval; } - public override void PerformRun() + public override bool PerformRun() { + if (_appContext == null) return true; // repeat... + + if (ServerEnvironmentHelper.GetStatus(_settings) == CurrentServerEnvironmentStatus.Slave) + { + LogHelper.Debug("Does not run on slave servers."); + return false; // do NOT repeat, server status comes from config and will NOT change + } + using (DisposableTimer.DebugDuration("Log scrubbing executing", "Log scrubbing complete")) { Log.CleanLogs(GetLogScrubbingMaximumAge(_settings)); - } + } + + return true; // repeat } - public override Task PerformRunAsync(CancellationToken token) + public override Task PerformRunAsync(CancellationToken token) { throw new NotImplementedException(); } diff --git a/src/Umbraco.Web/Scheduling/RecurringTaskBase.cs b/src/Umbraco.Web/Scheduling/RecurringTaskBase.cs index dc82795852..3fea70a2b8 100644 --- a/src/Umbraco.Web/Scheduling/RecurringTaskBase.cs +++ b/src/Umbraco.Web/Scheduling/RecurringTaskBase.cs @@ -6,57 +6,51 @@ namespace Umbraco.Web.Scheduling /// /// Provides a base class for recurring background tasks. /// - /// The type of the managed tasks. - internal abstract class RecurringTaskBase : IBackgroundTask - where T : class, IBackgroundTask + internal abstract class RecurringTaskBase : LatchedBackgroundTaskBase { - private readonly IBackgroundTaskRunner _runner; + private readonly IBackgroundTaskRunner _runner; private readonly int _periodMilliseconds; - private Timer _timer; - private T _recurrent; + private readonly Timer _timer; + private bool _disposed; /// - /// Initializes a new instance of the class with a tasks runner and a period. + /// Initializes a new instance of the class. /// /// The task runner. + /// The delay. /// The period. /// The task will repeat itself periodically. Use this constructor to create a new task. - protected RecurringTaskBase(IBackgroundTaskRunner runner, int periodMilliseconds) + protected RecurringTaskBase(IBackgroundTaskRunner runner, int delayMilliseconds, int periodMilliseconds) { _runner = runner; _periodMilliseconds = periodMilliseconds; - } - /// - /// Initializes a new instance of the class with a source task. - /// - /// The source task. - /// Use this constructor to create a new task from a source task in GetRecurring. - protected RecurringTaskBase(RecurringTaskBase source) - { - _runner = source._runner; - _timer = source._timer; - _periodMilliseconds = source._periodMilliseconds; + // note + // must use the single-parameter constructor on Timer to avoid it from being GC'd + // read http://stackoverflow.com/questions/4962172/why-does-a-system-timers-timer-survive-gc-but-not-system-threading-timer + + _timer = new Timer(_ => Release()); + _timer.Change(delayMilliseconds, 0); } /// /// Implements IBackgroundTask.Run(). /// /// Classes inheriting from RecurringTaskBase must implement PerformRun. - public virtual void Run() + public override void Run() { - PerformRun(); - Repeat(); + var shouldRepeat = PerformRun(); + if (shouldRepeat) Repeat(); } /// /// Implements IBackgroundTask.RunAsync(). /// /// Classes inheriting from RecurringTaskBase must implement PerformRun. - public virtual async Task RunAsync(CancellationToken token) + public override async Task RunAsync(CancellationToken token) { - await PerformRunAsync(token); - Repeat(); + var shouldRepeat = await PerformRunAsync(token); + if (shouldRepeat) Repeat(); } private void Repeat() @@ -64,53 +58,45 @@ namespace Umbraco.Web.Scheduling // again? if (_runner.IsCompleted) return; // fail fast - if (_periodMilliseconds == 0) return; + if (_periodMilliseconds == 0) return; // safe - _recurrent = GetRecurring(); - if (_recurrent == null) - { - _timer.Dispose(); - _timer = null; - return; // done - } + Reset(); // re-latch - // note - // must use the single-parameter constructor on Timer to avoid it from being GC'd - // read http://stackoverflow.com/questions/4962172/why-does-a-system-timers-timer-survive-gc-but-not-system-threading-timer - - _timer = _timer ?? new Timer(_ => _runner.TryAdd(_recurrent)); - _timer.Change(_periodMilliseconds, 0); + // try to add again (may fail if runner has completed) + // if added, re-start the timer, else kill it + if (_runner.TryAdd(this)) + _timer.Change(_periodMilliseconds, 0); + else + Dispose(true); } - /// - /// Indicates whether the background task can run asynchronously. - /// - public abstract bool IsAsync { get; } - /// /// Runs the background task. /// - public abstract void PerformRun(); + /// A value indicating whether to repeat the task. + public abstract bool PerformRun(); /// /// Runs the task asynchronously. /// /// A cancellation token. - /// A instance representing the execution of the background task. - public abstract Task PerformRunAsync(CancellationToken token); + /// A instance representing the execution of the background task, + /// and returning a value indicating whether to repeat the task. + public abstract Task PerformRunAsync(CancellationToken token); - /// - /// Gets a new occurence of the recurring task. - /// - /// A new task instance to be queued, or null to terminate the recurring task. - /// The new task instance must be created via the RecurringTaskBase(RecurringTaskBase{T} source) constructor, - /// where source is the current task, eg: return new MyTask(this); - protected abstract T GetRecurring(); + protected override void Dispose(bool disposing) + { + // lock on _timer instead of creating a new object as _timer is + // private, non-null, readonly - so safe here + lock (_timer) + { + if (_disposed) return; + _disposed = true; - /// - /// Dispose the task. - /// - public virtual void Dispose() - { } + // stop the timer + _timer.Change(Timeout.Infinite, Timeout.Infinite); + _timer.Dispose(); + } + } } } \ No newline at end of file diff --git a/src/Umbraco.Web/Scheduling/ScheduledPublishing.cs b/src/Umbraco.Web/Scheduling/ScheduledPublishing.cs index 0f7cb8c205..78a91f6341 100644 --- a/src/Umbraco.Web/Scheduling/ScheduledPublishing.cs +++ b/src/Umbraco.Web/Scheduling/ScheduledPublishing.cs @@ -10,14 +10,12 @@ using Umbraco.Web.Mvc; namespace Umbraco.Web.Scheduling { - internal class ScheduledPublishing : DelayedRecurringTaskBase + internal class ScheduledPublishing : RecurringTaskBase { private readonly ApplicationContext _appContext; private readonly IUmbracoSettingsSection _settings; - private static bool _isPublishingRunning; - - public ScheduledPublishing(IBackgroundTaskRunner runner, int delayMilliseconds, int periodMilliseconds, + public ScheduledPublishing(IBackgroundTaskRunner runner, int delayMilliseconds, int periodMilliseconds, ApplicationContext appContext, IUmbracoSettingsSection settings) : base(runner, delayMilliseconds, periodMilliseconds) { @@ -25,84 +23,56 @@ namespace Umbraco.Web.Scheduling _settings = settings; } - private ScheduledPublishing(ScheduledPublishing source) - : base(source) - { - _appContext = source._appContext; - _settings = source._settings; - } - - protected override ScheduledPublishing GetRecurring() - { - return new ScheduledPublishing(this); - } - - public override void PerformRun() + public override bool PerformRun() { throw new NotImplementedException(); } - public override async Task PerformRunAsync(CancellationToken token) - { - - if (_appContext == null) return; + public override async Task PerformRunAsync(CancellationToken token) + { + if (_appContext == null) return true; // repeat... + if (ServerEnvironmentHelper.GetStatus(_settings) == CurrentServerEnvironmentStatus.Slave) { LogHelper.Debug("Does not run on slave servers."); - return; + return false; // do NOT repeat, server status comes from config and will NOT change } using (DisposableTimer.DebugDuration(() => "Scheduled publishing executing", () => "Scheduled publishing complete")) { - if (_isPublishingRunning) return; - - _isPublishingRunning = true; - - var umbracoBaseUrl = ServerEnvironmentHelper.GetCurrentServerUmbracoBaseUrl(_appContext, _settings); + string umbracoAppUrl = null; try { - - if (string.IsNullOrWhiteSpace(umbracoBaseUrl)) + umbracoAppUrl = _appContext.UmbracoApplicationUrl; + if (umbracoAppUrl.IsNullOrWhiteSpace()) { LogHelper.Warn("No url for service (yet), skip."); + return true; // repeat } - else - { - var url = string.Format("{0}RestServices/ScheduledPublish/Index", umbracoBaseUrl.EnsureEndsWith('/')); - using (var wc = new HttpClient()) - { - var request = new HttpRequestMessage() - { - RequestUri = new Uri(url), - Method = HttpMethod.Post, - Content = new StringContent(string.Empty) - }; - //pass custom the authorization header - request.Headers.Authorization = AdminTokenAuthorizeAttribute.GetAuthenticationHeaderValue(_appContext); - try - { - var result = await wc.SendAsync(request, token); - } - catch (Exception ex) - { - LogHelper.Error("An error occurred calling scheduled publish url", ex); - } - } + var url = umbracoAppUrl + "/RestServices/ScheduledPublish/Index"; + using (var wc = new HttpClient()) + { + var request = new HttpRequestMessage() + { + RequestUri = new Uri(url), + Method = HttpMethod.Post, + Content = new StringContent(string.Empty) + }; + //pass custom the authorization header + request.Headers.Authorization = AdminTokenAuthorizeAttribute.GetAuthenticationHeaderValue(_appContext); + + var result = await wc.SendAsync(request, token); } } - catch (Exception ee) + catch (Exception e) { - LogHelper.Error( - string.Format("An error occurred with the scheduled publishing. The base url used in the request was: {0}, see http://our.umbraco.org/documentation/Using-Umbraco/Config-files/umbracoSettings/#ScheduledTasks documentation for details on setting a baseUrl if this is in error", umbracoBaseUrl) - , ee); + LogHelper.Error(string.Format("Failed (at \"{0}\").", umbracoAppUrl), e); } - finally - { - _isPublishingRunning = false; - } - } + } + + return true; // repeat } public override bool IsAsync diff --git a/src/Umbraco.Web/Scheduling/ScheduledTasks.cs b/src/Umbraco.Web/Scheduling/ScheduledTasks.cs index 1015b2d4f6..92214e5199 100644 --- a/src/Umbraco.Web/Scheduling/ScheduledTasks.cs +++ b/src/Umbraco.Web/Scheduling/ScheduledTasks.cs @@ -15,14 +15,13 @@ namespace Umbraco.Web.Scheduling // would need to be a publicly available task (URL) which isn't really very good :( // We should really be using the AdminTokenAuthorizeAttribute for this stuff - internal class ScheduledTasks : DelayedRecurringTaskBase + internal class ScheduledTasks : RecurringTaskBase { private readonly ApplicationContext _appContext; private readonly IUmbracoSettingsSection _settings; private static readonly Hashtable ScheduledTaskTimes = new Hashtable(); - private static bool _isPublishingRunning = false; - public ScheduledTasks(IBackgroundTaskRunner runner, int delayMilliseconds, int periodMilliseconds, + public ScheduledTasks(IBackgroundTaskRunner runner, int delayMilliseconds, int periodMilliseconds, ApplicationContext appContext, IUmbracoSettingsSection settings) : base(runner, delayMilliseconds, periodMilliseconds) { @@ -30,18 +29,6 @@ namespace Umbraco.Web.Scheduling _settings = settings; } - public ScheduledTasks(ScheduledTasks source) - : base(source) - { - _appContext = source._appContext; - _settings = source._settings; - } - - protected override ScheduledTasks GetRecurring() - { - return new ScheduledTasks(this); - } - private async Task ProcessTasksAsync(CancellationToken token) { var scheduledTasks = _settings.ScheduledTasks.Tasks; @@ -99,25 +86,23 @@ namespace Umbraco.Web.Scheduling } } - public override void PerformRun() + public override bool PerformRun() { throw new NotImplementedException(); } - public override async Task PerformRunAsync(CancellationToken token) + public override async Task PerformRunAsync(CancellationToken token) { + if (_appContext == null) return true; // repeat... + if (ServerEnvironmentHelper.GetStatus(_settings) == CurrentServerEnvironmentStatus.Slave) { LogHelper.Debug("Does not run on slave servers."); - return; + return false; // do NOT repeat, server status comes from config and will NOT change } using (DisposableTimer.DebugDuration(() => "Scheduled tasks executing", () => "Scheduled tasks complete")) { - if (_isPublishingRunning) return; - - _isPublishingRunning = true; - try { await ProcessTasksAsync(token); @@ -126,11 +111,9 @@ namespace Umbraco.Web.Scheduling { LogHelper.Error("Error executing scheduled task", ee); } - finally - { - _isPublishingRunning = false; - } } + + return true; // repeat } public override bool IsAsync diff --git a/src/Umbraco.Web/Scheduling/Scheduler.cs b/src/Umbraco.Web/Scheduling/Scheduler.cs index fff6261401..f1f48f141a 100644 --- a/src/Umbraco.Web/Scheduling/Scheduler.cs +++ b/src/Umbraco.Web/Scheduling/Scheduler.cs @@ -1,11 +1,7 @@ -using System; -using System.Threading; -using System.Web; +using System.Web; using Umbraco.Core; using Umbraco.Core.Configuration; -using Umbraco.Core.Configuration.UmbracoSettings; using Umbraco.Core.Logging; -using Umbraco.Core.Sync; namespace Umbraco.Web.Scheduling { @@ -18,7 +14,7 @@ namespace Umbraco.Web.Scheduling /// internal sealed class Scheduler : ApplicationEventHandler { - private static Timer _pingTimer; + private static BackgroundTaskRunner _keepAliveRunner; private static BackgroundTaskRunner _publishingRunner; private static BackgroundTaskRunner _tasksRunner; private static BackgroundTaskRunner _scrubberRunner; @@ -48,30 +44,24 @@ namespace Umbraco.Web.Scheduling LogHelper.Debug(() => "Initializing the scheduler"); // backgrounds runners are web aware, if the app domain dies, these tasks will wind down correctly + _keepAliveRunner = new BackgroundTaskRunner("KeepAlive", applicationContext.ProfilingLogger.Logger); _publishingRunner = new BackgroundTaskRunner("ScheduledPublishing", applicationContext.ProfilingLogger.Logger); _tasksRunner = new BackgroundTaskRunner("ScheduledTasks", applicationContext.ProfilingLogger.Logger); _scrubberRunner = new BackgroundTaskRunner("LogScrubber", applicationContext.ProfilingLogger.Logger); var settings = UmbracoConfig.For.UmbracoSettings(); - // note - // must use the single-parameter constructor on Timer to avoid it from being GC'd - // also make the timer static to ensure further GC safety - // read http://stackoverflow.com/questions/4962172/why-does-a-system-timers-timer-survive-gc-but-not-system-threading-timer - - // ping/keepalive - no need for a background runner - does not need to be web aware, ok if the app domain dies - _pingTimer = new Timer(state => KeepAlive.Start(applicationContext, UmbracoConfig.For.UmbracoSettings())); - _pingTimer.Change(60000, 300000); + // ping/keepalive + // on all servers + _keepAliveRunner.Add(new KeepAlive(_keepAliveRunner, 60000, 300000, applicationContext)); // scheduled publishing/unpublishing // install on all, will only run on non-slaves servers - // both are delayed recurring tasks _publishingRunner.Add(new ScheduledPublishing(_publishingRunner, 60000, 60000, applicationContext, settings)); _tasksRunner.Add(new ScheduledTasks(_tasksRunner, 60000, 60000, applicationContext, settings)); // log scrubbing - // install & run on all servers - // LogScrubber is a delayed recurring task + // install on all, will only run on non-slaves servers _scrubberRunner.Add(new LogScrubber(_scrubberRunner, 60000, LogScrubber.GetLogScrubbingInterval(settings), applicationContext, settings)); } } diff --git a/src/Umbraco.Web/Security/Identity/AppBuilderExtensions.cs b/src/Umbraco.Web/Security/Identity/AppBuilderExtensions.cs index a9a884a2e7..58a77d91cf 100644 --- a/src/Umbraco.Web/Security/Identity/AppBuilderExtensions.cs +++ b/src/Umbraco.Web/Security/Identity/AppBuilderExtensions.cs @@ -55,6 +55,9 @@ namespace Umbraco.Web.Security.Identity appContext.Services.UserService, appContext.Services.ExternalLoginService, userMembershipProvider)); + + //Create a sign in manager per request + app.CreatePerOwinContext(BackOfficeSignInManager.Create); } /// @@ -82,6 +85,9 @@ namespace Umbraco.Web.Security.Identity options, customUserStore, userMembershipProvider)); + + //Create a sign in manager per request + app.CreatePerOwinContext(BackOfficeSignInManager.Create); } /// @@ -104,6 +110,9 @@ namespace Umbraco.Web.Security.Identity //Configure Umbraco user manager to be created per request app.CreatePerOwinContext(userManager); + + //Create a sign in manager per request + app.CreatePerOwinContext(BackOfficeSignInManager.Create); } /// diff --git a/src/Umbraco.Web/Security/Identity/AuthenticationOptionsExtensions.cs b/src/Umbraco.Web/Security/Identity/AuthenticationOptionsExtensions.cs index 43b995bb06..97b7e85e37 100644 --- a/src/Umbraco.Web/Security/Identity/AuthenticationOptionsExtensions.cs +++ b/src/Umbraco.Web/Security/Identity/AuthenticationOptionsExtensions.cs @@ -7,6 +7,31 @@ namespace Umbraco.Web.Security.Identity { public static class AuthenticationOptionsExtensions { + /// + /// Used during the External authentication process to assign external sign-in options + /// that are used by the Umbraco authentication process. + /// + /// + /// + public static void SetExternalSignInAutoLinkOptions( + this AuthenticationOptions authOptions, + ExternalSignInAutoLinkOptions options) + { + authOptions.Description.Properties["ExternalSignInAutoLinkOptions"] = options; + } + + /// + /// Used during the External authentication process to retrieve external sign-in options + /// that have been set with SetExternalAuthenticationOptions + /// + /// + public static ExternalSignInAutoLinkOptions GetExternalAuthenticationOptions(this AuthenticationDescription authenticationDescription) + { + if (authenticationDescription.Properties.ContainsKey("ExternalSignInAutoLinkOptions") == false) return null; + var options = authenticationDescription.Properties["ExternalSignInAutoLinkOptions"] as ExternalSignInAutoLinkOptions; + return options; + } + /// /// Configures the properties of the authentication description instance for use with Umbraco back office /// diff --git a/src/Umbraco.Web/Security/Identity/ExternalSignInAutoLinkOptions.cs b/src/Umbraco.Web/Security/Identity/ExternalSignInAutoLinkOptions.cs new file mode 100644 index 0000000000..832f0b3a30 --- /dev/null +++ b/src/Umbraco.Web/Security/Identity/ExternalSignInAutoLinkOptions.cs @@ -0,0 +1,77 @@ +using System; +using Microsoft.AspNet.Identity.Owin; +using Microsoft.Owin; +using Umbraco.Core; +using Umbraco.Core.Configuration; +using Umbraco.Core.Models.Identity; + +namespace Umbraco.Web.Security.Identity +{ + /// + /// Options used to configure auto-linking external OAuth providers + /// + public sealed class ExternalSignInAutoLinkOptions + { + public ExternalSignInAutoLinkOptions( + bool autoLinkExternalAccount = false, + string defaultUserType = "editor", + string[] defaultAllowedSections = null, + string defaultCulture = null) + { + Mandate.ParameterNotNullOrEmpty(defaultUserType, "defaultUserType"); + + _defaultUserType = defaultUserType; + _defaultAllowedSections = defaultAllowedSections ?? new[] { "content", "media" }; + _autoLinkExternalAccount = autoLinkExternalAccount; + _defaultCulture = defaultCulture ?? GlobalSettings.DefaultUILanguage; + } + + private readonly string _defaultUserType; + + /// + /// A callback executed during account auto-linking and before the user is persisted + /// + public Action OnAutoLinking { get; set; } + + /// + /// The default User Type alias to use for auto-linking users + /// + public string GetDefaultUserType(UmbracoContext umbracoContext, ExternalLoginInfo loginInfo) + { + return _defaultUserType; + } + + private readonly string[] _defaultAllowedSections; + + /// + /// The default allowed sections to use for auto-linking users + /// + public string[] GetDefaultAllowedSections(UmbracoContext umbracoContext, ExternalLoginInfo loginInfo) + { + return _defaultAllowedSections; + } + + private readonly bool _autoLinkExternalAccount; + + /// + /// For private external auth providers such as Active Directory, which when set to true will automatically + /// create a local user if the external provider login was successful. + /// + /// For public auth providers this should always be false!!! + /// + public bool ShouldAutoLinkExternalAccount(UmbracoContext umbracoContext, ExternalLoginInfo loginInfo) + { + return _autoLinkExternalAccount; + } + + private readonly string _defaultCulture; + + /// + /// The default Culture to use for auto-linking users + /// + public string GetDefaultCulture(UmbracoContext umbracoContext, ExternalLoginInfo loginInfo) + { + return _defaultCulture; + } + } +} \ No newline at end of file diff --git a/src/Umbraco.Web/Security/Identity/IUmbracoBackOfficeTwoFactorOptions.cs b/src/Umbraco.Web/Security/Identity/IUmbracoBackOfficeTwoFactorOptions.cs new file mode 100644 index 0000000000..54d1d6bdce --- /dev/null +++ b/src/Umbraco.Web/Security/Identity/IUmbracoBackOfficeTwoFactorOptions.cs @@ -0,0 +1,12 @@ +using Microsoft.Owin; + +namespace Umbraco.Web.Security.Identity +{ + /// + /// Used to display a custom view in the back office if developers choose to implement their own custom 2 factor authentication + /// + public interface IUmbracoBackOfficeTwoFactorOptions + { + string GetTwoFactorView(IOwinContext owinContext, UmbracoContext umbracoContext, string username); + } +} \ No newline at end of file diff --git a/src/Umbraco.Web/Security/Identity/OwinExtensions.cs b/src/Umbraco.Web/Security/Identity/OwinExtensions.cs index 4b83f97bd3..ceb0bdafb2 100644 --- a/src/Umbraco.Web/Security/Identity/OwinExtensions.cs +++ b/src/Umbraco.Web/Security/Identity/OwinExtensions.cs @@ -5,12 +5,13 @@ namespace Umbraco.Web.Security.Identity { internal static class OwinExtensions { + /// /// Nasty little hack to get httpcontextbase from an owin context /// /// /// - public static HttpContextBase HttpContextFromOwinContext(this IOwinContext owinContext) + internal static HttpContextBase HttpContextFromOwinContext(this IOwinContext owinContext) { return owinContext.Get(typeof(HttpContextBase).FullName); } diff --git a/src/Umbraco.Web/Security/WebSecurity.cs b/src/Umbraco.Web/Security/WebSecurity.cs index 463b2c84e3..d3d6f76999 100644 --- a/src/Umbraco.Web/Security/WebSecurity.cs +++ b/src/Umbraco.Web/Security/WebSecurity.cs @@ -323,7 +323,7 @@ namespace Umbraco.Web.Security // since the authentication happens in the Module, that authentication also checks the ticket expiry. We don't // need to check it a second time because that requires another decryption phase and nothing can tamper with it during the request. - if (_httpContext.User.Identity.IsAuthenticated == false) + if (IsAuthenticated() == false) { //There is no user if (throwExceptions) throw new InvalidOperationException("The user has no umbraco contextid - try logging in"); @@ -403,11 +403,22 @@ namespace Umbraco.Web.Security { } } - + + /// + /// Ensures that a back office user is logged in + /// + /// + public bool IsAuthenticated() + { + return _httpContext.User.Identity.IsAuthenticated && _httpContext.GetCurrentIdentity(false) != null; + } + protected override void DisposeResources() { _httpContext = null; _applicationContext = null; } + + } } diff --git a/src/Umbraco.Web/Umbraco.Web.csproj b/src/Umbraco.Web/Umbraco.Web.csproj index 0df815b5f6..656580be21 100644 --- a/src/Umbraco.Web/Umbraco.Web.csproj +++ b/src/Umbraco.Web/Umbraco.Web.csproj @@ -105,9 +105,9 @@ False ..\packages\AutoMapper.3.3.1\lib\net40\AutoMapper.Net4.dll - + False - ..\packages\ClientDependency.1.8.3.1\lib\net45\ClientDependency.Core.dll + ..\packages\ClientDependency.1.8.4\lib\net45\ClientDependency.Core.dll False @@ -134,11 +134,11 @@ False - ..\packages\Microsoft.AspNet.Identity.Core.2.2.0\lib\net45\Microsoft.AspNet.Identity.Core.dll + ..\packages\Microsoft.AspNet.Identity.Core.2.2.1\lib\net45\Microsoft.AspNet.Identity.Core.dll False - ..\packages\Microsoft.AspNet.Identity.Owin.2.2.0\lib\net45\Microsoft.AspNet.Identity.Owin.dll + ..\packages\Microsoft.AspNet.Identity.Owin.2.2.1\lib\net45\Microsoft.AspNet.Identity.Owin.dll @@ -306,6 +306,8 @@ + + @@ -314,6 +316,7 @@ + @@ -565,7 +568,6 @@ - diff --git a/src/Umbraco.Web/UmbracoModule.cs b/src/Umbraco.Web/UmbracoModule.cs index f93347aa20..838dea94b8 100644 --- a/src/Umbraco.Web/UmbracoModule.cs +++ b/src/Umbraco.Web/UmbracoModule.cs @@ -36,37 +36,47 @@ namespace Umbraco.Web { #region HttpModule event handlers + private static void EnsureApplicationUrl(HttpRequestBase request) + { + var appctx = ApplicationContext.Current; + + // already initialized = ok + // note that getting ApplicationUrl will ALSO try the various settings + if (appctx.UmbracoApplicationUrl.IsNullOrWhiteSpace() == false) return; + + // so if we reach that point, nothing was configured + // use the current request as application url + + // if (HTTP and SSL not required) or (HTTPS and SSL required), + // use ports from request + // otherwise, + // if non-standard ports used, + // user may need to set baseUrl manually per + // http://our.umbraco.org/documentation/Using-Umbraco/Config-files/umbracoSettings/#ScheduledTasks + // TODO update the doc, prefer web.routing/@appUrl to scheduledTasks/@baseUrl + var port = (request.IsSecureConnection == false && GlobalSettings.UseSSL == false) + || (request.IsSecureConnection && GlobalSettings.UseSSL) + ? ":" + request.ServerVariables["SERVER_PORT"] + : ""; + + var ssl = GlobalSettings.UseSSL ? "s" : ""; // force, whatever the first request + var url = "http" + ssl + "://" + request.ServerVariables["SERVER_NAME"] + port + IOHelper.ResolveUrl(SystemDirectories.Umbraco); + + appctx.UmbracoApplicationUrl = UriUtility.TrimPathEndSlash(url); + LogHelper.Info("ApplicationUrl: " + appctx.UmbracoApplicationUrl + " (UmbracoModule request)"); + } + + /// /// Begins to process a request. /// /// static void BeginRequest(HttpContextBase httpContext) { + // ensure application url is initialized + EnsureApplicationUrl(httpContext.Request); - //we need to set the initial url in our ApplicationContext, this is so our keep alive service works and this must - //exist on a global context because the keep alive service doesn't run in a web context. - //we are NOT going to put a lock on this because locking will slow down the application and we don't really care - //if two threads write to this at the exact same time during first page hit. - //see: http://issues.umbraco.org/issue/U4-2059 - if (ApplicationContext.Current.OriginalRequestUrl.IsNullOrWhiteSpace()) - { - // If (HTTP and SSL not required) or (HTTPS and SSL required), use ports from request to configure OriginalRequestUrl. - // Otherwise, user may need to set baseUrl manually per http://our.umbraco.org/documentation/Using-Umbraco/Config-files/umbracoSettings/#ScheduledTasks if non-standard ports used. - if ((!httpContext.Request.IsSecureConnection && !GlobalSettings.UseSSL) || (httpContext.Request.IsSecureConnection && GlobalSettings.UseSSL)) - { - // Use port from request. - ApplicationContext.Current.OriginalRequestUrl = string.Format("{0}:{1}{2}", httpContext.Request.ServerVariables["SERVER_NAME"], httpContext.Request.ServerVariables["SERVER_PORT"], IOHelper.ResolveUrl(SystemDirectories.Umbraco)); - } - else - { - // Omit port entirely. - ApplicationContext.Current.OriginalRequestUrl = string.Format("{0}{1}", httpContext.Request.ServerVariables["SERVER_NAME"], IOHelper.ResolveUrl(SystemDirectories.Umbraco)); - } - - LogHelper.Info("Setting OriginalRequestUrl: " + ApplicationContext.Current.OriginalRequestUrl); - } - - // do not process if client-side request + // do not process if client-side request if (httpContext.Request.Url.IsClientSideRequest()) return; diff --git a/src/Umbraco.Web/packages.config b/src/Umbraco.Web/packages.config index 33c259c885..1ad7d7c403 100644 --- a/src/Umbraco.Web/packages.config +++ b/src/Umbraco.Web/packages.config @@ -1,13 +1,13 @@  - + - - + + diff --git a/src/Umbraco.Web/umbraco.presentation/content.cs b/src/Umbraco.Web/umbraco.presentation/content.cs index 7b9b726223..ecb21ba5b7 100644 --- a/src/Umbraco.Web/umbraco.presentation/content.cs +++ b/src/Umbraco.Web/umbraco.presentation/content.cs @@ -132,23 +132,26 @@ namespace umbraco private static readonly object DbReadSyncLock = new object(); private const string XmlContextContentItemKey = "UmbracoXmlContextContent"; - private string _umbracoXmlDiskCacheFileName = string.Empty; + private static string _umbracoXmlDiskCacheFileName = string.Empty; private volatile XmlDocument _xmlContent; /// /// Gets the path of the umbraco XML disk cache file. /// /// The name of the umbraco XML disk cache file. + public static string GetUmbracoXmlDiskFileName() + { + if (string.IsNullOrEmpty(_umbracoXmlDiskCacheFileName)) + { + _umbracoXmlDiskCacheFileName = IOHelper.MapPath(SystemFiles.ContentCacheXml); + } + return _umbracoXmlDiskCacheFileName; + } + + [Obsolete("Use the safer static GetUmbracoXmlDiskFileName() method instead to retrieve this value")] public string UmbracoXmlDiskCacheFileName { - get - { - if (string.IsNullOrEmpty(_umbracoXmlDiskCacheFileName)) - { - _umbracoXmlDiskCacheFileName = IOHelper.MapPath(SystemFiles.ContentCacheXml); - } - return _umbracoXmlDiskCacheFileName; - } + get { return GetUmbracoXmlDiskFileName(); } set { _umbracoXmlDiskCacheFileName = value; } } @@ -674,9 +677,9 @@ order by umbracoNode.level, umbracoNode.sortOrder"; { //TODO: Should there be a try/catch here in case the file is being written to while this is trying to be executed? - if (File.Exists(UmbracoXmlDiskCacheFileName)) + if (File.Exists(GetUmbracoXmlDiskFileName())) { - return new FileInfo(UmbracoXmlDiskCacheFileName).LastWriteTimeUtc; + return new FileInfo(GetUmbracoXmlDiskFileName()).LastWriteTimeUtc; } return DateTime.MinValue; diff --git a/src/Umbraco.Web/umbraco.presentation/keepAliveService.cs b/src/Umbraco.Web/umbraco.presentation/keepAliveService.cs index 6d80d8bedd..abc3425f3f 100644 --- a/src/Umbraco.Web/umbraco.presentation/keepAliveService.cs +++ b/src/Umbraco.Web/umbraco.presentation/keepAliveService.cs @@ -18,9 +18,7 @@ namespace umbraco.presentation var appContext = (ApplicationContext) sender; - //TODO: This won't always work, in load balanced scenarios ping will not work because - // this original request url will be public and not internal to the server. - var url = string.Format("http://{0}/ping.aspx", appContext.OriginalRequestUrl); + var url = appContext.UmbracoApplicationUrl + "/ping.aspx"; try { using (var wc = new WebClient()) diff --git a/src/Umbraco.Web/umbraco.presentation/umbraco/controls/ContentTypeControlNew.ascx.cs b/src/Umbraco.Web/umbraco.presentation/umbraco/controls/ContentTypeControlNew.ascx.cs index fff0ff6595..eed2947b23 100644 --- a/src/Umbraco.Web/umbraco.presentation/umbraco/controls/ContentTypeControlNew.ascx.cs +++ b/src/Umbraco.Web/umbraco.presentation/umbraco/controls/ContentTypeControlNew.ascx.cs @@ -842,7 +842,7 @@ jQuery(document).ready(function() {{ refreshDropDowns(); }}); { var tabs = _contentType.getVirtualTabs; var propertyTypeGroups = _contentType.PropertyTypeGroups.ToList(); - var dtds = cms.businesslogic.datatype.DataTypeDefinition.GetAll(); + var dtds = cms.businesslogic.datatype.DataTypeDefinition.GetAll().OrderBy(d => d.Text).ToArray(); PropertyTypes.Controls.Clear(); diff --git a/src/Umbraco.Web/umbraco.presentation/umbraco/dialogs/about.aspx.cs b/src/Umbraco.Web/umbraco.presentation/umbraco/dialogs/about.aspx.cs index 37e1f6eca9..a30cb1eb7b 100644 --- a/src/Umbraco.Web/umbraco.presentation/umbraco/dialogs/about.aspx.cs +++ b/src/Umbraco.Web/umbraco.presentation/umbraco/dialogs/about.aspx.cs @@ -1,5 +1,6 @@ using System; using System.Globalization; +using Umbraco.Core; using Umbraco.Core.Configuration; namespace umbraco.dialogs @@ -14,7 +15,7 @@ namespace umbraco.dialogs { // Put user code to initialize the page here thisYear.Text = DateTime.Now.Year.ToString(CultureInfo.InvariantCulture); - version.Text = UmbracoVersion.GetSemanticVersion().ToString(); + version.Text = UmbracoVersion.GetSemanticVersion().ToSemanticString(); } #region Web Form Designer generated code diff --git a/src/umbraco.businesslogic/BasePages/BasePage.cs b/src/umbraco.businesslogic/BasePages/BasePage.cs index 51f059dbb5..8e7f1f47e1 100644 --- a/src/umbraco.businesslogic/BasePages/BasePage.cs +++ b/src/umbraco.businesslogic/BasePages/BasePage.cs @@ -6,6 +6,7 @@ using System.Linq; using System.Web.Mvc; using System.Web.Routing; using System.Web.Security; +using System.Web.UI; using Umbraco.Core; using Umbraco.Core.Configuration; using Umbraco.Core.IO; @@ -181,7 +182,14 @@ namespace umbraco.BasePages /// public static int GetUserId() { - var identity = HttpContext.Current.GetCurrentIdentity(true); + var identity = HttpContext.Current.GetCurrentIdentity( + //DO NOT AUTO-AUTH UNLESS THE CURRENT HANDLER IS WEBFORMS! + // Without this check, anything that is using this legacy API, like ui.Text will + // automatically log the back office user in even if it is a front-end request (if there is + // a back office user logged in. This can cause problems becaues the identity is changing mid + // request. For example: http://issues.umbraco.org/issue/U4-4010 + HttpContext.Current.CurrentHandler is Page); + if (identity == null) return -1; return Convert.ToInt32(identity.Id); @@ -205,7 +213,14 @@ namespace umbraco.BasePages /// public static bool ValidateCurrentUser() { - var identity = HttpContext.Current.GetCurrentIdentity(true); + var identity = HttpContext.Current.GetCurrentIdentity( + //DO NOT AUTO-AUTH UNLESS THE CURRENT HANDLER IS WEBFORMS! + // Without this check, anything that is using this legacy API, like ui.Text will + // automatically log the back office user in even if it is a front-end request (if there is + // a back office user logged in. This can cause problems becaues the identity is changing mid + // request. For example: http://issues.umbraco.org/issue/U4-4010 + HttpContext.Current.CurrentHandler is Page); + if (identity != null) { return true; @@ -232,7 +247,14 @@ namespace umbraco.BasePages { get { - var identity = HttpContext.Current.GetCurrentIdentity(true); + var identity = HttpContext.Current.GetCurrentIdentity( + //DO NOT AUTO-AUTH UNLESS THE CURRENT HANDLER IS WEBFORMS! + // Without this check, anything that is using this legacy API, like ui.Text will + // automatically log the back office user in even if it is a front-end request (if there is + // a back office user logged in. This can cause problems becaues the identity is changing mid + // request. For example: http://issues.umbraco.org/issue/U4-4010 + HttpContext.Current.CurrentHandler is Page); + return identity == null ? "" : identity.SessionId; } set diff --git a/src/umbraco.cms/businesslogic/Dictionary.cs b/src/umbraco.cms/businesslogic/Dictionary.cs index 0d34da4615..8e76122175 100644 --- a/src/umbraco.cms/businesslogic/Dictionary.cs +++ b/src/umbraco.cms/businesslogic/Dictionary.cs @@ -93,8 +93,8 @@ namespace umbraco.cms.businesslogic [Obsolete("This is no longer used and will be removed from the codebase in future versions")] public bool IsTopMostItem() - { - return _dictionaryItem.ParentId == new Guid(Constants.Conventions.Localization.DictionaryItemRootId); + { + return _dictionaryItem.ParentId.HasValue == false; } /// @@ -105,9 +105,9 @@ namespace umbraco.cms.businesslogic get { //EnsureCache(); - if (_parent == null) + if (_parent == null && _dictionaryItem.ParentId.HasValue) { - var p = ApplicationContext.Current.Services.LocalizationService.GetDictionaryItemById(_dictionaryItem.ParentId); + var p = ApplicationContext.Current.Services.LocalizationService.GetDictionaryItemById(_dictionaryItem.ParentId.Value); if (p == null) { @@ -325,7 +325,9 @@ namespace umbraco.cms.businesslogic if (!hasKey(key)) { var item = ApplicationContext.Current.Services.LocalizationService.CreateDictionaryItemWithIdentity( - key, parentId, defaultValue); + key, + parentId == TopLevelParent ? (Guid?)null : parentId, + defaultValue); return item.Id; } diff --git a/src/umbraco.cms/packages.config b/src/umbraco.cms/packages.config index 30682b49ec..e8d51df7f8 100644 --- a/src/umbraco.cms/packages.config +++ b/src/umbraco.cms/packages.config @@ -1,6 +1,6 @@  - + diff --git a/src/umbraco.cms/umbraco.cms.csproj b/src/umbraco.cms/umbraco.cms.csproj index 242b678be9..9561c3afb9 100644 --- a/src/umbraco.cms/umbraco.cms.csproj +++ b/src/umbraco.cms/umbraco.cms.csproj @@ -106,9 +106,9 @@ false - + False - ..\packages\ClientDependency.1.8.3.1\lib\net45\ClientDependency.Core.dll + ..\packages\ClientDependency.1.8.4\lib\net45\ClientDependency.Core.dll False diff --git a/src/umbraco.controls/packages.config b/src/umbraco.controls/packages.config index 0859f3d4e9..1e49726191 100644 --- a/src/umbraco.controls/packages.config +++ b/src/umbraco.controls/packages.config @@ -1,4 +1,4 @@  - + \ No newline at end of file diff --git a/src/umbraco.controls/umbraco.controls.csproj b/src/umbraco.controls/umbraco.controls.csproj index a5c08e525a..2fb5d7174c 100644 --- a/src/umbraco.controls/umbraco.controls.csproj +++ b/src/umbraco.controls/umbraco.controls.csproj @@ -68,9 +68,9 @@ false - + False - ..\packages\ClientDependency.1.8.3.1\lib\net45\ClientDependency.Core.dll + ..\packages\ClientDependency.1.8.4\lib\net45\ClientDependency.Core.dll diff --git a/src/umbraco.editorControls/packages.config b/src/umbraco.editorControls/packages.config index 0859f3d4e9..1e49726191 100644 --- a/src/umbraco.editorControls/packages.config +++ b/src/umbraco.editorControls/packages.config @@ -1,4 +1,4 @@  - + \ No newline at end of file diff --git a/src/umbraco.editorControls/umbraco.editorControls.csproj b/src/umbraco.editorControls/umbraco.editorControls.csproj index ba28ab485a..9b669e284e 100644 --- a/src/umbraco.editorControls/umbraco.editorControls.csproj +++ b/src/umbraco.editorControls/umbraco.editorControls.csproj @@ -114,9 +114,9 @@ {651E1350-91B6-44B7-BD60-7207006D7003} Umbraco.Web - + False - ..\packages\ClientDependency.1.8.3.1\lib\net45\ClientDependency.Core.dll + ..\packages\ClientDependency.1.8.4\lib\net45\ClientDependency.Core.dll System