Rename the javascriptlibrary so it's just a service, not a helperservice :)

CONTRIBUTING.md

@@ -24,7 +24,6 @@ Remember, we're a friendly bunch and are happy with whatever contribution you mi
   * [Working with the source code](#working-with-the-source-code)
   * [What branch should I target for my contributions?](#what-branch-should-i-target-for-my-contributions)
   * [Building Umbraco from source code](#building-umbraco-from-source-code)
-  * [Keeping your Umbraco fork in sync with the main repository](#keeping-your-umbraco-fork-in-sync-with-the-main-repository)
   
 [How do I even begin?](#how-do-i-even-begin)
 
@@ -147,29 +146,6 @@ Alternatively, you can open `src\umbraco.sln` in Visual Studio 2017 ([the commun
 
 After this build completes, you should be able to hit `F5` in Visual Studio to build and run the project. A IISExpress webserver will start and the Umbraco installer will pop up in your browser, follow the directions there to get a working Umbraco install up and running.
 
-### Keeping your Umbraco fork in sync with the main repository
-
-We recommend you sync with our repository before you submit your pull request. That way, you can fix any potential merge conflicts and make our lives a little bit easier.
-
-Also, if you've submitted a pull request three weeks ago and want to work on something new, you'll want to get the latest code to build against of course.
-
-To sync your fork with this original one, you'll have to add the upstream url, you only have to do this once:
-
-```
-git remote add upstream https://github.com/umbraco/Umbraco-CMS.git
-```
-
-Then when you want to get the changes from the main repository:
-
-```
-git fetch upstream
-git rebase upstream/dev-v7
-```
-
-In this command we're syncing with the `dev-v7` branch, but you can of course choose another one if needed.
-
-(More info on how this works: [http://robots.thoughtbot.com/post/5133345960/keeping-a-git-fork-updated](http://robots.thoughtbot.com/post/5133345960/keeping-a-git-fork-updated))
-
 ## How do I even begin?
 
 Great question! The short version goes like this:

README.md

@@ -30,7 +30,7 @@ As an Open Source platform, Umbraco is more than just a CMS. We are transparent
 
 [Umbraco Cloud](https://umbraco.com) is the easiest and fastest way to use Umbraco yet with full support for all your custom .NET code and intergrations. You're up and running in less than a minute and your life will be made easier with automated upgrades and a built-in deployment engine. We offer a free 14 day trial, no credit card needed.
 
-If you want to DIY you can [download Umbraco](https://our.umbraco.org/download) either as a ZIP file or via NuGet. It's the same version of Umbraco CMS that powers Umbraco Cloud, but you'll need to find a place to host yourself and handling deployments and upgrades is all down to you.
+If you want to DIY you can [download Umbraco](https://our.umbraco.org/download) either as a ZIP file or via NuGet. It's the same version of Umbraco CMS that powers Umbraco Xloud, but you'll need to find a place to host yourself and handling deployments and upgrades is all down to you.
 
 ## Community
 

build/NuSpecs/tools/ReadmeUpgrade.txt

@@ -8,7 +8,7 @@
                                                    
 ----------------------------------------------------
 
-*** IMPORTANT NOTICE FOR UPGRADES FROM VERSIONS BELOW 7.7.0 ***
+*** IMPORTANT NOTICE FOR 7.7 UPGRADES ***
 
 Be sure to read the version specific upgrade information before proceeding:
 https://our.umbraco.org/documentation/Getting-Started/Setup/Upgrading/version-specific#version-7-7-0

src/SolutionInfo.cs

@@ -11,5 +11,5 @@ using System.Resources;
 
 [assembly: AssemblyVersion("1.0.*")]
 
-[assembly: AssemblyFileVersion("7.9.4")]
-[assembly: AssemblyInformationalVersion("7.9.4")]
+[assembly: AssemblyFileVersion("7.9.2")]
+[assembly: AssemblyInformationalVersion("7.9.2")]

src/Umbraco.Core/Configuration/UmbracoVersion.cs

@@ -6,7 +6,7 @@ namespace Umbraco.Core.Configuration
 {
     public class UmbracoVersion
     {
-        private static readonly Version Version = new Version("7.9.4");
+        private static readonly Version Version = new Version("7.9.2");
 
         /// <summary>
         /// Gets the current version of Umbraco.

src/Umbraco.Core/IO/FileSystemProviderManager.cs

@@ -2,6 +2,7 @@
 using System.Collections.Concurrent;
 using System.Collections.Generic;
 using System.Configuration;
+using System.IO;
 using System.Linq;
 using System.Reflection;
 using Umbraco.Core.Configuration;
@@ -26,6 +27,7 @@ namespace Umbraco.Core.IO
         private ShadowWrapper _xsltFileSystem;
         private ShadowWrapper _masterPagesFileSystem;
         private ShadowWrapper _mvcViewsFileSystem;
+        private ShadowWrapper _javaScriptLibraryFileSystem;
 
         #region Singleton & Constructor
 
@@ -113,6 +115,7 @@ namespace Umbraco.Core.IO
             var xsltFileSystem = new PhysicalFileSystem(SystemDirectories.Xslt);
             var masterPagesFileSystem = new PhysicalFileSystem(SystemDirectories.Masterpages);
             var mvcViewsFileSystem = new PhysicalFileSystem(SystemDirectories.MvcViews);
+            var javaScriptLibraryFileSystem = new PhysicalFileSystem(Path.Combine(SystemDirectories.Umbraco, "lib"));
 
             _macroPartialFileSystem = new ShadowWrapper(macroPartialFileSystem, "Views/MacroPartials", ScopeProvider);
             _partialViewsFileSystem = new ShadowWrapper(partialViewsFileSystem, "Views/Partials", ScopeProvider);
@@ -123,6 +126,7 @@ namespace Umbraco.Core.IO
             _xsltFileSystem = new ShadowWrapper(xsltFileSystem, "xslt", ScopeProvider);
             _masterPagesFileSystem = new ShadowWrapper(masterPagesFileSystem, "masterpages", ScopeProvider);
             _mvcViewsFileSystem = new ShadowWrapper(mvcViewsFileSystem, "Views", ScopeProvider);
+            _javaScriptLibraryFileSystem = new ShadowWrapper(javaScriptLibraryFileSystem, "Lib", ScopeProvider);
 
             // filesystems obtained from GetFileSystemProvider are already wrapped and do not need to be wrapped again
             MediaFileSystem = GetFileSystemProvider<MediaFileSystem>();
@@ -143,6 +147,7 @@ namespace Umbraco.Core.IO
         public IFileSystem2 XsltFileSystem { get { return _xsltFileSystem; } }
         public IFileSystem2 MasterPagesFileSystem { get { return _mvcViewsFileSystem; } }
         public IFileSystem2 MvcViewsFileSystem { get { return _mvcViewsFileSystem; } }
+        internal IFileSystem2 JavaScriptLibraryFileSystem { get { return _javaScriptLibraryFileSystem; } }
         public MediaFileSystem MediaFileSystem { get; private set; }
 
         #endregion

src/Umbraco.Core/ObjectExtensions.cs

@@ -140,7 +140,8 @@ namespace Umbraco.Core
                     if (underlying != null)
                     {
                         // Special case for empty strings for bools/dates which should return null if an empty string.
-                        if (input is string inputString)
+                        var inputString = input as string;
+                        if (inputString != null)
                         {
                             //TODO: Why the check against only bool/date when a string is null/empty? In what scenario can we convert to another type when the string is null or empty other than just being null?
                             if (string.IsNullOrEmpty(inputString) && (underlying == typeof(DateTime) || underlying == typeof(bool)))
@@ -167,7 +168,8 @@ namespace Umbraco.Core
                 {
                     // target is not a generic type
 
-                    if (input is string inputString)
+                    var inputString = input as string;
+                    if (inputString != null)
                     {
                         // Try convert from string, returns an Attempt if the string could be
                         // processed (either succeeded or failed), else null if we need to try
@@ -216,7 +218,8 @@ namespace Umbraco.Core
                 }
 
                 // Re-check convertables since we altered the input through recursion
-                if (input is IConvertible convertible2)
+                var convertible2 = input as IConvertible;
+                if (convertible2 != null)
                 {
                     return Attempt.Succeed(Convert.ChangeType(convertible2, target));
                 }
@@ -274,7 +277,8 @@ namespace Umbraco.Core
             {
                 if (target == typeof(int))
                 {
-                    if (int.TryParse(input, out var value))
+                    int value;
+                    if (int.TryParse(input, out value))
                     {
                         return Attempt<object>.Succeed(value);
                     }
@@ -282,26 +286,30 @@ namespace Umbraco.Core
                     // Because decimal 100.01m will happily convert to integer 100, it
                     // makes sense that string "100.01" *also* converts to integer 100.
                     var input2 = NormalizeNumberDecimalSeparator(input);
-                    return Attempt<object>.SucceedIf(decimal.TryParse(input2, out var value2), Convert.ToInt32(value2));
+                    decimal value2;
+                    return Attempt<object>.SucceedIf(decimal.TryParse(input2, out value2), Convert.ToInt32(value2));
                 }
 
                 if (target == typeof(long))
                 {
-                    if (long.TryParse(input, out var value))
+                    long value;
+                    if (long.TryParse(input, out value))
                     {
                         return Attempt<object>.Succeed(value);
                     }
 
                     // Same as int
                     var input2 = NormalizeNumberDecimalSeparator(input);
-                    return Attempt<object>.SucceedIf(decimal.TryParse(input2, out var value2), Convert.ToInt64(value2));
+                    decimal value2;
+                    return Attempt<object>.SucceedIf(decimal.TryParse(input2, out value2), Convert.ToInt64(value2));
                 }
 
                 // TODO: Should we do the decimal trick for short, byte, unsigned?
 
                 if (target == typeof(bool))
                 {
-                    if (bool.TryParse(input, out var value))
+                    bool value;
+                    if (bool.TryParse(input, out value))
                     {
                         return Attempt<object>.Succeed(value);
                     }
@@ -314,42 +322,53 @@ namespace Umbraco.Core
                 switch (Type.GetTypeCode(target))
                 {
                     case TypeCode.Int16:
-                        return Attempt<object>.SucceedIf(short.TryParse(input, out var value), value);
+                        short value;
+                        return Attempt<object>.SucceedIf(short.TryParse(input, out value), value);
 
                     case TypeCode.Double:
                         var input2 = NormalizeNumberDecimalSeparator(input);
-                        return Attempt<object>.SucceedIf(double.TryParse(input2, out var valueD), valueD);
+                        double valueD;
+                        return Attempt<object>.SucceedIf(double.TryParse(input2, out valueD), valueD);
 
                     case TypeCode.Single:
                         var input3 = NormalizeNumberDecimalSeparator(input);
-                        return Attempt<object>.SucceedIf(float.TryParse(input3, out var valueF), valueF);
+                        float valueF;
+                        return Attempt<object>.SucceedIf(float.TryParse(input3, out valueF), valueF);
 
                     case TypeCode.Char:
-                        return Attempt<object>.SucceedIf(char.TryParse(input, out var valueC), valueC);
+                        char valueC;
+                        return Attempt<object>.SucceedIf(char.TryParse(input, out valueC), valueC);
 
                     case TypeCode.Byte:
-                        return Attempt<object>.SucceedIf(byte.TryParse(input, out var valueB), valueB);
+                        byte valueB;
+                        return Attempt<object>.SucceedIf(byte.TryParse(input, out valueB), valueB);
 
                     case TypeCode.SByte:
-                        return Attempt<object>.SucceedIf(sbyte.TryParse(input, out var valueSb), valueSb);
+                        sbyte valueSb;
+                        return Attempt<object>.SucceedIf(sbyte.TryParse(input, out valueSb), valueSb);
 
                     case TypeCode.UInt32:
-                        return Attempt<object>.SucceedIf(uint.TryParse(input, out var valueU), valueU);
+                        uint valueU;
+                        return Attempt<object>.SucceedIf(uint.TryParse(input, out valueU), valueU);
 
                     case TypeCode.UInt16:
-                        return Attempt<object>.SucceedIf(ushort.TryParse(input, out var valueUs), valueUs);
+                        ushort valueUs;
+                        return Attempt<object>.SucceedIf(ushort.TryParse(input, out valueUs), valueUs);
 
                     case TypeCode.UInt64:
-                        return Attempt<object>.SucceedIf(ulong.TryParse(input, out var valueUl), valueUl);
+                        ulong valueUl;
+                        return Attempt<object>.SucceedIf(ulong.TryParse(input, out valueUl), valueUl);
                 }
             }
             else if (target == typeof(Guid))
             {
-                return Attempt<object>.SucceedIf(Guid.TryParse(input, out var value), value);
+                Guid value;
+                return Attempt<object>.SucceedIf(Guid.TryParse(input, out value), value);
             }
             else if (target == typeof(DateTime))
             {
-                if (DateTime.TryParse(input, out var value))
+                DateTime value;
+                if (DateTime.TryParse(input, out value))
                 {
                     switch (value.Kind)
                     {
@@ -369,20 +388,24 @@ namespace Umbraco.Core
             }
             else if (target == typeof(DateTimeOffset))
             {
-                return Attempt<object>.SucceedIf(DateTimeOffset.TryParse(input, out var value), value);
+                DateTimeOffset value;
+                return Attempt<object>.SucceedIf(DateTimeOffset.TryParse(input, out value), value);
             }
             else if (target == typeof(TimeSpan))
             {
-                return Attempt<object>.SucceedIf(TimeSpan.TryParse(input, out var value), value);
+                TimeSpan value;
+                return Attempt<object>.SucceedIf(TimeSpan.TryParse(input, out value), value);
             }
             else if (target == typeof(decimal))
             {
                 var input2 = NormalizeNumberDecimalSeparator(input);
-                return Attempt<object>.SucceedIf(decimal.TryParse(input2, out var value), value);
+                decimal value;
+                return Attempt<object>.SucceedIf(decimal.TryParse(input2, out value), value);
             }
             else if (input != null && target == typeof(Version))
             {
-                return Attempt<object>.SucceedIf(Version.TryParse(input, out var value), value);
+                Version value;
+                return Attempt<object>.SucceedIf(Version.TryParse(input, out value), value);
             }
 
             // E_NOTIMPL IPAddress, BigInteger
@@ -667,7 +690,8 @@ namespace Umbraco.Core
         {
             var key = new CompositeTypeTypeKey(source, target);
 
-            if (InputTypeConverterCache.TryGetValue(key, out TypeConverter typeConverter))
+            TypeConverter typeConverter;
+            if (InputTypeConverterCache.TryGetValue(key, out typeConverter))
             {
                 return typeConverter;
             }
@@ -687,7 +711,8 @@ namespace Umbraco.Core
         {
             var key = new CompositeTypeTypeKey(source, target);
 
-            if (DestinationTypeConverterCache.TryGetValue(key, out TypeConverter typeConverter))
+            TypeConverter typeConverter;
+            if (DestinationTypeConverterCache.TryGetValue(key, out typeConverter))
             {
                 return typeConverter;
             }
@@ -705,7 +730,8 @@ namespace Umbraco.Core
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         private static Type GetCachedGenericNullableType(Type type)
         {
-            if (NullableGenericCache.TryGetValue(type, out Type underlyingType))
+            Type underlyingType;
+            if (NullableGenericCache.TryGetValue(type, out underlyingType))
             {
                 return underlyingType;
             }
@@ -724,7 +750,8 @@ namespace Umbraco.Core
         private static bool GetCachedCanAssign(object input, Type source, Type target)
         {
             var key = new CompositeTypeTypeKey(source, target);
-            if (AssignableTypeCache.TryGetValue(key, out bool canConvert))
+            bool canConvert;
+            if (AssignableTypeCache.TryGetValue(key, out canConvert))
             {
                 return canConvert;
             }
@@ -743,7 +770,8 @@ namespace Umbraco.Core
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         private static bool GetCachedCanConvertToBoolean(Type type)
         {
-            if (BoolConvertCache.TryGetValue(type, out bool result))
+            bool result;
+            if (BoolConvertCache.TryGetValue(type, out result))
             {
                 return result;
             }

src/Umbraco.Core/Persistence/Migrations/Upgrades/TargetVersionSevenSevenZero/AddUserGroupTables.cs

@@ -6,7 +6,6 @@ using Umbraco.Core.Configuration;
 using Umbraco.Core.Logging;
 using Umbraco.Core.Models;
 using Umbraco.Core.Models.Rdbms;
-using Umbraco.Core.Persistence.DatabaseModelDefinitions;
 using Umbraco.Core.Persistence.SqlSyntax;
 
 namespace Umbraco.Core.Persistence.Migrations.Upgrades.TargetVersionSevenSevenZero
@@ -344,24 +343,15 @@ namespace Umbraco.Core.Persistence.Migrations.Upgrades.TargetVersionSevenSevenZe
 
             if (tables.InvariantContains("umbracoUserType") && tables.InvariantContains("umbracoUser"))
             {
-                if (Context.CurrentDatabaseProvider == DatabaseProviders.MySql)
+                if (constraints.Any(x => x.Item1.InvariantEquals("umbracoUser") && x.Item3.InvariantEquals("FK_umbracoUser_umbracoUserType_id")))
                 {
-                    //In MySql, this will drop the FK according to it's special naming rules
-                    Delete.ForeignKey().FromTable("umbracoUser").ForeignColumn("userType").ToTable("umbracoUserType").PrimaryColumn("id");
+                    Delete.ForeignKey("FK_umbracoUser_umbracoUserType_id").OnTable("umbracoUser");
                 }
-                else
+                //This is the super old constraint name of the FK for user type so check this one too
+                if (constraints.Any(x => x.Item1.InvariantEquals("umbracoUser") && x.Item3.InvariantEquals("FK_user_userType")))
                 {
-                    //Delete the FK if it exists before dropping the column
-                    if (constraints.Any(x => x.Item1.InvariantEquals("umbracoUser") && x.Item3.InvariantEquals("FK_umbracoUser_umbracoUserType_id")))
-                    {
-                        Delete.ForeignKey("FK_umbracoUser_umbracoUserType_id").OnTable("umbracoUser");
-                    }
-                    //This is the super old constraint name of the FK for user type so check this one too
-                    if (constraints.Any(x => x.Item1.InvariantEquals("umbracoUser") && x.Item3.InvariantEquals("FK_user_userType")))
-                    {
-                        Delete.ForeignKey("FK_user_userType").OnTable("umbracoUser");
-                    }
-                }               
+                    Delete.ForeignKey("FK_user_userType").OnTable("umbracoUser");
+                }
 
                 Delete.Column("userType").FromTable("umbracoUser");
                 Delete.Table("umbracoUserType");
@@ -371,4 +361,4 @@ namespace Umbraco.Core.Persistence.Migrations.Upgrades.TargetVersionSevenSevenZe
         public override void Down()
         { }
     }
-}
+}

src/Umbraco.Core/PropertyEditors/ValueConverters/IntegerValueConverter.cs

@@ -1,5 +1,4 @@
-using System;
-using Umbraco.Core.Models.PublishedContent;
+using Umbraco.Core.Models.PublishedContent;
 
 namespace Umbraco.Core.PropertyEditors.ValueConverters
 {
@@ -15,7 +14,19 @@ namespace Umbraco.Core.PropertyEditors.ValueConverters
 
         public override object ConvertDataToSource(PublishedPropertyType propertyType, object source, bool preview)
         {
-            return source.TryConvertTo<int>().Result;
+            if (source == null) return 0;
+
+            // in XML an integer is a string
+            var sourceString = source as string;
+            if (sourceString != null)
+            {
+                int i;
+                return (int.TryParse(sourceString, out i)) ? i : 0;
+            }
+
+            // in the database an integer is an integer
+            // default value is zero
+            return (source is int) ? source : 0;
         }
     }
 }

src/Umbraco.Core/Security/UmbracoBackOfficeIdentity.cs

@@ -37,15 +37,15 @@ namespace Umbraco.Core.Security
             var username = identity.GetUserName();
             var session = identity.FindFirstValue(Constants.Security.SessionIdClaimType);
             var securityStamp = identity.FindFirstValue(Microsoft.AspNet.Identity.Constants.DefaultSecurityStampClaimType);
-            var startContentId = identity.FindFirstValue(Constants.Security.StartContentNodeIdClaimType);
+            var startContentId = identity.FindFirstValue(Constants.Security.StartContentNodeIdClaimType);            
             var startMediaId = identity.FindFirstValue(Constants.Security.StartMediaNodeIdClaimType);
 
             var culture = identity.FindFirstValue(ClaimTypes.Locality);
-            var id = identity.FindFirstValue(ClaimTypes.NameIdentifier);
+            var id = identity.FindFirstValue(ClaimTypes.NameIdentifier);            
             var realName = identity.FindFirstValue(ClaimTypes.GivenName);
 
-            if (username == null || startContentId == null || startMediaId == null
-                || culture == null || id == null
+            if (username == null || startContentId == null || startMediaId == null 
+                || culture == null || id == null 
                 || realName == null || session == null)
                 throw new InvalidOperationException("Cannot create a " + typeof(UmbracoBackOfficeIdentity) + " from " + typeof(ClaimsIdentity) + " since there are missing required claims");
 
@@ -62,7 +62,7 @@ namespace Umbraco.Core.Security
             catch (Exception e)
             {
                 throw new InvalidOperationException("Cannot create a " + typeof(UmbracoBackOfficeIdentity) + " from " + typeof(ClaimsIdentity) + " since the data is not formatted correctly - either content or media start Ids could not be parsed as JSON", e);
-            }
+            }           
 
             var roles = identity.FindAll(x => x.Type == DefaultRoleClaimType).Select(role => role.Value).ToList();
             var allowedApps = identity.FindAll(x => x.Type == Constants.Security.AllowedApplicationsClaimType).Select(app => app.Value).ToList();
@@ -165,7 +165,7 @@ namespace Umbraco.Core.Security
         {
             foreach (var claim in claimsIdentity.Claims)
             {
-                //In one special case we will replace a claim if it exists already and that is the
+                //In one special case we will replace a claim if it exists already and that is the 
                 // Forms auth claim for name which automatically gets added
                 TryRemoveClaim(FindFirst(x => x.Type == claim.Type && x.Issuer == "Forms"));
 
@@ -187,15 +187,15 @@ namespace Umbraco.Core.Security
                 {
                     ClaimTypes.NameIdentifier, //id
                     ClaimTypes.Name,  //username
-                    ClaimTypes.GivenName,
+                    ClaimTypes.GivenName, 
                     Constants.Security.StartContentNodeIdClaimType,
-                    Constants.Security.StartMediaNodeIdClaimType,
-                    ClaimTypes.Locality,
+                    Constants.Security.StartMediaNodeIdClaimType, 
+                    ClaimTypes.Locality, 
                     Constants.Security.SessionIdClaimType,
                     Microsoft.AspNet.Identity.Constants.DefaultSecurityStampClaimType
                 };
             }
-        }
+        } 
 
         /// <summary>
         /// Adds claims based on the UserData data
@@ -222,19 +222,23 @@ namespace Umbraco.Core.Security
                 AddClaim(new Claim(ClaimTypes.Locality, Culture, ClaimValueTypes.String, Issuer, Issuer, this));
 
             if (HasClaim(x => x.Type == Constants.Security.SessionIdClaimType) == false && SessionId.IsNullOrWhiteSpace() == false)
+            {
                 AddClaim(new Claim(Constants.Security.SessionIdClaimType, SessionId, ClaimValueTypes.String, Issuer, Issuer, this));
 
-            //The security stamp claim is also required... this is because this claim type is hard coded
-            // by the SecurityStampValidator, see: https://katanaproject.codeplex.com/workitem/444
-            if (HasClaim(x => x.Type == Microsoft.AspNet.Identity.Constants.DefaultSecurityStampClaimType) == false)
-                AddClaim(new Claim(Microsoft.AspNet.Identity.Constants.DefaultSecurityStampClaimType, SecurityStamp, ClaimValueTypes.String, Issuer, Issuer, this));
+                //The security stamp claim is also required... this is because this claim type is hard coded 
+                // by the SecurityStampValidator, see: https://katanaproject.codeplex.com/workitem/444
+                if (HasClaim(x => x.Type == Microsoft.AspNet.Identity.Constants.DefaultSecurityStampClaimType) == false)
+                {
+                    AddClaim(new Claim(Microsoft.AspNet.Identity.Constants.DefaultSecurityStampClaimType, SecurityStamp, ClaimValueTypes.String, Issuer, Issuer, this));
+                }
+            }
 
             //Add each app as a separate claim
             if (HasClaim(x => x.Type == Constants.Security.AllowedApplicationsClaimType) == false)
             {
                 foreach (var application in AllowedApplications)
                 {
-                    AddClaim(new Claim(Constants.Security.AllowedApplicationsClaimType, application, ClaimValueTypes.String, Issuer, Issuer, this));
+                    AddClaim(new Claim(Constants.Security.AllowedApplicationsClaimType, application, ClaimValueTypes.String, Issuer, Issuer, this));    
                 }
             }
 
@@ -249,8 +253,8 @@ namespace Umbraco.Core.Security
                 }
             }
 
-
-
+            
+            
         }
 
         protected internal UserData UserData { get; private set; }
@@ -328,4 +332,4 @@ namespace Umbraco.Core.Security
         }
 
     }
-}
+}

src/Umbraco.Core/Services/UserService.cs

@@ -207,17 +207,20 @@ namespace Umbraco.Core.Services
                 {
                     return repository.GetByUsername(username, includeSecurityData: true);
                 }
-                catch (DbException ex)
+                catch (Exception ex)
                 {
-                    //we need to handle this one specific case which is when we are upgrading to 7.7 since the user group
-                    //tables don't exist yet. This is the 'easiest' way to deal with this without having to create special
-                    //version checks in the BackOfficeSignInManager and calling into other special overloads that we'd need
-                    //like "GetUserById(int id, bool includeSecurityData)" which may cause confusion because the result of
-                    //that method would not be cached.
-                    if (ApplicationContext.Current.IsUpgrading)
+                    if (ex is SqlException || ex is SqlCeException)
                     {
-                        //NOTE: this will not be cached
-                        return repository.GetByUsername(username, includeSecurityData: false);
+                        //we need to handle this one specific case which is when we are upgrading to 7.7 since the user group
+                        //tables don't exist yet. This is the 'easiest' way to deal with this without having to create special
+                        //version checks in the BackOfficeSignInManager and calling into other special overloads that we'd need
+                        //like "GetUserById(int id, bool includeSecurityData)" which may cause confusion because the result of
+                        //that method would not be cached.
+                        if (ApplicationContext.Current.IsUpgrading)
+                        {
+                            //NOTE: this will not be cached
+                            return repository.GetByUsername(username, includeSecurityData: false);
+                        }
                     }
                     throw;
                 }
@@ -786,17 +789,20 @@ namespace Umbraco.Core.Services
                     var result = repository.Get(id);
                     return result;
                 }
-                catch (DbException ex)
+                catch (Exception ex)
                 {
-                    //we need to handle this one specific case which is when we are upgrading to 7.7 since the user group
-                    //tables don't exist yet. This is the 'easiest' way to deal with this without having to create special
-                    //version checks in the BackOfficeSignInManager and calling into other special overloads that we'd need
-                    //like "GetUserById(int id, bool includeSecurityData)" which may cause confusion because the result of
-                    //that method would not be cached.
-                    if (ApplicationContext.Current.IsUpgrading)
+                    if (ex is SqlException || ex is SqlCeException)
                     {
-                        //NOTE: this will not be cached
-                        return repository.Get(id, includeSecurityData: false);
+                        //we need to handle this one specific case which is when we are upgrading to 7.7 since the user group
+                        //tables don't exist yet. This is the 'easiest' way to deal with this without having to create special
+                        //version checks in the BackOfficeSignInManager and calling into other special overloads that we'd need
+                        //like "GetUserById(int id, bool includeSecurityData)" which may cause confusion because the result of
+                        //that method would not be cached.
+                        if (ApplicationContext.Current.IsUpgrading)
+                        {
+                            //NOTE: this will not be cached
+                            return repository.Get(id, includeSecurityData: false);
+                        }
                     }
                     throw;
                 }

src/Umbraco.Tests/UI/LegacyDialogTests.cs

@@ -1,4 +1,7 @@
 using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
 using NUnit.Framework;
 using Umbraco.Core;
 using Umbraco.Web.UI;

src/Umbraco.Web.UI.Client/bower.json

@@ -42,7 +42,12 @@
       "codemirror"
     ],
     "sources": {
-      "moment": "bower_components/moment/min/moment-with-locales.js",
+      "moment": [
+          "bower_components/moment/min/moment.min.js",
+          "bower_components/moment/min/moment-with-locales.js",
+          "bower_components/moment/min/moment-with-locales.min.js",
+          "bower_components/moment/locale/*.js"
+        ],
       "underscore": [
         "bower_components/underscore/underscore-min.js",
         "bower_components/underscore/underscore-min.map"

src/Umbraco.Web.UI.Client/gruntFile.js

@@ -0,0 +1,605 @@
+module.exports = function (grunt) {
+
+
+
+    // Default task.
+    grunt.registerTask('default', ['jshint:dev', 'build', 'karma:unit']);
+    grunt.registerTask('dev', ['jshint:dev', 'build-dev', 'webserver', 'open:dev', 'watch']);
+    grunt.registerTask('docserve', ['docs:api', 'connect:docserver', 'open:docs', 'watch:docs']);
+    grunt.registerTask('vs', ['jshint:dev', 'build-dev', 'watch']);
+
+    //TODO: Too much watching, this brings windows to it's knees when in dev mode
+    //run by the watch task
+    grunt.registerTask('watch-js', ['jshint:dev', 'concat', 'copy:app', 'copy:mocks', 'copy:canvasdesigner', 'copy:vs', 'karma:unit']);
+    grunt.registerTask('watch-less', ['recess:build', 'recess:installer', 'recess:nonodes', 'recess:canvasdesigner', 'postcss', 'copy:canvasdesigner', 'copy:assets', 'copy:vs']);
+    grunt.registerTask('watch-html', ['copy:views', 'copy:vs']);
+    grunt.registerTask('watch-installer', ['concat:install', 'concat:installJs', 'copy:installer', 'copy:vs']);
+    grunt.registerTask('watch-canvasdesigner', ['copy:canvasdesigner', 'concat:canvasdesignerJs', 'copy:vs']);
+    grunt.registerTask('watch-test', ['jshint:dev', 'karma:unit']);
+
+    //triggered from grunt
+    grunt.registerTask('build', ['concat', 'recess:build', 'recess:installer', 'recess:nonodes', 'recess:canvasdesigner', 'postcss', 'bower-install-simple', 'bower', 'copy', 'clean:post']);
+
+    //triggered from grunt dev vs or grunt vs
+    grunt.registerTask('build-dev', ['clean:pre', 'concat', 'recess:build', 'recess:installer', 'recess:nonodes', 'postcss', 'bower-install-simple', 'bower', 'copy']);
+
+    //utillity tasks
+    grunt.registerTask('docs', ['ngdocs']);
+    grunt.registerTask('webserver', ['connect:devserver']);
+
+
+    // Print a timestamp (useful for when watching)
+    grunt.registerTask('timestamp', function () {
+        grunt.log.subhead(Date());
+    });
+
+    // Project configuration.
+    grunt.initConfig({
+        buildVersion: grunt.option('buildversion') || '7',
+        connect: {
+            devserver: {
+                options: {
+                    port: 9990,
+                    hostname: '0.0.0.0',
+                    base: './build',
+                    middleware: function(connect, options) {
+                        return [
+                            //uncomment to enable CSP
+                            // util.csp(),
+                            //util.rewrite(),
+                            connect.favicon('images/favicon.ico'),
+                            connect.static(options.base),
+                            connect.directory(options.base)
+                        ];
+                    }
+                }
+            },
+            testserver: {},
+            docserver: {
+                options: {
+                    port: 8880,
+                    hostname: '0.0.0.0',
+                    base: './docs/api',
+                    middleware: function(connect, options) {
+                        return [
+                            //uncomment to enable CSP
+                            // util.csp(),
+                            //util.rewrite(),
+                            connect.static(options.base),
+                            connect.directory(options.base)
+                        ];
+                    }
+                }
+            },
+        },
+
+        open: {
+            dev: {
+                path: 'http://localhost:9990/belle/'
+            },
+            docs: {
+                path: 'http://localhost:8880/index.html'
+            }
+        },
+
+        distdir: 'build/belle',
+        vsdir: '../Umbraco.Web.UI/umbraco',
+        pkg: grunt.file.readJSON('package.json'),
+        banner:
+            '/*! <%= pkg.title || pkg.name %>\n' +
+                '<%= pkg.homepage ? " * " + pkg.homepage + "\\n" : "" %>' +
+                ' * Copyright (c) <%= grunt.template.today("yyyy") %> <%= pkg.author %>;\n' +
+                ' * Licensed <%= _.pluck(pkg.licenses, "type").join(", ") %>\n */\n',
+        src: {
+            js: ['src/**/*.js', 'src/*.js'],
+
+            common: ['src/common/**/*.js'],
+            controllers: ['src/**/*.controller.js'],
+
+            specs: ['test/**/*.spec.js'],
+            scenarios: ['test/**/*.scenario.js'],
+            samples: ['sample files/*.js'],
+            html: ['src/index.html', 'src/install.html'],
+
+            everything: ['src/**/*.*', 'test/**/*.*', 'docs/**/*.*'],
+
+            tpl: {
+                app: ['src/views/**/*.html'],
+                common: ['src/common/**/*.tpl.html']
+            },
+            less: ['src/less/belle.less'], // recess:build doesn't accept ** in its file patterns
+            prod: ['<%= distdir %>/js/*.js']
+        },
+
+        clean: {
+            pre: ['<%= distdir %>/*'],
+            post: ['<%= distdir %>/js/*.dev.js']
+        },
+
+        copy: {
+            assets: {
+                files: [{ dest: '<%= distdir %>/assets', src: '**', expand: true, cwd: 'src/assets/' }]
+            },
+
+            config: {
+                files: [{ dest: '<%= distdir %>/../config', src: '**', expand: true, cwd: 'src/config/' }]
+            },
+
+            installer: {
+                files: [{ dest: '<%= distdir %>/views/install', src: '**/*.html', expand: true, cwd: 'src/installer/steps' }]
+            },
+
+            canvasdesigner: {
+                files: [
+                    { dest: '<%= distdir %>/preview', src: '**/*.html', expand: true, cwd: 'src/canvasdesigner' },
+                    { dest: '<%= distdir %>/preview/editors', src: '**/*.html', expand: true, cwd: 'src/canvasdesigner/editors' },
+                    { dest: '<%= distdir %>/assets/less', src: '**/*.less', expand: true, cwd: 'src/canvasdesigner/editors' },
+                    { dest: '<%= distdir %>/js', src: 'canvasdesigner.config.js', expand: true, cwd: 'src/canvasdesigner/config' },
+                    { dest: '<%= distdir %>/js', src: 'canvasdesigner.palettes.js', expand: true, cwd: 'src/canvasdesigner/config' },
+                    { dest: '<%= distdir %>/js', src: 'canvasdesigner.front.js', expand: true, cwd: 'src/canvasdesigner' }
+                ]
+            },
+
+            vendor: {
+                files: [{ dest: '<%= distdir %>/lib', src: '**', expand: true, cwd: 'lib/' }]
+            },
+
+            views: {
+                files: [{ dest: '<%= distdir %>/views', src: ['**/*.*', '!**/*.controller.js'], expand: true, cwd: 'src/views' }]
+            },
+
+            app: {
+                files: [
+                    { dest: '<%= distdir %>/js', src: '*.js', expand: true, cwd: 'src/' }
+                ]
+            },
+
+            mocks: {
+                files: [{ dest: '<%= distdir %>/js', src: '*.js', expand: true, cwd: 'src/common/mocks/' }]
+            },
+
+            vs: {
+                files: [
+                    //everything except the index.html root file!
+                    //then we need to figure out how to not copy all the test stuff either!?
+                    { dest: '<%= vsdir %>/assets', src: '**', expand: true, cwd: '<%= distdir %>/assets' },
+                    { dest: '<%= vsdir %>/js', src: '**', expand: true, cwd: '<%= distdir %>/js' },
+                    { dest: '<%= vsdir %>/views', src: '**', expand: true, cwd: '<%= distdir %>/views' },
+                    { dest: '<%= vsdir %>/preview', src: '**', expand: true, cwd: '<%= distdir %>/preview' },
+                    { dest: '<%= vsdir %>/lib', src: '**', expand: true, cwd: '<%= distdir %>/lib' }
+                ]
+            }
+        },
+
+        karma: {
+            unit: { configFile: 'test/config/karma.conf.js', keepalive: true },
+            e2e: { configFile: 'test/config/e2e.js', keepalive: true },
+            watch: { configFile: 'test/config/unit.js', singleRun: false, autoWatch: true, keepalive: true }
+        },
+
+        concat: {
+            index: {
+                src: ['src/index.html'],
+                dest: '<%= distdir %>/index.html',
+                options: {
+                    process: true
+                }
+            },
+            install: {
+                src: ['src/installer/installer.html'],
+                dest: '<%= distdir %>/installer.html',
+                options: {
+                    process: true
+                }
+            },
+
+            installJs: {
+                src: ['src/installer/**/*.js'],
+                dest: '<%= distdir %>/js/umbraco.installer.js',
+                options: {
+                    banner: "<%= banner %>\n(function() { \n\n",
+                    footer: "\n\n})();"
+                }
+            },
+
+            canvasdesignerJs: {
+                src: ['src/canvasdesigner/canvasdesigner.global.js', 'src/canvasdesigner/canvasdesigner.controller.js', 'src/canvasdesigner/editors/*.js', 'src/canvasdesigner/lib/*.js'],
+                dest: '<%= distdir %>/js/canvasdesigner.panel.js'
+            },
+
+            controllers: {
+                src: ['src/controllers/**/*.controller.js', 'src/views/**/*.controller.js'],
+                dest: '<%= distdir %>/js/umbraco.controllers.js',
+                options: {
+                    banner: "<%= banner %>\n(function() { \n\n",
+                    footer: "\n\n})();"
+                }
+            },
+
+            services: {
+                src: ['src/common/services/*.js'],
+                dest: '<%= distdir %>/js/umbraco.services.js',
+                options: {
+                    banner: "<%= banner %>\n(function() { \n\n",
+                    footer: "\n\n})();"
+                }
+            },
+
+            security: {
+                src: ['src/common/security/*.js'],
+                dest: '<%= distdir %>/js/umbraco.security.js',
+                options: {
+                    banner: "<%= banner %>\n(function() { \n\n",
+                    footer: "\n\n})();"
+                }
+            },
+
+            resources: {
+                src: ['src/common/resources/*.js'],
+                dest: '<%= distdir %>/js/umbraco.resources.js',
+                options: {
+                    banner: "<%= banner %>\n(function() { \n\n",
+                    footer: "\n\n})();"
+                }
+            },
+
+            testing: {
+                src: ['src/common/mocks/*/*.js'],
+                dest: '<%= distdir %>/js/umbraco.testing.js',
+                options: {
+                    banner: "<%= banner %>\n(function() { \n\n",
+                    footer: "\n\n})();"
+                }
+            },
+
+            directives: {
+                src: ['src/common/directives/**/*.js'],
+                dest: '<%= distdir %>/js/umbraco.directives.js',
+                options: {
+                    banner: "<%= banner %>\n(function() { \n\n",
+                    footer: "\n\n})();"
+                }
+            },
+
+            filters: {
+                src: ['src/common/filters/*.js'],
+                dest: '<%= distdir %>/js/umbraco.filters.js',
+                options: {
+                    banner: "<%= banner %>\n(function() { \n\n",
+                    footer: "\n\n})();"
+                }
+            }
+        },
+
+        uglify: {
+            options: {
+                mangle: true
+            },
+            combine: {
+                files: {
+                    '<%= distdir %>/js/umbraco.min.js': ['<%= distdir %>/js/umbraco.*.js']
+                }
+            }
+        },
+
+        recess: {
+            build: {
+                files: {
+                    '<%= distdir %>/assets/css/<%= pkg.name %>.css':
+                    ['<%= src.less %>']
+                },
+                options: {
+                    compile: true,
+                    compress: true
+                }
+            },
+            nonodes: {
+                files: {
+                    '<%= distdir %>/assets/css/nonodes.style.min.css':
+                    ['src/less/pages/nonodes.less']
+                },
+                options: {
+                    compile: true,
+                    compress: true
+                }
+            },
+            installer: {
+                files: {
+                    '<%= distdir %>/assets/css/installer.css':
+                    ['src/less/installer.less']
+                },
+                options: {
+                    compile: true,
+                    compress: true
+                }
+            },
+            canvasdesigner: {
+                files: {
+                    '<%= distdir %>/assets/css/canvasdesigner.css':
+                    ['src/less/canvas-designer.less', 'src/less/helveticons.less']
+                },
+                options: {
+                    compile: true,
+                    compress: true
+                }
+            }
+        },
+
+        postcss: {
+           options: {
+              processors: [
+                 // add vendor prefixes
+                 require('autoprefixer-core')({
+                    browsers: 'last 2 versions'
+                 })
+              ]
+           },
+           dist: {
+              src: '<%= distdir %>/assets/css/<%= pkg.name %>.css'
+           }
+        },
+
+        ngTemplateCache: {
+            views: {
+                files: {
+                    '<%= distdir %>/js/umbraco.views.js': 'src/views/**/*.html'
+                },
+                options: {
+                    trim: 'src/',
+                    module: 'umbraco.views'
+                }
+            }
+        },
+
+        watch: {
+            docs: {
+                files: ['docs/src/**/*.md'],
+                tasks: ['watch-docs', 'timestamp']
+            },
+            css: {
+                files: 'src/**/*.less',
+                tasks: ['watch-less', 'timestamp'],
+                options: {
+                    livereload: true,
+                },
+            },
+            js: {
+                files: ['src/**/*.js', 'src/*.js'],
+                tasks: ['watch-js', 'timestamp'],
+            },
+            test: {
+                files: ['test/**/*.js'],
+                tasks: ['watch-test', 'timestamp'],
+            },
+            installer: {
+                files: ['src/installer/**/*.*'],
+                tasks: ['watch-installer', 'timestamp'],
+            },
+            canvasdesigner: {
+                files: ['src/canvasdesigner/**/*.*'],
+                tasks: ['watch-canvasdesigner', 'timestamp'],
+            },
+            html: {
+                files: ['src/views/**/*.html', 'src/*.html'],
+                tasks: ['watch-html', 'timestamp']
+            },
+			options: { 
+                interval: 500
+            }
+        },
+
+
+        ngdocs: {
+            options: {
+                dest: 'docs/api',
+                startPage: '/api',
+                title: "Umbraco Backoffice UI API Documentation",
+                html5Mode: false,
+                styles: [
+                    'docs/umb-docs.css'
+                ],
+                image: "https://our.umbraco.org/assets/images/logo.svg"
+            },
+            api: {
+                src: ['src/common/**/*.js', 'docs/src/api/**/*.ngdoc'],
+                title: 'API Documentation'
+            },
+            tutorials: {
+                src: [],
+                title: ''
+            }
+        },
+
+        eslint:{
+            src: ['<%= src.common %>','<%= src.controllers %>'],
+            options: {quiet: true}
+        },
+
+        jshint: {
+            dev: {
+                files: {
+                    src: ['<%= src.common %>']
+                },
+                options: {
+                    curly: true,
+                    eqeqeq: true,
+                    immed: true,
+                    latedef: "nofunc",
+                    newcap: true,
+                    noarg: true,
+                    sub: true,
+                    boss: true,
+                    //NOTE: This is required so it doesn't barf on reserved words like delete when doing $http.delete
+                    es5: true,
+                    eqnull: true,
+                    //NOTE: we need to use eval sometimes so ignore it
+                    evil: true,
+                    //NOTE: we need to check for strings such as "javascript:" so don't throw errors regarding those
+                    scripturl: true,
+                    //NOTE: we ignore tabs vs spaces because enforcing that causes lots of errors depending on the text editor being used
+                    smarttabs: true,
+                    globals: {}
+                }
+            },
+            build: {
+                files: {
+                    src: ['<%= src.prod %>']
+                },
+                options: {
+                    curly: true,
+                    eqeqeq: true,
+                    immed: true,
+                    latedef: "nofunc",
+                    newcap: true,
+                    noarg: true,
+                    sub: true,
+                    boss: true,
+                    //NOTE: This is required so it doesn't barf on reserved words like delete when doing $http.delete
+                    es5: true,
+                    eqnull: true,
+                    //NOTE: we need to use eval sometimes so ignore it
+                    evil: true,
+                    //NOTE: we need to check for strings such as "javascript:" so don't throw errors regarding those
+                    scripturl: true,
+                    //NOTE: we ignore tabs vs spaces because enforcing that causes lots of errors depending on the text editor being used
+                    smarttabs: true,
+                    globalstrict: true,
+                    globals: { $: false, jQuery: false, define: false, require: false, window: false }
+                }
+            }
+        },
+
+        bower: {
+            dev: {
+                dest: '<%= distdir %>/lib',
+                options: {
+                    expand: true,
+                    ignorePackages: ['bootstrap'],
+                    packageSpecific: {
+                        'moment': {
+                            keepExpandedHierarchy: false,
+                            files: ['min/moment-with-locales.js']
+                        },
+                        'typeahead.js': {
+                            keepExpandedHierarchy: false,
+                            files: ['dist/typeahead.bundle.min.js']
+                        },
+                        'underscore': {
+                            files: ['underscore-min.js', 'underscore-min.map']
+                        },
+                        'rgrove-lazyload': {
+                            files: ['lazyload.js']
+                        },
+                        'bootstrap-social': {
+                            files: ['bootstrap-social.css']
+                        },
+                        'font-awesome': {
+                            files: ['css/font-awesome.min.css', 'fonts/*']
+                        },
+                        "jquery": {
+                            keepExpandedHierarchy: false,
+                            files: ['dist/jquery.min.js', 'dist/jquery.min.map']
+                        },
+                        'jquery-ui': {
+                            keepExpandedHierarchy: false,
+                            files: ['jquery-ui.min.js']
+                        },
+                        'jquery-migrate': {
+                            keepExpandedHierarchy: false,
+                            files: ['jquery-migrate.min.js']
+                        },
+                        'tinymce': {
+                            files: ['plugins/**', 'themes/**', 'tinymce.min.js']
+                        },
+                        'angular-dynamic-locale': {
+                            files: ['tmhDynamicLocale.min.js', 'tmhDynamicLocale.min.js.map']
+                        },
+                        'ng-file-upload': {
+                            keepExpandedHierarchy: false,
+                            files: ['ng-file-upload.min.js']
+                        },
+                        'angular-local-storage': {
+                            keepExpandedHierarchy: false,
+                            files: ['dist/angular-local-storage.min.js']
+                        },
+                        'codemirror': {
+                            files: [
+                                'lib/codemirror.js',
+                                'lib/codemirror.css',
+
+                                'mode/css/*',
+                                'mode/javascript/*',
+                                'mode/xml/*',
+                                'mode/htmlmixed/*',
+
+                                'addon/search/*',
+                                'addon/edit/*',
+                                'addon/selection/*',
+                                'addon/dialog/*'
+                            ]
+                        },
+                        'ace-builds': {
+                           files: [
+                                'src-min-noconflict/ace.js',
+                                
+                                'src-min-noconflict/ext-language_tools.js',
+                                'src-min-noconflict/ext-searchbox.js',
+                                'src-min-noconflict/ext-settings_menu.js',
+
+                                'src-min-noconflict/snippets/text.js',
+                                'src-min-noconflict/snippets/javascript.js',
+                                
+                                'src-min-noconflict/theme-chrome.js',
+                                
+                                'src-min-noconflict/mode-razor.js',
+                                'src-min-noconflict/mode-javascript.js',
+                                
+                                'src-min-noconflict/worker-javascript.js',
+                            ]
+                        },
+                        'clipboard': {
+                            keepExpandedHierarchy: false,
+                            files: ['dist/clipboard.min.js']
+                       },
+                       'angular-moment': {
+                            keepExpandedHierarchy: false,
+                            files: ['angular-moment.min.js']
+                        }
+                    }
+                }
+            },
+            options: {
+                expand: true
+            }
+        },
+
+        "bower-install-simple": {
+            options: {
+                color: true
+            },
+            "dev": {}
+        }
+    });
+
+
+
+    grunt.loadNpmTasks('grunt-contrib-concat');
+    grunt.loadNpmTasks('grunt-contrib-jshint');
+    grunt.loadNpmTasks('grunt-contrib-clean');
+    grunt.loadNpmTasks('grunt-contrib-copy');
+    grunt.loadNpmTasks('grunt-contrib-uglify');
+    grunt.loadNpmTasks('grunt-contrib-watch');
+    grunt.loadNpmTasks('grunt-recess');
+    grunt.loadNpmTasks('grunt-postcss');
+
+    grunt.loadNpmTasks('grunt-karma');
+
+    grunt.loadNpmTasks('grunt-open');
+    grunt.loadNpmTasks('grunt-contrib-connect');
+    grunt.loadNpmTasks("grunt-bower-install-simple");
+    grunt.loadNpmTasks('grunt-bower');
+    grunt.loadNpmTasks('grunt-ngdocs');
+
+    grunt.loadNpmTasks('grunt-eslint');
+    grunt.loadNpmTasks('grunt-hustler');
+};

src/Umbraco.Web.UI.Client/src/common/directives/components/overlays/umboverlay.directive.js

@@ -59,6 +59,7 @@
 </pre>
 
 <h1>General Options</h1>
+Lorem ipsum dolor sit amet..
 <table>
     <thead>
         <tr>
@@ -73,7 +74,7 @@
         <td>Set the title of the overlay.</td>
     </tr>
     <tr>
-        <td>model.subtitle</td>
+        <td>model.subTitle</td>
         <td>String</td>
         <td>Set the subtitle of the overlay.</td>
     </tr>
@@ -495,7 +496,6 @@ Opens an overlay to show a custom YSOD. </br>
                      var activeElementType = document.activeElement.tagName;
                      var clickableElements = ["A", "BUTTON"];
                      var submitOnEnter = document.activeElement.hasAttribute("overlay-submit-on-enter");
-                     var submitOnEnterValue = submitOnEnter ? document.activeElement.getAttribute("overlay-submit-on-enter") : "";
 
                      if(clickableElements.indexOf(activeElementType) === 0) {
                         document.activeElement.click();
@@ -503,9 +503,7 @@ Opens an overlay to show a custom YSOD. </br>
                      } else if(activeElementType === "TEXTAREA" && !submitOnEnter) {
 
 
-                     } else if (submitOnEnter && submitOnEnterValue === "false") {
-                         // don't do anything
-                     }else {
+                     } else {
                         scope.$apply(function () {
                            scope.submitForm(scope.model);
                         });

src/Umbraco.Web.UI.Client/src/common/services/javascriptlibrary.service.js

@@ -0,0 +1,40 @@
+(function () {
+    'use strict';
+
+    function javascriptLibraryService($q, $http, umbRequestHelper) {
+
+        var existingLocales = [];
+
+        function getSupportedLocalesForMoment() {
+            var deferred = $q.defer();
+
+            if (existingLocales.length === 0) {
+                umbRequestHelper.resourcePromise(
+                    $http.get(
+                        umbRequestHelper.getApiUrl(
+                            "backOfficeAssetsApiBaseUrl",
+                            "GetSupportedMomentLocales")),
+                    'Failed to get cultures').then(function(locales) {
+                    existingLocales = locales;
+                    deferred.resolve(existingLocales);
+                });
+            } else {
+                deferred.resolve(existingLocales);
+            }
+
+            return deferred.promise;
+        }
+
+        var service = {
+            getSupportedLocalesForMoment: getSupportedLocalesForMoment
+        };
+
+        return service;
+
+    }
+
+    angular.module('umbraco.services').factory('javascriptLibraryService', javascriptLibraryService);
+
+
+})();
+

src/Umbraco.Web.UI.Client/src/common/services/navigation.service.js

@@ -288,12 +288,9 @@ function navigationService($rootScope, $routeParams, $log, $location, $q, $timeo
                 throw "args.tree cannot be null";
             }
 
-            if (mainTreeEventHandler) {                
-               
-                if (mainTreeEventHandler.syncTree) {
-                    //returns a promise,
-                    return mainTreeEventHandler.syncTree(args);
-                }
+            if (mainTreeEventHandler) {
+                //returns a promise
+                return mainTreeEventHandler.syncTree(args);
             }
 
             //couldn't sync

src/Umbraco.Web.UI.Client/src/common/services/user.service.js

@@ -1,285 +1,324 @@
 angular.module('umbraco.services')
-  .factory('userService', function ($rootScope, eventsService, $q, $location, $log, securityRetryQueue, authResource, dialogService, $timeout, angularHelper, $http) {
+    .factory('userService', function ($rootScope, eventsService, $q, $location, $log, securityRetryQueue, authResource, assetsService, dialogService, $timeout, angularHelper, $http, javascriptLibraryService) {
 
-    var currentUser = null;
-    var lastUserId = null;
-    var loginDialog = null;
+        var currentUser = null;
+        var lastUserId = null;
+        var loginDialog = null;
 
-    //this tracks the last date/time that the user's remainingAuthSeconds was updated from the server
-    // this is used so that we know when to go and get the user's remaining seconds directly.
-    var lastServerTimeoutSet = null;
+        //this tracks the last date/time that the user's remainingAuthSeconds was updated from the server
+        // this is used so that we know when to go and get the user's remaining seconds directly.
+        var lastServerTimeoutSet = null;
 
-    function openLoginDialog(isTimedOut) {
-      if (!loginDialog) {
-        loginDialog = dialogService.open({
+        function openLoginDialog(isTimedOut) {
+            if (!loginDialog) {
+                loginDialog = dialogService.open({
 
-          //very special flag which means that global events cannot close this dialog
-          manualClose: true,
+                    //very special flag which means that global events cannot close this dialog
+                    manualClose: true,
 
-          template: 'views/common/dialogs/login.html',
-          modalClass: "login-overlay",
-          animation: "slide",
-          show: true,
-          callback: onLoginDialogClose,
-          dialogData: {
-            isTimedOut: isTimedOut
-          }
-        });
-      }
-    }
-
-    function onLoginDialogClose(success) {
-      loginDialog = null;
-
-      if (success) {
-        securityRetryQueue.retryAll(currentUser.name);
-      }
-      else {
-        securityRetryQueue.cancelAll();
-        $location.path('/');
-      }
-    }
-
-    /**
-    This methods will set the current user when it is resolved and
-    will then start the counter to count in-memory how many seconds they have
-    remaining on the auth session
-    */
-    function setCurrentUser(usr) {
-      if (!usr.remainingAuthSeconds) {
-        throw "The user object is invalid, the remainingAuthSeconds is required.";
-      }
-      currentUser = usr;
-      lastServerTimeoutSet = new Date();
-      //start the timer
-      countdownUserTimeout();
-    }
-
-    /**
-    Method to count down the current user's timeout seconds,
-    this will continually count down their current remaining seconds every 5 seconds until
-    there are no more seconds remaining.
-    */
-    function countdownUserTimeout() {
-
-      $timeout(function () {
-
-        if (currentUser) {
-          //countdown by 5 seconds since that is how long our timer is for.
-          currentUser.remainingAuthSeconds -= 5;
-
-          //if there are more than 30 remaining seconds, recurse!
-          if (currentUser.remainingAuthSeconds > 30) {
-
-            //we need to check when the last time the timeout was set from the server, if
-            // it has been more than 30 seconds then we'll manually go and retrieve it from the
-            // server - this helps to keep our local countdown in check with the true timeout.
-            if (lastServerTimeoutSet != null) {
-              var now = new Date();
-              var seconds = (now.getTime() - lastServerTimeoutSet.getTime()) / 1000;
-
-              if (seconds > 30) {
-
-                //first we'll set the lastServerTimeoutSet to null - this is so we don't get back in to this loop while we
-                // wait for a response from the server otherwise we'll be making double/triple/etc... calls while we wait.
-                lastServerTimeoutSet = null;
-
-                //now go get it from the server
-                //NOTE: the safeApply because our timeout is set to not run digests (performance reasons)
-                angularHelper.safeApply($rootScope, function () {
-                  authResource.getRemainingTimeoutSeconds().then(function (result) {
-                    setUserTimeoutInternal(result);
-                  });
+                    template: 'views/common/dialogs/login.html',
+                    modalClass: "login-overlay",
+                    animation: "slide",
+                    show: true,
+                    callback: onLoginDialogClose,
+                    dialogData: {
+                        isTimedOut: isTimedOut
+                    }
                 });
-              }
             }
+        }
 
-            //recurse the countdown!
-            countdownUserTimeout();
-          }
-          else {
+        function onLoginDialogClose(success) {
+            loginDialog = null;
 
-            //we are either timed out or very close to timing out so we need to show the login dialog.
-            if (Umbraco.Sys.ServerVariables.umbracoSettings.keepUserLoggedIn !== true) {
-              //NOTE: the safeApply because our timeout is set to not run digests (performance reasons)
-              angularHelper.safeApply($rootScope, function () {
-                try {
-                  //NOTE: We are calling this again so that the server can create a log that the timeout has expired, we
-                  // don't actually care about this result.
-                  authResource.getRemainingTimeoutSeconds();
-                }
-                finally {
-                  userAuthExpired();
-                }
-              });
+            if (success) {
+                securityRetryQueue.retryAll(currentUser.name);
             }
             else {
-              //we've got less than 30 seconds remaining so let's check the server
-
-              if (lastServerTimeoutSet != null) {
-                //first we'll set the lastServerTimeoutSet to null - this is so we don't get back in to this loop while we
-                // wait for a response from the server otherwise we'll be making double/triple/etc... calls while we wait.
-                lastServerTimeoutSet = null;
-
-                //now go get it from the server
-                //NOTE: the safeApply because our timeout is set to not run digests (performance reasons)
-                angularHelper.safeApply($rootScope, function () {
-                  authResource.getRemainingTimeoutSeconds().then(function (result) {
-                    setUserTimeoutInternal(result);
-                  });
-                });
-              }
-
-              //recurse the countdown!
-              countdownUserTimeout();
-
+                securityRetryQueue.cancelAll();
+                $location.path('/');
             }
-          }
         }
-      }, 5000, //every 5 seconds
-        false); //false = do NOT execute a digest for every iteration
-    }
 
-    /** Called to update the current user's timeout */
-    function setUserTimeoutInternal(newTimeout) {
-
-
-      var asNumber = parseFloat(newTimeout);
-      if (!isNaN(asNumber) && currentUser && angular.isNumber(asNumber)) {
-        currentUser.remainingAuthSeconds = newTimeout;
-        lastServerTimeoutSet = new Date();
-      }
-    }
-
-    /** resets all user data, broadcasts the notAuthenticated event and shows the login dialog */
-    function userAuthExpired(isLogout) {
-      //store the last user id and clear the user
-      if (currentUser && currentUser.id !== undefined) {
-        lastUserId = currentUser.id;
-      }
-
-      if (currentUser) {
-        currentUser.remainingAuthSeconds = 0;
-      }
-
-      lastServerTimeoutSet = null;
-      currentUser = null;
-
-      //broadcast a global event that the user is no longer logged in
-      eventsService.emit("app.notAuthenticated");
-
-      openLoginDialog(isLogout === undefined ? true : !isLogout);
-    }
-
-    // Register a handler for when an item is added to the retry queue
-    securityRetryQueue.onItemAddedCallbacks.push(function (retryItem) {
-      if (securityRetryQueue.hasMore()) {
-        userAuthExpired();
-      }
-    });
-
-    return {
-
-      /** Internal method to display the login dialog */
-      _showLoginDialog: function () {
-        openLoginDialog();
-      },
-      /** Returns a promise, sends a request to the server to check if the current cookie is authorized  */
-      isAuthenticated: function () {
-        //if we've got a current user then just return true
-        if (currentUser) {
-          var deferred = $q.defer();
-          deferred.resolve(true);
-          return deferred.promise;
+        /**
+        This methods will set the current user when it is resolved and
+        will then start the counter to count in-memory how many seconds they have
+        remaining on the auth session
+        */
+        function setCurrentUser(usr) {
+            if (!usr.remainingAuthSeconds) {
+                throw "The user object is invalid, the remainingAuthSeconds is required.";
+            }
+            currentUser = usr;
+            lastServerTimeoutSet = new Date();
+            //start the timer
+            countdownUserTimeout();
         }
-        return authResource.isAuthenticated();
-      },
 
-      /** Returns a promise, sends a request to the server to validate the credentials  */
-      authenticate: function (login, password) {
+        /**
+        Method to count down the current user's timeout seconds,
+        this will continually count down their current remaining seconds every 5 seconds until
+        there are no more seconds remaining.
+        */
+        function countdownUserTimeout() {
 
-        return authResource.performLogin(login, password)
-          .then(this.setAuthenticationSuccessful);
-      },
-      setAuthenticationSuccessful: function (data) {
+            $timeout(function () {
 
-        //when it's successful, return the user data
-        setCurrentUser(data);
+                if (currentUser) {
+                    //countdown by 5 seconds since that is how long our timer is for.
+                    currentUser.remainingAuthSeconds -= 5;
 
-        var result = { user: data, authenticated: true, lastUserId: lastUserId, loginType: "credentials" };
+                    //if there are more than 30 remaining seconds, recurse!
+                    if (currentUser.remainingAuthSeconds > 30) {
 
-        //broadcast a global event
-        eventsService.emit("app.authenticated", result);
-        return result;
-      },
+                        //we need to check when the last time the timeout was set from the server, if
+                        // it has been more than 30 seconds then we'll manually go and retrieve it from the
+                        // server - this helps to keep our local countdown in check with the true timeout.
+                        if (lastServerTimeoutSet != null) {
+                            var now = new Date();
+                            var seconds = (now.getTime() - lastServerTimeoutSet.getTime()) / 1000;
 
-      /** Logs the user out
-       */
-      logout: function () {
+                            if (seconds > 30) {
 
-        return authResource.performLogout()
-          .then(function (data) {
-            userAuthExpired();
-            //done!
-            return null;
-          });
-      },
+                                //first we'll set the lastServerTimeoutSet to null - this is so we don't get back in to this loop while we
+                                // wait for a response from the server otherwise we'll be making double/triple/etc... calls while we wait.
+                                lastServerTimeoutSet = null;
 
-      /** Refreshes the current user data with the data stored for the user on the server and returns it */
-      refreshCurrentUser: function() {
-          var deferred = $q.defer();
+                                //now go get it from the server
+                                //NOTE: the safeApply because our timeout is set to not run digests (performance reasons)
+                                angularHelper.safeApply($rootScope, function () {
+                                    authResource.getRemainingTimeoutSeconds().then(function (result) {
+                                        setUserTimeoutInternal(result);
+                                    });
+                                });
+                            }
+                        }
 
-          authResource.getCurrentUser()
-              .then(function (data) {
+                        //recurse the countdown!
+                        countdownUserTimeout();
+                    }
+                    else {
 
-                  var result = { user: data, authenticated: true, lastUserId: lastUserId, loginType: "implicit" };
-                  
-                  setCurrentUser(data);
+                        //we are either timed out or very close to timing out so we need to show the login dialog.
+                        if (Umbraco.Sys.ServerVariables.umbracoSettings.keepUserLoggedIn !== true) {
+                            //NOTE: the safeApply because our timeout is set to not run digests (performance reasons)
+                            angularHelper.safeApply($rootScope, function () {
+                                try {
+                                    //NOTE: We are calling this again so that the server can create a log that the timeout has expired, we
+                                    // don't actually care about this result.
+                                    authResource.getRemainingTimeoutSeconds();
+                                }
+                                finally {
+                                    userAuthExpired();
+                                }
+                            });
+                        }
+                        else {
+                            //we've got less than 30 seconds remaining so let's check the server
 
-                  deferred.resolve(currentUser);
-              }, function () {
-                  //it failed, so they are not logged in
-                  deferred.reject();
-              });
+                            if (lastServerTimeoutSet != null) {
+                                //first we'll set the lastServerTimeoutSet to null - this is so we don't get back in to this loop while we
+                                // wait for a response from the server otherwise we'll be making double/triple/etc... calls while we wait.
+                                lastServerTimeoutSet = null;
 
-          return deferred.promise;
-      },
+                                //now go get it from the server
+                                //NOTE: the safeApply because our timeout is set to not run digests (performance reasons)
+                                angularHelper.safeApply($rootScope, function () {
+                                    authResource.getRemainingTimeoutSeconds().then(function (result) {
+                                        setUserTimeoutInternal(result);
+                                    });
+                                });
+                            }
 
-      /** Returns the current user object in a promise  */
-      getCurrentUser: function (args) {
-        var deferred = $q.defer();
+                            //recurse the countdown!
+                            countdownUserTimeout();
 
-        if (!currentUser) {
-          authResource.getCurrentUser()
-            .then(function (data) {
+                        }
+                    }
+                }
+            }, 5000, //every 5 seconds
+                false); //false = do NOT execute a digest for every iteration
+        }
 
-              var result = { user: data, authenticated: true, lastUserId: lastUserId, loginType: "implicit" };
+        /** Called to update the current user's timeout */
+        function setUserTimeoutInternal(newTimeout) {
 
-              if (args && args.broadcastEvent) {
-                //broadcast a global event, will inform listening controllers to load in the user specific data
+
+            var asNumber = parseFloat(newTimeout);
+            if (!isNaN(asNumber) && currentUser && angular.isNumber(asNumber)) {
+                currentUser.remainingAuthSeconds = newTimeout;
+                lastServerTimeoutSet = new Date();
+            }
+        }
+
+        /** resets all user data, broadcasts the notAuthenticated event and shows the login dialog */
+        function userAuthExpired(isLogout) {
+            //store the last user id and clear the user
+            if (currentUser && currentUser.id !== undefined) {
+                lastUserId = currentUser.id;
+            }
+
+            if (currentUser) {
+                currentUser.remainingAuthSeconds = 0;
+            }
+
+            lastServerTimeoutSet = null;
+            currentUser = null;
+
+            //broadcast a global event that the user is no longer logged in
+            eventsService.emit("app.notAuthenticated");
+
+            openLoginDialog(isLogout === undefined ? true : !isLogout);
+        }
+
+        // Register a handler for when an item is added to the retry queue
+        securityRetryQueue.onItemAddedCallbacks.push(function (retryItem) {
+            if (securityRetryQueue.hasMore()) {
+                userAuthExpired();
+            }
+        });
+
+        return {
+
+            /** Internal method to display the login dialog */
+            _showLoginDialog: function () {
+                openLoginDialog();
+            },
+            /** Returns a promise, sends a request to the server to check if the current cookie is authorized  */
+            isAuthenticated: function () {
+                //if we've got a current user then just return true
+                if (currentUser) {
+                    var deferred = $q.defer();
+                    deferred.resolve(true);
+                    return deferred.promise;
+                }
+                return authResource.isAuthenticated();
+            },
+
+            /** Returns a promise, sends a request to the server to validate the credentials  */
+            authenticate: function (login, password) {
+
+                return authResource.performLogin(login, password)
+                    .then(this.setAuthenticationSuccessful);
+            },
+            setAuthenticationSuccessful: function (data) {
+
+                //when it's successful, return the user data
+                setCurrentUser(data);
+
+                var result = { user: data, authenticated: true, lastUserId: lastUserId, loginType: "credentials" };
+
+                //broadcast a global event
                 eventsService.emit("app.authenticated", result);
-              }
+                return result;
+            },
 
-              setCurrentUser(data);
+            /** Logs the user out
+             */
+            logout: function () {
 
-              deferred.resolve(currentUser);
-            }, function () {
-              //it failed, so they are not logged in
-              deferred.reject();
-            });
+                return authResource.performLogout()
+                    .then(function (data) {
+                        userAuthExpired();
+                        //done!
+                        return null;
+                    });
+            },
 
-        }
-        else {
-          deferred.resolve(currentUser);
-        }
+            /** Refreshes the current user data with the data stored for the user on the server and returns it */
+            refreshCurrentUser: function () {
+                var deferred = $q.defer();
 
-        return deferred.promise;
-      },
+                authResource.getCurrentUser()
+                    .then(function (data) {
 
-      /** Called whenever a server request is made that contains a x-umb-user-seconds response header for which we can update the user's remaining timeout seconds */
-      setUserTimeout: function (newTimeout) {
-        setUserTimeoutInternal(newTimeout);
-      }
-    };
+                        var result = { user: data, authenticated: true, lastUserId: lastUserId, loginType: "implicit" };
 
-  });
+                        setCurrentUser(data);
+
+                        deferred.resolve(currentUser);
+                    }, function () {
+                        //it failed, so they are not logged in
+                        deferred.reject();
+                    });
+
+                return deferred.promise;
+            },
+
+            /** Returns the current user object in a promise  */
+            getCurrentUser: function (args) {
+                var deferred = $q.defer();
+
+                if (!currentUser) {
+                    authResource.getCurrentUser()
+                        .then(function (data) {
+
+                            var result = { user: data, authenticated: true, lastUserId: lastUserId, loginType: "implicit" };
+
+                            if (args && args.broadcastEvent) {
+                                //broadcast a global event, will inform listening controllers to load in the user specific data
+                                eventsService.emit("app.authenticated", result);
+                            }
+
+                            setCurrentUser(data);
+
+                            deferred.resolve(currentUser);
+                        }, function () {
+                            //it failed, so they are not logged in
+                            deferred.reject();
+                        });
+
+                }
+                else {
+                    deferred.resolve(currentUser);
+                }
+
+                return deferred.promise;
+            },
+
+            /** Loads the Moment.js Locale for the current user. */
+            loadMomentLocaleForCurrentUser: function () {
+                var deferred = $q.defer();
+
+
+                function loadLocales(currentUser, supportedLocales) {
+                    var locale = currentUser.locale.toLowerCase();
+                    if (locale !== 'en-us') {
+                        var localeUrls = [];
+                        if (supportedLocales.indexOf(locale + '.js') > -1) {
+                            localeUrls.push('lib/moment/' + locale + '.js');
+                        }
+                        if (locale.indexOf('-') > -1) {
+                            var majorLocale = locale.split('-')[0] + '.js';
+                            if (supportedLocales.indexOf(majorLocale) > -1) {
+                                localeUrls.push('lib/moment/' + majorLocale);
+                            }
+                        }
+                        assetsService.load(localeUrls).then(function () {
+                            deferred.resolve(localeUrls);
+                        });
+                    } else {
+                        deferred.resolve(['']);
+                    }
+                }
+
+                var promises = {
+                    currentUser: this.getCurrentUser(),
+                    supportedLocales: javascriptLibraryService.getSupportedLocalesForMoment()
+                }
+
+                $q.all(promises).then((values) => {
+                    loadLocales(values.currentUser, values.supportedLocales);
+                });
+                
+                return deferred.promise;
+
+            },
+
+            /** Called whenever a server request is made that contains a x-umb-user-seconds response header for which we can update the user's remaining timeout seconds */
+            setUserTimeout: function (newTimeout) {
+                setUserTimeoutInternal(newTimeout);
+            }
+        };
+
+    });

src/Umbraco.Web.UI.Client/src/init.js

@@ -18,23 +18,26 @@ app.run(['userService', '$log', '$rootScope', '$location', 'queryStrings', 'navi
         eventsService.on("app.authenticated", function(evt, data) {
             
             assetsService._loadInitAssets().then(function() {
-                
-                //Register all of the tours on the server
-                tourService.registerAllTours().then(function () {
-                    appReady(data);
-                    
-                    // Auto start intro tour
-                    tourService.getTourByAlias("umbIntroIntroduction").then(function (introTour) {
-                        // start intro tour if it hasn't been completed or disabled
-                        if (introTour && introTour.disabled !== true && introTour.completed !== true) {
-                            tourService.startTour(introTour);
-                        }
+
+                // Loads the user's locale settings for Moment.
+                userService.loadMomentLocaleForCurrentUser().then(function() {
+
+                    //Register all of the tours on the server
+                    tourService.registerAllTours().then(function () {
+                        appReady(data);
+                        
+                        // Auto start intro tour
+                        tourService.getTourByAlias("umbIntroIntroduction").then(function (introTour) {
+                            // start intro tour if it hasn't been completed or disabled
+                            if (introTour && introTour.disabled !== true && introTour.completed !== true) {
+                                tourService.startTour(introTour);
+                            }
+                        });
+
+                    }, function(){
+                        appReady(data);
                     });
-
-                }, function(){
-                    appReady(data);
                 });
-
             });
 
         });

src/Umbraco.Web.UI.Client/src/less/belle.less

@@ -168,9 +168,6 @@
 //used for property editors
 @import "property-editors.less";
 
-//used for prevalue editors
-@import "components/prevalues/multivalues.less";
-
 
 @import "typeahead.less";
 @import "hacks.less";
@@ -178,4 +175,4 @@
 @import "healthcheck.less";
 
 // cleanup properties.less when it is done
-@import "properties.less";
+@import "properties.less";

src/Umbraco.Web.UI.Client/src/less/components/prevalues/multivalues.less

@@ -1,53 +0,0 @@
-.umb-prevalues-multivalues {
-    width: 400px;
-}
-
-.umb-prevalues-multivalues__left {
-    display: flex;
-    flex: 1 1 auto;
-}
-
-.umb-prevalues-multivalues__right {
-    display: flex;
-    flex: 0 0 auto;
-    align-items: center;
-}
-
-.umb-prevalues-multivalues__add  {
-    display: flex;
-}
-
-.umb-prevalues-multivalues__add input {
-    width: 320px;
-}
-
-.umb-prevalues-multivalues__add input {
-    display: flex;
-}
-
-.umb-prevalues-multivalues__add button {
-    margin: 0 6px 0 0;
-    float: right
-}
-
-.umb-prevalues-multivalues__listitem {
-    display: flex;
-    padding: 6px;
-    margin: 10px 0px !important;
-    background: #F3F3F5;
-    cursor: move;
-}
-
-.umb-prevalues-multivalues__listitem i {
-    display: flex;
-    align-items: center;
-    margin-right: 5px
-}
-
-.umb-prevalues-multivalues__listitem a {
-    cursor: pointer;
-}
-
-.umb-prevalues-multivalues__listitem input {
-    width: 295px;
-}

src/Umbraco.Web.UI.Client/src/less/components/umb-grid.less

@@ -280,6 +280,7 @@
 .umb-grid .umb-control {
     position: relative;
     display: block;
+    overflow: hidden;
     margin-left: 10px;
     margin-right: 10px;
     margin-bottom: 10px;

src/Umbraco.Web.UI.Client/src/less/property-editors.less

@@ -40,16 +40,6 @@
   padding: 10px;
 }
 
-.umb-contentpicker__min-max-help {
-    font-size: 13px;
-    margin-top: 5px;
-    color: @gray-4;
-}
-
-.show-validation .umb-contentpicker__min-max-help {
-    display: none;
-}
-
 .umb-contentpicker small {
 
   &:not(:last-child) {
@@ -119,22 +109,22 @@ ul.color-picker li a  {
 }
 
 /* pre-value editor */
-/*.control-group.color-picker-preval:before {
-    content: "";
-    display: inline-block;
-    vertical-align: middle;
+/*.control-group.color-picker-preval:before {
+    content: "";
+    display: inline-block;
+    vertical-align: middle;
     height: 100%;
-}*/
-
-/*.control-group.color-picker-preval div.thumbnail {
-    display: inline-block;
+}*/
+
+/*.control-group.color-picker-preval div.thumbnail {
+    display: inline-block;
     vertical-align: middle;
-}*/
-.control-group.color-picker-preval div.color-picker-prediv {
-    display: inline-block;
+}*/
+.control-group.color-picker-preval div.color-picker-prediv {
+    display: inline-block;
     width: 60%;
-}
-
+}
+
 .control-group.color-picker-preval pre {
     display: inline;
     margin-right: 20px;
@@ -146,18 +136,18 @@ ul.color-picker li a  {
     vertical-align: middle;
 }
 
-.control-group.color-picker-preval btn {
+.control-group.color-picker-preval btn {
     //vertical-align: middle;
-}
+}
 
-.control-group.color-picker-preval input[type="text"] {
-    min-width: 40%;
-    width: 40%;
-    display: inline-block;
-    margin-right: 20px;
+.control-group.color-picker-preval input[type="text"] {
+    min-width: 40%;
+    width: 40%;
+    display: inline-block;
+    margin-right: 20px;
     margin-top: 1px;
-}
-
+}
+
 .control-group.color-picker-preval label {
     border: solid @white 1px;
     padding: 6px;
@@ -213,22 +203,10 @@ ul.color-picker li a  {
 
 
 
-.umb-thumbnails {
-    position: relative;
-    display: flex;
-    -ms-flex-direction: row;
-    -webkit-flex-direction: row;
-    flex-direction: row;
-    -ms-flex-wrap: wrap;
-    -webkit-flex-wrap: wrap;
-    flex-wrap: wrap;
-    justify-content: flex-start;
+.umb-thumbnails{
+  position: relative;
 }
 
-.umb-thumbnails > li.icon {
-    width: 14%;
-    text-align: center;
-}
 
 .umb-thumbnails i{margin: auto;}
 .umb-thumbnails a{

src/Umbraco.Web.UI.Client/src/less/variables.less

@@ -100,27 +100,6 @@
 .color-green, .color-green i{color: @green-d1 !important;}
 .color-yellow, .color-yellow i{color: @yellow-d1 !important;}
 
-/* Colors based on http://zavoloklom.github.io/material-design-color-palette/colors.html */
-.color-black, .color-black i { color: #000 !important; }
-.color-blue-grey, .color-blue-grey i { color: #607d8b !important; }
-.color-grey, .color-grey i { color: #9e9e9e !important; }
-.color-brown, .color-brown i { color: #795548 !important; }
-.color-blue, .color-blue i { color: #2196f3 !important; }
-.color-light-blue, .color-light-blue i {color: #03a9f4 !important; }
-.color-cyan, .color-cyan i { color: #00bcd4 !important; }
-.color-green, .color-green i { color: #4caf50 !important; }
-.color-light-green, .color-light-green i {color: #8bc34a !important; }
-.color-lime, .color-lime i { color: #cddc39 !important; }
-.color-yellow, .color-yellow i { color: #ffeb3b !important; }
-.color-amber, .color-amber i { color: #ffc107 !important; }
-.color-orange, .color-orange i { color: #ff9800 !important; }
-.color-deep-orange, .color-deep-orange i { color: #ff5722 !important; }
-.color-red, .color-red i { color: #f44336 !important; }
-.color-pink, .color-pink i { color: #e91e63 !important; }
-.color-purple,.color-purple i { color: #9c27b0 !important; }
-.color-deep-purple, .color-deep-purple i { color: #673ab7 !important; }
-.color-indigo, .color-indigo i { color: #3f51b5 !important; }
-
 
 // Scaffolding
 // -------------------------

src/Umbraco.Web.UI.Client/src/views/common/dialogs/iconpicker.controller.js

@@ -7,13 +7,14 @@ angular.module("umbraco")
             	$scope.icons = icons;
             });
 
-			$scope.submitClass = function(icon){
+            $scope.submitClass = function (icon) {
 				if($scope.color) {
 					$scope.submit(icon + " " + $scope.color);
 				}
-				else {
-					$scope.submit(icon);	
+                else {
+					$scope.submit(icon);
 				}
 			};
+
 		}
 	);

src/Umbraco.Web.UI.Client/src/views/common/overlays/iconpicker/iconpicker.html

@@ -16,25 +16,24 @@
 
     <div class="umb-control-group">
         <select ng-model="color" class="input-block-level">
-            <option value=""><localize key="colors_black">Black</localize></option>
-            <option value="color-blue-grey"><localize key="colors_bluegrey">Blue Grey</localize></option>
-            <option value="color-grey"><localize key="colors_grey">Grey</localize></option>
-            <option value="color-brown"><localize key="colors_brown">Brown</localize></option>
-            <option value="color-blue"><localize key="colors_blue">Blue</localize></option>
-            <option value="color-light-blue"><localize key="colors_lightblue">Light Blue</localize></option>
-            <option value="color-cyan"><localize key="colors_cyan">Cyan</localize></option>
-            <option value="color-green"><localize key="colors_green">Green</localize></option>
-            <option value="color-light-green"><localize key="colors_lightgreen">Light Green</localize></option>
-            <option value="color-yellow"><localize key="colors_yellow">Yellow</localize></option>
-            <option value="color-lime"><localize key="colors_lime">Lime</localize></option>
-            <option value="color-amber"><localize key="colors_amber">Amber</localize></option>
-            <option value="color-orange"><localize key="colors_orange">Orange</localize></option>
-            <option value="color-deep-orange"><localize key="colors_deeporange">Deep Orange</localize></option>
-            <option value="color-red"><localize key="colors_red">Red</localize></option>
-            <option value="color-pink"><localize key="colors_pink">Pink</localize></option>
-            <option value="color-purple"><localize key="colors_purple">Purple</localize></option>
-            <option value="color-deep-purple"><localize key="colors_deeppurple">Deep Purple</localize></option>
-            <option value="color-indigo"><localize key="colors_indigo">Indigo</localize></option>
+            <option value="">
+                <localize key="colors_black">Black</localize>
+            </option>
+            <option value="color-green">
+                <localize key="colors_green">Green</localize>
+            </option>
+            <option value="color-yellow">
+                <localize key="colors_yellow">Yellow</localize>
+            </option>
+            <option value="color-orange">
+                <localize key="colors_orange">Orange</localize>
+            </option>
+            <option value="color-blue">
+                <localize key="colors_blue">Blue</localize>
+            </option>
+            <option value="color-red">
+                <localize key="colors_red">Red</localize>
+            </option>
         </select>
     </div>
 

src/Umbraco.Web.UI.Client/src/views/components/umb-table.html

@@ -47,17 +47,7 @@
                     </a>
                 </div>
                 <div class="umb-table-cell" ng-repeat="column in itemProperties">
-                    <span title="{{column.header}}: {{item[column.alias]}}">
-
-                        <div ng-if="!column.isSensitive">
-                            {{item[column.alias]}}
-                        </div>
-
-                        <em ng-show="column.isSensitive" class="muted">
-                            <localize key="content_isSensitiveValue_short"></localize>
-                        </em>
-
-                    </span>
+                    <span title="{{column.header}}: {{item[column.alias]}}">{{item[column.alias]}}</span>
                 </div>
             </div>
         </div>

src/Umbraco.Web.UI.Client/src/views/prevalueeditors/multivalues.controller.js

@@ -5,7 +5,6 @@ angular.module("umbraco").controller("Umbraco.PrevalueEditors.MultiValuesControl
 
         $scope.newItem = "";
         $scope.hasError = false;
-        $scope.focusOnNew = false;
        
         if (!angular.isArray($scope.model.value)) {
 
@@ -44,7 +43,6 @@ angular.module("umbraco").controller("Umbraco.PrevalueEditors.MultiValuesControl
                     $scope.model.value.push({ value: $scope.newItem });
                     $scope.newItem = "";
                     $scope.hasError = false;
-                    $scope.focusOnNew = true;
                     return;
                 }
             }
@@ -75,12 +73,6 @@ angular.module("umbraco").controller("Umbraco.PrevalueEditors.MultiValuesControl
             }
         };
 
-        $scope.createNew = function (event) {
-            if (event.keyCode == 13) {
-                $scope.add(event);
-            }
-        }
-
         function getElementIndexByPrevalueText(value) {
             for (var i = 0; i < $scope.model.value.length; i++) {
                 if ($scope.model.value[i].value === value) {

src/Umbraco.Web.UI.Client/src/views/prevalueeditors/multivalues.html

@@ -1,21 +1,13 @@
-<div class="umb-editor umb-prevalues-multivalues" ng-controller="Umbraco.PrevalueEditors.MultiValuesController">
-    <div class="control-group umb-prevalues-multivalues__add">
-        <div class="umb-prevalues-multivalues__left">
-            <input overlay-submit-on-enter="false" name="newItem" focus-when="{{focusOnNew}}" ng-keydown="createNew($event)" type="text" ng-model="newItem" val-highlight="{{hasError}}" />
-        </div>
-        <div class="umb-prevalues-multivalues__right">
-            <button class="btn btn-info" ng-click="add($event)">Add</button>
-        </div>
+<div class="umb-editor" ng-controller="Umbraco.PrevalueEditors.MultiValuesController">
+    <div class="control-group">
+        <input name="newItem" type="text" ng-model="newItem" val-highlight="{{hasError}}" />
+        <button class="btn" ng-click="add($event)">Add</button>
     </div>
     <div ui-sortable="sortableOptions">
-        <div class="control-group umb-prevalues-multivalues__listitem" ng-repeat="item in model.value">
+        <div class="control-group" ng-repeat="item in model.value">
             <i class="icon icon-navigation handle"></i>
-            <div class="umb-prevalues-multivalues__left">
-                <input type="text" ng-model="item.value" val-server="item_{{$index}}" required />
-            </div>
-            <div class="umb-prevalues-multivalues__right">
-                <a class="umb-node-preview__action" ng-click="remove(item, $event)">Remove</a>
-            </div>
+            <input type="text" ng-model="item.value" val-server="item_{{$index}}" required />
+            <button class="btn btn-danger" ng-click="remove(item, $event)">Remove</button>
         </div>
     </div>
 </div>

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

@@ -66,8 +66,6 @@ function contentPickerController($scope, entityResource, editorState, iconHelper
         showOpenButton: false,
         showEditButton: false,
         showPathOnHover: false,
-        maxNumber: 1,
-        minNumber : 0,
         startNode: {
             query: "",
             type: "content",

src/Umbraco.Web.UI.Client/src/views/propertyeditors/contentpicker/contentpicker.html

@@ -20,7 +20,7 @@
             </umb-node-preview>
         </div>
  
-        <a ng-show="model.config.multiPicker === true && renderModel.length < model.config.maxNumber || renderModel.length === 0 || !model.config.maxNumber"
+        <a ng-show="model.config.multiPicker === true || renderModel.length === 0"
             class="umb-node-preview-add"
             href=""
             ng-click="openContentPicker()"
@@ -28,39 +28,6 @@
             <localize key="general_add">Add</localize>
         </a>
 
-        <div class="umb-contentpicker__min-max-help" ng-if="model.config.multiPicker === true">
-
-            <!-- Both min and max items -->
-            <span ng-if="model.config.minNumber && model.config.maxNumber && model.config.minNumber !== model.config.maxNumber">
-                <span ng-if="renderModel.length < model.config.maxNumber">Add between {{model.config.minNumber}} and {{model.config.maxNumber}} items</span>
-                <span ng-if="renderModel.length > model.config.maxNumber">
-                    <localize key="validation_maxCount">You can only have</localize> {{model.config.maxNumber}} <localize key="validation_itemsSelected"> items selected</localize>
-                </span>
-            </span>
-            
-            <!-- Equal min and max -->
-            <span ng-if="model.config.minNumber && model.config.maxNumber && model.config.minNumber === model.config.maxNumber">
-                <span ng-if="renderModel.length < model.config.maxNumber">Add {{model.config.minNumber - renderModel.length}} item(s)</span>
-                <span ng-if="renderModel.length > model.config.maxNumber">
-                    <localize key="validation_maxCount">You can only have</localize> {{model.config.maxNumber}} <localize key="validation_itemsSelected"> items selected</localize>
-                </span>
-            </span>
-
-            <!-- Only max -->
-            <span ng-if="!model.config.minNumber && model.config.maxNumber">
-                <span ng-if="renderModel.length < model.config.maxNumber">Add up to {{model.config.maxNumber}} items</span>
-                <span ng-if="renderModel.length > model.config.maxNumber">
-                    <localize key="validation_maxCount">You can only have</localize> {{model.config.maxNumber}} <localize key="validation_itemsSelected">items selected</localize>
-                </span>
-            </span>
-
-            <!-- Only min -->
-            <span ng-if="model.config.minNumber && !model.config.maxNumber && renderModel.length < model.config.minNumber">
-                Add at least {{model.config.minNumber}} item(s)
-            </span>
-
-        </div>
-
         <!--These are here because we need ng-form fields to validate against-->
         <input type="hidden" name="minCount" ng-model="renderModel" />
         <input type="hidden" name="maxCount" ng-model="renderModel" />

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

@@ -157,26 +157,24 @@ angular.module("umbraco")
     .controller('Umbraco.PropertyEditors.FileUploadController', fileUploadController)
     .run(function(mediaHelper, umbRequestHelper, assetsService){
         if (mediaHelper && mediaHelper.registerFileResolver) {
-            assetsService.load(["lib/moment/moment-with-locales.js"]).then(
-                function () {
-                    //NOTE: The 'entity' can be either a normal media entity or an "entity" returned from the entityResource
-                    // they contain different data structures so if we need to query against it we need to be aware of this.
-                    mediaHelper.registerFileResolver("Umbraco.UploadField", function(property, entity, thumbnail){
-                        if (thumbnail) {
-                            if (mediaHelper.detectIfImageByExtension(property.value)) {
-                                //get default big thumbnail from image processor
-                                var thumbnailUrl = property.value + "?rnd=" + moment(entity.updateDate).format("YYYYMMDDHHmmss") + "&width=500&animationprocessmode=first";
-                                return thumbnailUrl;
-                            }
-                            else {
-                                return null;
-                            }
-                        }
-                        else {
-                            return property.value;
-                        }
-                    });
+
+            //NOTE: The 'entity' can be either a normal media entity or an "entity" returned from the entityResource
+            // they contain different data structures so if we need to query against it we need to be aware of this.
+            mediaHelper.registerFileResolver("Umbraco.UploadField", function(property, entity, thumbnail){
+                if (thumbnail) {
+                    if (mediaHelper.detectIfImageByExtension(property.value)) {
+                        //get default big thumbnail from image processor
+                        var thumbnailUrl = property.value + "?rnd=" + moment(entity.updateDate).format("YYYYMMDDHHmmss") + "&width=500&animationprocessmode=first";
+                        return thumbnailUrl;
+                    }
+                    else {
+                        return null;
+                    }
                 }
-            );
+                else {
+                    return property.value;
+                }
+            });
+
         }
     });

src/Umbraco.Web.UI.Client/src/views/propertyeditors/listview/layouts/list/list.listviewlayout.controller.js

@@ -30,14 +30,15 @@
         vm.dragLeave = dragLeave;
         vm.onFilesQueue = onFilesQueue;
         vm.onUploadComplete = onUploadComplete;
-        markAsSensitive();
 
         function activate() {
+
             if ($scope.entityType === 'media') {
                 mediaTypeHelper.getAllowedImagetypes(vm.nodeId).then(function (types) {
                     vm.acceptedMediatypes = types;
                 });
             }
+
         }
 
         function selectAll($event) {
@@ -86,27 +87,6 @@
             $scope.getContent($scope.contentId);
         }
 
-        function markAsSensitive() {
-            angular.forEach($scope.options.includeProperties, function (option) {
-                option.isSensitive = false;
-
-                angular.forEach($scope.items,
-                    function (item) {
-
-                        angular.forEach(item.properties,
-                            function (property) {
-
-                                if (option.alias === property.alias) {
-                                    option.isSensitive = property.isSensitive;
-                                }
-
-                            });
-
-                    });
-
-            });
-        }
-
         activate();
 
     }

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

@@ -46,7 +46,6 @@ function MarkdownEditorController($scope, $element, assetsService, dialogService
                 // init the md editor after this digest because the DOM needs to be ready first
                 // so run the init on a timeout
                 $timeout(function () {
-                    $scope.markdownEditorInitComplete = false;
                     var converter2 = new Markdown.Converter();
                     var editor2 = new Markdown.Editor(converter2, "-" + $scope.model.alias);
                     editor2.run();
@@ -60,12 +59,7 @@ function MarkdownEditorController($scope, $element, assetsService, dialogService
                     editor2.hooks.set("onPreviewRefresh", function () {
                         // We must manually update the model as there is no way to hook into the markdown editor events without exstensive edits to the library.
                         if ($scope.model.value !== $("textarea", $element).val()) {
-                            if ($scope.markdownEditorInitComplete) {
-                                //only set dirty after init load to avoid "unsaved" dialogue when we don't want it
-                                angularHelper.getCurrentForm($scope).$setDirty();
-                            } else {
-                                $scope.markdownEditorInitComplete = true;
-                            }
+                            angularHelper.getCurrentForm($scope).$setDirty();
                             $scope.model.value = $("textarea", $element).val();
                         }
                     });

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

@@ -359,8 +359,7 @@ angular.module("umbraco")
                 //this is instead of doing a watch on the model.value = faster
                 $scope.model.onValueChanged = function (newVal, oldVal) {
                     //update the display val again if it has changed from the server;
-                    //uses an empty string in the editor when the value is null
-                    tinyMceEditor.setContent(newVal || "", { format: 'raw' });
+                    tinyMceEditor.setContent(newVal, { format: 'raw' });
                     //we need to manually fire this event since it is only ever fired based on loading from the DOM, this
                     // is required for our plugins listening to this event to execute
                     tinyMceEditor.fire('LoadContent', null);

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

@@ -92,6 +92,7 @@
         $scope.model.config.ticksPositions = _.map($scope.model.config.ticksPositions.split(','), function (item) {
             return parseInt(item.trim());
         });
+        console.log($scope.model.config.ticksPositions);
     }
 
     if (!$scope.model.config.ticksLabels) {
@@ -214,4 +215,4 @@
     assetsService.loadCss("lib/slider/bootstrap-slider.css");
     assetsService.loadCss("lib/slider/bootstrap-slider-custom.css");
 }
-angular.module("umbraco").controller("Umbraco.PropertyEditors.SliderController", sliderController);
+angular.module("umbraco").controller("Umbraco.PropertyEditors.SliderController", sliderController);

src/Umbraco.Web.UI.Client/test/config/karma.conf.js

@@ -99,4 +99,4 @@ module.exports = function (config) {
       'karma-phantomjs-launcher'
     ]
   });
-};
+};

src/Umbraco.Web.UI/Umbraco.Web.UI.csproj

@@ -1023,9 +1023,9 @@ xcopy "$(ProjectDir)"..\packages\SqlServerCE.4.0.0.1\x86\*.* "$(TargetDir)x86\"
         <WebProjectProperties>
           <UseIIS>True</UseIIS>
           <AutoAssignPort>True</AutoAssignPort>
-          <DevelopmentServerPort>7940</DevelopmentServerPort>
+          <DevelopmentServerPort>7920</DevelopmentServerPort>
           <DevelopmentServerVPath>/</DevelopmentServerVPath>
-          <IISUrl>http://localhost:7940</IISUrl>
+          <IISUrl>http://localhost:7920</IISUrl>
           <NTLMAuthentication>False</NTLMAuthentication>
           <UseCustomServer>False</UseCustomServer>
           <CustomServerUrl>

src/Umbraco.Web.UI/umbraco/config/create/UI.Release.xml

@@ -19,7 +19,6 @@
     <header>Macro</header>
     <usercontrol>/create/xslt.ascx</usercontrol>
     <tasks>
-	  <create assembly="umbraco" type="XsltTasks" />
       <delete assembly="umbraco" type="XsltTasks" />
     </tasks>
   </nodeType>

src/Umbraco.Web.UI/umbraco/config/create/UI.xml

@@ -19,7 +19,6 @@
     <header>Macro</header>
     <usercontrol>/create/xslt.ascx</usercontrol>
     <tasks>
-      <create assembly="umbraco" type="XsltTasks" />
       <delete assembly="umbraco" type="XsltTasks" />
     </tasks>
   </nodeType>

src/Umbraco.Web.UI/umbraco/config/lang/da.xml

@@ -661,7 +661,7 @@
   <area alias="graphicheadline">
     <key alias="backgroundcolor">Baggrundsfarve</key>
     <key alias="bold">Fed</key>
-    <key alias="color">Tekstfarve</key>
+    <key alias="color">Tekst farve</key>
     <key alias="font">Skrifttype</key>
     <key alias="text">Tekst</key>
   </area>
@@ -1259,9 +1259,9 @@ Mange hilsner fra Umbraco robotten
 
 
     <key alias="styles">Typografi</key>
-    <key alias="stylesDetails">Vælg hvilke typografiværdier en redaktør kan ændre</key>
+    <key alias="stylesDetails">Vælg, hvilke typografiværdier, en redaktør kan ændre</key>
 
-    <key alias="settingDialogDetails">Indstillinger gemmes kun, hvis den indtastede json-konfiguration er gyldig</key>
+    <key alias="settingDialogDetails">Indstillinger gemmes kun, hvis den indtaste json-konfiguration er gyldig</key>
 
     <key alias="allowAllEditors">Tillad alle editorer</key>
     <key alias="allowAllRowConfigurations">Tillad alle rækkekonfigurationer</key>
@@ -1272,7 +1272,7 @@ Mange hilsner fra Umbraco robotten
     <key alias="areAdded">er tilføjet</key>
 
     <key alias="maxItems">Maksimalt emner</key>
-    <key alias="maxItemsDescription">Efterlad blank eller sæt til 0 for ubegrænset</key>
+    <key alias="maxItemsDescription">Efterlad blank eller sat til 0 ubegrænset for</key>
 
   </area>
   <area alias="contentTypeEditor">
@@ -1282,7 +1282,7 @@ Mange hilsner fra Umbraco robotten
     <key alias="addNewTab">Tilføj ny fane</key>
     <key alias="addAnotherTab">Tilføj endnu en fane</key>
     <key alias="inheritedFrom">Nedarvet fra</key>
-    <key alias="addProperty">Tilføj egenskab</key>
+    <key alias="addProperty">Tilføj property</key>
     <key alias="requiredLabel">Påkrævet label</key>
 
     <key alias="enableListViewHeading">Aktiver listevisning</key>
@@ -1473,6 +1473,7 @@ Mange hilsner fra Umbraco robotten
     <key alias="noLogin">har endnu ikke logget ind</key>
     <key alias="oldPassword">Gammelt kodeord</key>
     <key alias="password">Adgangskode</key>
+    <key alias="removePhoto">Fjern billede</key>
     <key alias="resetPassword">Nulstil kodeord</key>
     <key alias="passwordChanged">Dit kodeord er blevet ændret!</key>
     <key alias="passwordConfirm">Bekræft venligst dit nye kodeord</key>

src/Umbraco.Web.UI/umbraco/config/lang/en.xml

@@ -229,7 +229,6 @@
         <key alias="removeTextBox">Remove this text box</key>
         <key alias="contentRoot">Content root</key>
         <key alias="isSensitiveValue">This value is hidden. If you need access to view this value please contact your website administrator.</key>
-        <key alias="isSensitiveValue_short">This value is hidden.</key>
     </area>
     <area alias="blueprints">
         <key alias="createBlueprintFrom">Create a new Content Template from '%0%'</key>
@@ -663,20 +662,7 @@
         <key alias="yellow">Yellow</key>
         <key alias="orange">Orange</key>
         <key alias="blue">Blue</key>
-        <key alias="bluegrey">Blue Grey</key>
-        <key alias="grey">Grey</key>
-        <key alias="brown">Brown</key>
-        <key alias="lightblue">Light Blue</key>
-        <key alias="cyan">Cyan</key>
-        <key alias="lightgreen">Light Green</key>
-        <key alias="lime">Lime</key>
-        <key alias="amber">Amber</key>
-        <key alias="deeporange">Deep Orange</key>
         <key alias="red">Red</key>
-        <key alias="pink">Pink</key>
-        <key alias="purple">Purple</key>
-        <key alias="deeppurple">Deep Purple</key>
-        <key alias="indigo">Indigo</key>
     </area>
 
     <area alias="shortcuts">

src/Umbraco.Web.UI/umbraco/config/lang/en_us.xml

@@ -229,7 +229,6 @@
         <key alias="removeTextBox">Remove this text box</key>
         <key alias="contentRoot">Content root</key>
         <key alias="isSensitiveValue">This value is hidden. If you need access to view this value please contact your website administrator.</key>
-        <key alias="isSensitiveValue_short">This value is hidden.</key>
     </area>
     <area alias="blueprints">
         <key alias="createBlueprintFrom">Create a new Content Template from '%0%'</key>
@@ -661,20 +660,7 @@
         <key alias="yellow">Yellow</key>
         <key alias="orange">Orange</key>
         <key alias="blue">Blue</key>
-        <key alias="bluegrey">Blue Grey</key>
-        <key alias="grey">Grey</key>
-        <key alias="brown">Brown</key>
-        <key alias="lightblue">Light Blue</key>
-        <key alias="cyan">Cyan</key>
-        <key alias="lightgreen">Light Green</key>
-        <key alias="lime">Lime</key>
-        <key alias="amber">Amber</key>
-        <key alias="deeporange">Deep Orange</key>
         <key alias="red">Red</key>
-        <key alias="pink">Pink</key>
-        <key alias="purple">Purple</key>
-        <key alias="deeppurple">Deep Purple</key>
-        <key alias="indigo">Indigo</key>
     </area>
     <area alias="shortcuts">
         <key alias="addTab">Add tab</key>

src/Umbraco.Web/Editors/BackOfficeAssetsController .cs

@@ -0,0 +1,28 @@
+using System.Collections.Generic;
+using System.Linq;
+using System.Web.Http;
+using Umbraco.Core.IO;
+using Umbraco.Web.Mvc;
+
+namespace Umbraco.Web.Editors
+{
+    [PluginController("UmbracoApi")]
+    public class BackOfficeAssetsController : UmbracoAuthorizedJsonController
+    {
+        
+        [HttpGet]
+        public IEnumerable<string> GetSupportedMomentLocales()
+        {
+            var momentLocaleFolder = "moment";
+            var fileSystem = FileSystemProviderManager.Current.JavaScriptLibraryFileSystem;
+            var cultures = fileSystem.GetFiles(momentLocaleFolder, "*.js").ToList();
+            for (var i = 0; i < cultures.Count(); i++)
+            {
+                cultures[i] = cultures[i]
+                    .Substring(cultures[i].IndexOf(momentLocaleFolder) + momentLocaleFolder.Length + 1);
+            }
+            return cultures;
+        }
+
+    }
+}

src/Umbraco.Web/Editors/BackOfficeServerVariables.cs

@@ -268,6 +268,10 @@ namespace Umbraco.Web.Editors
                         {
                             "helpApiBaseUrl", _urlHelper.GetUmbracoApiServiceBaseUrl<HelpController>(
                                 controller => controller.GetContextHelpForPage("","",""))
+                        },
+                        {
+                            "backOfficeAssetsApiBaseUrl", _urlHelper.GetUmbracoApiServiceBaseUrl<BackOfficeAssetsController>(
+                                controller => controller.GetSupportedMomentLocales())
                         }
                     }
                 },

src/Umbraco.Web/Editors/MemberController.cs

@@ -1,18 +1,29 @@
 using System;
+using System.Collections.Generic;
 using System.ComponentModel.DataAnnotations;
+using System.IO;
 using System.Linq;
 using System.Net;
 using System.Net.Http;
 using System.Net.Http.Formatting;
 using System.Net.Http.Headers;
+using System.Reflection;
+using System.Reflection;
+using System.Text;
+using System.Threading.Tasks;
+using System.Web;
 using System.Web.Http;
 using System.Web.Http.ModelBinding;
 using System.Web.Security;
 using AutoMapper;
+using Examine.LuceneEngine.SearchCriteria;
+using Examine.SearchCriteria;
 using Umbraco.Core;
 using Umbraco.Core.Logging;
 using Umbraco.Core.Models;
+using Umbraco.Core.Models.EntityBase;
 using Umbraco.Core.Models.Membership;
+using Umbraco.Core.Persistence;
 using Umbraco.Core.Persistence.DatabaseModelDefinitions;
 using Umbraco.Core.Security;
 using Umbraco.Core.Services;
@@ -22,7 +33,10 @@ using Umbraco.Web.Models.ContentEditing;
 using Umbraco.Web.Mvc;
 using Umbraco.Web.WebApi.Binders;
 using Umbraco.Web.WebApi.Filters;
+using umbraco;
 using Constants = Umbraco.Core.Constants;
+using Examine;
+using Newtonsoft.Json;
 
 namespace Umbraco.Web.Editors
 {
@@ -82,18 +96,16 @@ namespace Umbraco.Web.Editors
 
             if (MembershipScenario == MembershipScenario.NativeUmbraco)
             {
+                long totalRecords;
                 var members = Services.MemberService
-                    .GetAll((pageNumber - 1), pageSize, out var totalRecords, orderBy, orderDirection, orderBySystemField, memberTypeAlias, filter).ToArray();
+                    .GetAll((pageNumber - 1), pageSize, out totalRecords, orderBy, orderDirection, orderBySystemField, memberTypeAlias, filter).ToArray();
                 if (totalRecords == 0)
                 {
                     return new PagedResult<MemberBasic>(0, 0, 0);
                 }
-
-                var pagedResult = new PagedResult<MemberBasic>(totalRecords, pageNumber, pageSize)
-                {
-                    Items = members
-                        .Select(x => AutoMapperExtensions.MapWithUmbracoContext<IMember, MemberBasic>(x, UmbracoContext))
-                };
+                var pagedResult = new PagedResult<MemberBasic>(totalRecords, pageNumber, pageSize);
+                pagedResult.Items = members
+                    .Select(Mapper.Map<IMember, MemberBasic>);
                 return pagedResult;
             }
             else
@@ -121,13 +133,10 @@ namespace Umbraco.Web.Editors
                 {
                     return new PagedResult<MemberBasic>(0, 0, 0);
                 }
-
-                var pagedResult = new PagedResult<MemberBasic>(totalRecords, pageNumber, pageSize)
-                {
-                    Items = members
-                        .Cast<MembershipUser>()
-                        .Select(Mapper.Map<MembershipUser, MemberBasic>)
-                };
+                var pagedResult = new PagedResult<MemberBasic>(totalRecords, pageNumber, pageSize);
+                pagedResult.Items = members
+                    .Cast<MembershipUser>()
+                    .Select(Mapper.Map<MembershipUser, MemberBasic>);
                 return pagedResult;
             }
 
@@ -428,7 +437,7 @@ namespace Umbraco.Web.Editors
                 var sensitiveProperties = contentItem.PersistedContent.ContentType
                     .PropertyTypes.Where(x => contentItem.PersistedContent.ContentType.IsSensitiveProperty(x.Alias))
                     .ToList();
-
+                
                 foreach (var sensitiveProperty in sensitiveProperties)
                 {
                     //if found, change the value of the contentItem model to the persisted value so it remains unchanged
@@ -656,7 +665,7 @@ namespace Umbraco.Web.Editors
                         contentItem.Email,
                         "TEMP", //some membership provider's require something here even if q/a is disabled!
                         "TEMP", //some membership provider's require something here even if q/a is disabled!
-                        contentItem.IsApproved,
+                        contentItem.IsApproved, 
                         contentItem.PersistedContent.Key, //custom membership provider, we'll link that based on the IMember unique id (GUID)
                         out status);
 
@@ -673,7 +682,7 @@ namespace Umbraco.Web.Editors
                         contentItem.Email,
                         "TEMP", //some membership provider's require something here even if q/a is disabled!
                         "TEMP", //some membership provider's require something here even if q/a is disabled!
-                        contentItem.IsApproved,
+                        contentItem.IsApproved, 
                         newKey,
                         out status);
 
@@ -819,17 +828,17 @@ namespace Umbraco.Web.Editors
             var member = ((MemberService)Services.MemberService).ExportMember(key);
 
             var fileName = $"{member.Name}_{member.Email}.txt";
-
-            httpResponseMessage.Content = new ObjectContent<MemberExportModel>(member, new JsonMediaTypeFormatter { Indent = true });
+            
+            httpResponseMessage.Content = new ObjectContent<MemberExportModel>(member, new JsonMediaTypeFormatter {Indent = true});
             httpResponseMessage.Content.Headers.Add("x-filename", fileName);
             httpResponseMessage.Content.Headers.ContentType = new MediaTypeHeaderValue("application/octet-stream");
             httpResponseMessage.Content.Headers.ContentDisposition = new ContentDispositionHeaderValue("attachment");
             httpResponseMessage.Content.Headers.ContentDisposition.FileName = fileName;
             httpResponseMessage.StatusCode = HttpStatusCode.OK;
-
+            
             return httpResponseMessage;
         }
     }
 
-
+    
 }

src/Umbraco.Web/Editors/TourController.cs

@@ -70,20 +70,14 @@ namespace Umbraco.Web.Editors
             //Checking to see if the user has access to the required tour sections, else we remove the tour
             foreach (var backOfficeTourFile in result)
             {
-                if (backOfficeTourFile.Tours != null)
+                foreach (var tour in backOfficeTourFile.Tours)
                 {
-                    foreach (var tour in backOfficeTourFile.Tours)
+                    foreach (var toursRequiredSection in tour.RequiredSections)
                     {
-                        if (tour.RequiredSections != null)
+                        if (allowedSections.Contains(toursRequiredSection) == false)
                         {
-                            foreach (var toursRequiredSection in tour.RequiredSections)
-                            {
-                                if (allowedSections.Contains(toursRequiredSection) == false)
-                                {
-                                    toursToBeRemoved.Add(backOfficeTourFile);
-                                    break;
-                                }
-                            }
+                            toursToBeRemoved.Add(backOfficeTourFile);
+                            break;
                         }
                     }
                 }

src/Umbraco.Web/Models/BackOfficeTour.cs

@@ -9,11 +9,6 @@ namespace Umbraco.Web.Models
     [DataContract(Name = "tour", Namespace = "")]
     public class BackOfficeTour
     {
-        public BackOfficeTour()
-        {
-            RequiredSections = new List<string>();
-        }
-
         [DataMember(Name = "name")]
         public string Name { get; set; }
         [DataMember(Name = "alias")]

src/Umbraco.Web/Models/BackOfficeTourFile.cs

@@ -9,11 +9,6 @@ namespace Umbraco.Web.Models
     [DataContract(Name = "tourFile", Namespace = "")]
     public class BackOfficeTourFile
     {
-        public BackOfficeTourFile()
-        {
-            Tours = new List<BackOfficeTour>();
-        }
-
         /// <summary>
         /// The file name for the tour
         /// </summary>
@@ -32,4 +27,4 @@ namespace Umbraco.Web.Models
         [DataMember(Name = "tours")]
         public IEnumerable<BackOfficeTour> Tours { get; set; }
     }
-}
+}

src/Umbraco.Web/Models/ContentEditing/ContentPropertyBasic.cs

@@ -30,11 +30,6 @@ namespace Umbraco.Web.Models.ContentEditing
         [DataMember(Name = "editor", IsRequired = false)]
         public string Editor { get; set; }
 
-        /// <summary>
-        /// Flags the property to denote that it can contain sensitive data
-        /// </summary>
-        [DataMember(Name = "isSensitive", IsRequired = false)]
-        public bool IsSensitive { get; set; }
 
         /// <summary>
         /// Used internally during model mapping
@@ -43,4 +38,4 @@ namespace Umbraco.Web.Models.ContentEditing
         internal PropertyEditor PropertyEditor { get; set; }
 
     }
-}
+}

src/Umbraco.Web/Models/Mapping/MemberModelMapper.cs

@@ -80,21 +80,17 @@ namespace Umbraco.Web.Models.Mapping
 
             //FROM IMember TO MemberBasic
             config.CreateMap<IMember, MemberBasic>()
-                .ForMember(display => display.Udi,
-                    expression =>
-                        expression.MapFrom(content => Udi.Create(Constants.UdiEntityType.Member, content.Key)))
+                .ForMember(display => display.Udi, expression => expression.MapFrom(content => Udi.Create(Constants.UdiEntityType.Member, content.Key)))
                 .ForMember(dto => dto.Owner, expression => expression.ResolveUsing(new OwnerResolver<IMember>()))
                 .ForMember(dto => dto.Icon, expression => expression.MapFrom(content => content.ContentType.Icon))
-                .ForMember(dto => dto.ContentTypeAlias,
-                    expression => expression.MapFrom(content => content.ContentType.Alias))
+                .ForMember(dto => dto.ContentTypeAlias, expression => expression.MapFrom(content => content.ContentType.Alias))
                 .ForMember(dto => dto.Email, expression => expression.MapFrom(content => content.Email))
                 .ForMember(dto => dto.Username, expression => expression.MapFrom(content => content.Username))
                 .ForMember(dto => dto.Trashed, expression => expression.Ignore())
                 .ForMember(dto => dto.Published, expression => expression.Ignore())
                 .ForMember(dto => dto.Updater, expression => expression.Ignore())
                 .ForMember(dto => dto.Alias, expression => expression.Ignore())
-                .ForMember(dto => dto.HasPublishedVersion, expression => expression.Ignore())
-                .ForMember(dto => dto.Properties, expression => expression.ResolveUsing(new MemberBasicPropertiesResolver()));
+                .ForMember(dto => dto.HasPublishedVersion, expression => expression.Ignore());
 
             //FROM MembershipUser TO MemberBasic
             config.CreateMap<MembershipUser, MemberBasic>()
@@ -399,8 +395,6 @@ namespace Umbraco.Web.Models.Mapping
                     //check permissions for viewing sensitive data
                     if (isSensitiveProperty && umbracoContext.Security.CurrentUser.HasAccessToSensitiveData() == false)
                     {
-                        //mark this property as sensitive
-                        prop.IsSensitive = true;
                         //mark this property as readonly so that it does not post any data
                         prop.Readonly = true;
                         //replace this editor with a sensitivevalue
@@ -483,51 +477,8 @@ namespace Umbraco.Web.Models.Mapping
                 return AutoMapperExtensions.MapWithUmbracoContext<IMember, MemberDisplay>(member, context.GetUmbracoContext());
             }
         }
-
-        /// <summary>
-        /// A resolver to map <see cref="IMember"/> properties to a collection of <see cref="ContentPropertyBasic"/>
-        /// </summary>
-        internal class MemberBasicPropertiesResolver : IValueResolver
-        {
-            public ResolutionResult Resolve(ResolutionResult source)
-            {
-                if (source.Value != null && (source.Value is IMember) == false)
-                    throw new AutoMapperMappingException(string.Format("Value supplied is of type {0} but expected {1}.\nChange the value resolver source type, or redirect the source value supplied to the value resolver using FromMember.", new object[]
-                    {
-                    source.Value.GetType(),
-                    typeof (IMember)
-                    }));
-                return source.New(
-                    //perform the mapping with the current umbraco context
-                    ResolveCore(source.Context.GetUmbracoContext(), (IMember)source.Value), typeof(IEnumerable<ContentPropertyDisplay>));
-            }
-
-            private IEnumerable<ContentPropertyBasic> ResolveCore(UmbracoContext umbracoContext, IMember content)
-            {
-                var result = Mapper.Map<IEnumerable<Property>, IEnumerable<ContentPropertyBasic>>(
-                    // Sort properties so items from different compositions appear in correct order (see U4-9298). Map sorted properties.
-                    content.Properties.OrderBy(prop => prop.PropertyType.SortOrder))
-                .ToList();
-
-                var member = (IMember)content;
-                var memberType = member.ContentType;
-
-                //now update the IsSensitive value
-                foreach (var prop in result)
-                {
-                    //check if this property is flagged as sensitive
-                    var isSensitiveProperty = memberType.IsSensitiveProperty(prop.Alias);
-                    //check permissions for viewing sensitive data
-                    if (isSensitiveProperty && umbracoContext.Security.CurrentUser.HasAccessToSensitiveData() == false)
-                    {
-                        //mark this property as sensitive
-                        prop.IsSensitive = true;
-                        //clear the value
-                        prop.Value = null;
-                    }
-                }
-                return result;
-            }
-        }
     }
 }
+
+
+

src/Umbraco.Web/Models/Mapping/TabsAndPropertiesResolver.cs

@@ -1,5 +1,7 @@
 using System;
 using System.Collections.Generic;
+using System.ComponentModel.DataAnnotations;
+using System.Globalization;
 using System.Linq;
 using AutoMapper;
 using Umbraco.Core;
@@ -7,6 +9,7 @@ using Umbraco.Core.Models;
 using Umbraco.Core.PropertyEditors;
 using Umbraco.Core.Services;
 using Umbraco.Web.Models.ContentEditing;
+using umbraco;
 
 namespace Umbraco.Web.Models.Mapping
 {
@@ -50,7 +53,7 @@ namespace Umbraco.Web.Models.Mapping
                 //perform the mapping with the current umbraco context
                 ResolveCore(source.Context.GetUmbracoContext(), (TSource)source.Value), typeof(List<Tab<ContentPropertyDisplay>>));
         }
-
+        
         /// <summary>
         /// Adds the container (listview) tab to the document
         /// </summary>
@@ -272,7 +275,7 @@ namespace Umbraco.Web.Models.Mapping
 
             //now add the user props
             contentProps.AddRange(currProps);
-
+            
             //re-assign
             genericProps.Properties = contentProps;
 
@@ -305,6 +308,6 @@ namespace Umbraco.Web.Models.Mapping
 
             return result;
         }
-
+        
     }
 }

src/Umbraco.Web/UI/JavaScript/JsInitialize.js

@@ -3,7 +3,7 @@
     'lib/angular/1.1.5/angular.min.js',
     'lib/underscore/underscore-min.js',
 
-    'lib/moment/moment-with-locales.js',
+    'lib/moment/moment.min.js',
 
     'lib/jquery-ui/jquery-ui.min.js',
     'lib/jquery-ui-touch-punch/jquery.ui.touch-punch.js',

src/Umbraco.Web/Umbraco.Web.csproj

@@ -316,6 +316,7 @@
     <Compile Include="Cache\TemplateCacheRefresher.cs" />
     <Compile Include="Cache\UnpublishedPageCacheRefresher.cs" />
     <Compile Include="Cache\UserCacheRefresher.cs" />
+    <Compile Include="Editors\BackOfficeAssetsController .cs" />
     <Compile Include="Features\DisabledFeatures.cs" />
     <Compile Include="Editors\BackOfficeNotificationsController.cs" />
     <Compile Include="Editors\BackOfficeServerVariables.cs" />

src/Umbraco.Web/umbraco.presentation/umbraco/create/MemberGroupTasks.cs

@@ -1,9 +1,12 @@
-using System.Linq;
+using System;
+using System.Data;
 using System.Web.Security;
-using umbraco.BusinessLogic;
-using umbraco.cms.businesslogic.member;
-using Umbraco.Web;
 using Umbraco.Web.UI;
+using umbraco.BusinessLogic;
+using umbraco.DataLayer;
+using umbraco.BasePages;
+using Umbraco.Core.IO;
+using umbraco.cms.businesslogic.member;
 
 namespace umbraco
 {
@@ -12,43 +15,31 @@ namespace umbraco
         public override bool PerformSave()
         {
             Roles.CreateRole(Alias);
-            _returnUrl = $"members/EditMemberGroup.aspx?id={System.Web.HttpContext.Current.Server.UrlEncode(Alias)}";
+            _returnUrl = string.Format("members/EditMemberGroup.aspx?id={0}", System.Web.HttpContext.Current.Server.UrlEncode(Alias));
             return true;
         }
 
         public override bool PerformDelete()
         {
-            var roleDeleted = false;
-
             // only built-in roles can be deleted
             if (Member.IsUsingUmbracoRoles())
             {
-                roleDeleted = Roles.DeleteRole(Alias);
+                MemberGroup.GetByName(Alias).delete();
+                return true;
             }
-
-            // Need to delete the member group from any content item that has it assigned in public access settings
-            var publicAccessService = UmbracoContext.Current.Application.Services.PublicAccessService;
-            var allPublicAccessRules = publicAccessService.GetAll();
-
-            // Find only rules which have the current role name (alias) assigned to them
-            var rulesWithDeletedRoles = allPublicAccessRules.Where(x => x.Rules.Any(r => r.RuleValue == Alias));
-
-            var contentService = UmbracoContext.Current.Application.Services.ContentService;
-            foreach (var publicAccessEntry in rulesWithDeletedRoles)
-            {
-                var contentItem = contentService.GetById(publicAccessEntry.ProtectedNodeId);
-                var rulesToDelete = publicAccessEntry.Rules.ToList();
-                foreach (var rule in rulesToDelete)
-                    publicAccessService.RemoveRule(contentItem, rule.RuleType, rule.RuleValue);
-            }
-
-            return roleDeleted;
+            return false;            
         }
 
         private string _returnUrl = "";
 
-        public override string ReturnUrl => _returnUrl;
+        public override string ReturnUrl
+        {
+            get { return _returnUrl; }
+        }
 
-        public override string AssignedApp => DefaultApps.member.ToString();
+        public override string AssignedApp
+        {
+            get { return DefaultApps.member.ToString(); }
+        }
     }
 }