Forem: Andy Boot

Umbraco 13 - Setting The Backoffice Login Background & Logo From Content Data

Andy Boot — Wed, 15 May 2024 16:16:47 +0000

The release of Umbraco 13 back in December 2023 brought with it a whole new look and refreshed login screen based on the same technology as "Bellissima" (the upcoming Umbraco 14 backoffice revamp).

Out of the box, it looks like this:

Introduction

Umbraco offers a way to customise the logo and image by setting alternative values against the Umbraco:CMS:Content:LoginBackgroundImage and Umbraco:CMS:Content:LoginLogoImage properties within appsettings.json:

Check out Warren Buckley's blog post here for a further breakdown of how this works: https://blog.hackmakedo.com/2023/11/20/quick-tip-how-to-customise-your-umbraco-13-login-screen/

After watching a recent video uploaded by Paul Seal, it inspired me to expand on the idea he presented. Paul demo's how to achieve a similar desired effect by providing an element of customisability from the Umbraco backoffice by utilising the Umbraco package Skybrud Redirects. Check it out here:

My approach

Using a similar methodology to Paul's approach, I'm going to show you how to do a code only implementation, without the need for an additional package dependency.

Before I begin, I structure my content tree so that the root page holds all the global settings for the website. Some developers prefer to have a separate settings document type held as a child node (which is also perfectly acceptable). If this is you, you'll need to adapt parts of the code below around your setup.

First, we're going to create two new properties against the root document type:

Name: Umbraco Custom Login Background Image
Alias: umbracoCustomLoginBackground
Description: Suggested image size: 936x1404 pixels (JPG)
Data type: Media Picker

Name: Umbraco Custom Login Logo Image
Alias: umbracoCustomLoginLogo
Description: Suggested image size: 300x82 pixels (SVG or PNG)
Data type: Media Picker

Like so:

Next, we're going to populate our new fields with some appropriate images from the media library:

Now we just need to wire this up with a small piece of middleware:



public class UmbracoLoginImageMiddleware
{
    private readonly RequestDelegate _next;
    private readonly IRuntimeState _runtimeState;
    private readonly IUmbracoContextFactory _umbracoContextFactory;

    private const string DEFAULT_UMBRACO_LOGIN_BACKGROUND_IMAGE = "/umbraco/assets/img/login.jpg";
    private const string DEFAULT_UMBRACO_LOGIN_LOGO_IMAGE = "/umbraco/assets/img/application/umbraco_logo_blue.svg";

    private const string LOGIN_BACKGROUND_IMAGE_PROPERTY_ALIAS = "umbracoCustomLoginBackground";
    private const string LOGIN_LOGO_IMAGE_PROPERTY_ALIAS = "umbracoCustomLoginLogo";

    public UmbracoLoginImageMiddleware(RequestDelegate next,
        IRuntimeState runtimeState,
        IUmbracoContextFactory umbracoContextFactory)
    {
        _next = next;
        _runtimeState = runtimeState;
        _umbracoContextFactory = umbracoContextFactory;
    }

    public async Task Invoke(HttpContext context)
    {
        if (_runtimeState.Level != RuntimeLevel.Run)
        {
            await _next.Invoke(context);
            return;
        }

        var pathAndQuery = context.Request.GetEncodedPathAndQuery();

        if (pathAndQuery.InvariantIndexOf(DEFAULT_UMBRACO_LOGIN_BACKGROUND_IMAGE) != 0 && pathAndQuery.InvariantIndexOf(DEFAULT_UMBRACO_LOGIN_LOGO_IMAGE) != 0)
        {
            await _next(context);
            return;
        }

        // Handle the background or logo image
        if (!HandleLoginImageRedirect(context, DEFAULT_UMBRACO_LOGIN_BACKGROUND_IMAGE, LOGIN_BACKGROUND_IMAGE_PROPERTY_ALIAS) && 
            !HandleLoginImageRedirect(context, DEFAULT_UMBRACO_LOGIN_LOGO_IMAGE, LOGIN_LOGO_IMAGE_PROPERTY_ALIAS))
        {
            await _next(context);
        }
    }

    private bool HandleLoginImageRedirect(HttpContext context, string defaultImage, string propertyAlias)
    {
        // If the current request URL equals the default path or what we have in appsettings.json
        if (context.Request.Path.Value?.InvariantEquals(defaultImage) == true)
        {
            using var ctx = _umbracoContextFactory.EnsureUmbracoContext();

            var contentAtRoot = ctx.UmbracoContext.Content?.GetAtRoot(); // Get all document nodes at the root level of our content
            var firstRootContent = contentAtRoot?.FirstOrDefault(); // Get the first one (adjust this if you want to pull through something specific)

            if (firstRootContent != null && firstRootContent.HasValue(propertyAlias)) // If our sites root page has a matching property with a value
            {
                var mediaItemUrl = firstRootContent.Value<IPublishedContent>(propertyAlias)?.Url(); // Get & parse the media library item to get the direct URL

                if (!string.IsNullOrWhiteSpace(mediaItemUrl))
                {
                    context.Response.Redirect(mediaItemUrl, true); // Redirect to the media set in the backoffice
                    return true;
                }
            }
        }

        return false;
    }
}

Finally, we just need to register it from within a composer:



public class MyComposer : IComposer
{
    public void Compose(IUmbracoBuilder builder)
    {
        builder.Services.Configure<UmbracoPipelineOptions>(options =>
        {
            options.AddFilter(new UmbracoPipelineFilter(
                "UmbracoLoginImageMiddleware",
                applicationBuilder =>
                {
                    applicationBuilder.UseMiddleware<UmbracoLoginImageMiddleware>();
                },
                applicationBuilder =>
                {
                },
                applicationBuilder => { }
            ));
        });
    }
}

Drumroll...

Summary

The middleware finds the first root page and attempts to get values from the two newly created media picker properties. If the either of the two image HTTP request matches either of the default image URL's and the adjacent property has a value then it'll perform a permanent 301 redirect to your media library image instead.

While we redirect the background image from /umbraco/assets/img/login.jpg, it's probably a safe bet that this wouldn't harm any other component or page within the backoffice. However, overriding /umbraco/assets/img/application/umbraco_logo_blue.svg gives me a little more concern as it may be used elsewhere. On initial inspection I can't see anywhere specific where this is also defined so we may be able to get away with it. If however it does reveal itself to be used for other things we can workaround this by re-saving the SVG to somewhere within your wwwroot folder, setting the Umbraco:CMS:Content:LoginLogoImage value and updating the DEFAULT_UMBRACO_LOGIN_LOGO_IMAGE const within the middleware.

Please be aware that frequent changing of redirects against a URL may result in the redirect being cached and therefore you won't always see your changes immediately. To overcome this, disable browser caching.

I hope you find this article interesting. I wanted to share this approach with you because I hadn't seen it done yet.

Thanks for reading,
Andy
👋

Deep Dive Into Umbraco String Extension Methods

Andy Boot — Sat, 08 Apr 2023 08:21:54 +0000

‟Let's talk about ex-tension methods, baby!”

Extension methods are a powerful feature of C# that allows developers to add new methods to existing types without the need for inheritance, modification or recompilation of the original class. Fortunately, the .Net family of frameworks provides numerous built-in extension methods, but with Umbraco you get an additional set of methods that can help you keep your code concise, readable, and aligned with the DRY principle.

By chance, I stumbled upon this collection of extensions a while back when intellisense suggested IsNullOrWhiteSpace() and StripHtml() to me. Knowing that these were not part of the vanilla .Net, I hit F12 (go to definition) and discovered a treasure trove of other extension methods. In this article, we will explore the plethora of string extension methods that Umbraco CMS offers and how to utilise them.

Please note that the information below pertains to Umbraco version 11.0, although some features may also be relevant to older and newer versions. These methods are found in the StringExtensions class within the Umbraco.Extensions namespace.

Table of contents
⭐ = My Favourite

GetIdsFromPathReversed() - Returns the IDs of the items in a path in reverse order.
StripWhitespace() - Removes whitespace characters from the beginning and end of a string.
StripFileExtension() - Removes the file extension from a file path.
GetFileExtension() - Returns the file extension of a file path.
DetectIsJson() - Determines if a string is a valid JSON object.
DetectIsEmptyJson() - Determines if a string is an empty JSON object.
⭐ReplaceNonAlphanumericChars() - Replaces all non-alphanumeric characters in a string with a specified replacement.
CleanForXss() - Sanitizes a string to remove potential cross-site scripting (XSS) vulnerabilities.
ExceptChars() - Returns a string with all instances of specified characters removed.
GenerateStreamFromString() - Creates a stream from a string.
⭐AppendQueryStringToUrl() - Appends a query string to a URL.
MakePluralName() - Returns the plural form of a noun.
IsVowel() - Determines if a character is a vowel.
Trim() - Removes whitespace characters from the beginning and end of a string.
EncodeJsString() - Encodes a string to be used in a JavaScript string literal.
EnsureStartsWith() - Ensures that a string starts with a specified prefix.
EnsureEndsWith() - Ensures that a string ends with a specified suffix.
IsLowerCase() - Determines if a string is all lowercase.
IsUpperCase() - Determines if a string is all uppercase.
⭐IsNullOrWhiteSpace() - Determines if a string is null or consists only of whitespace characters.
IfNullOrWhiteSpace() - Returns a default value if a string is null or consists only of whitespace characters.
⭐ToDelimitedList() - Converts a list of strings to a delimited string.
EnumTryParse() - Provides a safer way to parse a string value to a specified enum type.
EnumParse() - Provides an easy way to parse a string value to a specified enum type.
⭐StripHtml() - Removes HTML tags from a string.
EncodeAsGuid() - Encodes a GUID as a string.
ConvertToHex() - Converts a byte array to a hexadecimal string.
DecodeFromHex() - Converts a hexadecimal string to a byte array.
ToUrlBase64() - Converts a byte array to a URL-safe base64-encoded string.
FromUrlBase64() - Decodes a URL-safe Base64 string into its original string representation.
InvariantFormat() - Formats a string with invariant culture.
ToInvariantString() - Converts an integer or long value to its invariant string representation.
⭐InvariantEquals() - Compares two strings in a case-insensitive manner and with invariant culture.
⭐InvariantStartsWith() - Checks if a string starts with a specific substring in a case-insensitive manner using the InvariantCultureIgnoreCase option.
InvariantEndsWith() - Checks if a string ends with a specific substring in a case-insensitive manner using the InvariantCultureIgnoreCase option.
⭐InvariantContains() - Checks if a string or IEnumerable of strings contains a specific substring in a case-insensitive manner.
⭐InvariantIndexOf() - Finds the index of the first occurrence of a specific substring in a string in a case-insensitive manner using the OrdinalIgnoreCase option.
InvariantLastIndexOf() - Finds the index of the last occurrence of a specific substring in a string in a case-insensitive manner using the OrdinalIgnoreCase option.
ParseInto() - Attempts to parse a string into the supplied type by finding and using the Type's "Parse" method.
GenerateHash() - Generates a hash of a string using a specified hash algorithm.
ToSHA1() - Converts a string to its SHA1 hash value.
UrlTokenDecode() - Decodes a string that was encoded with UrlTokenEncode.
UrlTokenEncode() - Encodes a byte array for use in URLs, files, or other places where a string is required.
NormaliseDirectoryPath() - Ensures a given directory path ends with a directory separator character.
⭐Truncate() - Truncates a given string to a specified length and appends a suffix at the end of it.
StripNewLines() - Removes carriage returns and line feeds from a given string.
ToSingleLine() - Converts a multiline string to a single line by replacing line breaks with spaces.
OrIfNullOrWhiteSpace() - Returns the input string if it is not null or whitespace, otherwise, it returns the alternative string.
ToFirstUpper() - Converts the first character of a string to uppercase.
ToFirstLower() - Converts the first character of a string to lowercase.
ToFirstUpperInvariant() / ToFirstLowerInvariant() - Similar to ToFirstUpper() and ToFirstLower(), respectively, but they use the casing rules of the invariant culture.
ReplaceMany() - Replaces multiple occurrences of a set of characters or strings in a given string with a specified replacement character or string.
ReplaceFirst() - A method that returns a new string in which only the first occurrence of a specified string is replaced by a specified replacement string.
Replace() - A method that returns a new string in which all occurrences of a specified string in the current instance are replaced with another specified string.
ToCSharpString() - A method that converts a literal string into a C# expression.
EscapeRegexSpecialCharacters() - A method that escapes all the special characters used in a regular expression.
ContainsAny() - A method that returns a boolean if any of the strings in the list of strings exists within the source string.
CsvContains() - Checks if a comma-separated string (CSV) contains a given value.
⭐ToFriendlyName() - Converts a file name to a user-friendly name for a content item.
ToValidXmlString() - Replaces all invalid Unicode characters in a string for XML files.
ToGuid() - Converts a string to a GUID (Globally Unique Identifier).
NullOrWhiteSpaceAsNull() - Turns a null-or-whitespace string into a null string.
IsFullPath() - Checks whether a given path is a full path including drive letter.
⭐ToSafeAlias() - Cleans a string to produce a string that can be safely used in an alias.
ToUrlSegment() - Cleans a string to produce a string that can safely be used in an URL segment.
⭐ToCleanString() - Cleans a string by removing any unwanted characters and formatting it according to the provided options.
SplitPascalCasing() - Splits a Pascal-cased string into a phrase separated by spaces.
ToSafeFileName() - Cleans a string to produce a safe filename for use internally (on disk) or externally (as a URL).
EscapedSplit() - Splits a string with an escape character that allows for the split character to exist within the string.

GetIdsFromPathReversed()

Parameters: this string path

The GetIdsFromPathReversed() extension method takes a string path and returns an array of integers that represent node ids in reverse order, from deepest to shallowest.

Example:

string path = "1,2,3";
int[] nodeIds = path.GetIdsFromPathReversed();
// nodeIds: [3, 2, 1]

StripWhitespace()

Parameters: this string txt

The StripWhitespace() extension method removes all new line and tab characters from a string. This method uses the Regex.Replace() method to replace any whitespace characters with an empty string.

Example:

string text = "Some text \n with \t whitespace";
string stripped = text.StripWhitespace();
// stripped: "Sometextwithwhitespace"

StripFileExtension()

Parameters: this string fileName

The StripFileExtension() extension method removes the file extension from a filename. This method checks if the filename contains any new line characters, and returns the original filename if it does. If the filename contains a file extension, it removes it using the Substring() method and returns the result.

Example:

string filename = "example.txt";
string stripped = filename.StripFileExtension();
// stripped: "example"

GetFileExtension()

Parameters: this string file

The GetFileExtension() extension method returns the file extension of a path or URL. This method uses a regular expression to match the last occurrence of a dot character before the start of a query string or the end of the string.

Example:

string path = "example.txt";
string extension = path.GetFileExtension();
// extension: ".txt"

DetectIsJson()

Parameters: this string input

The DetectIsJson() extension method checks if a string is a valid JSON string. This method trims the input string and checks if it starts with { and ends with } or starts with [ and ends with ].

Example:

string json = "{\"name\":\"John\"}";
bool isJson = json.DetectIsJson();
// isJson: true

DetectIsEmptyJson()

Parameters: this string input

The DetectIsEmptyJson() extension method checks if a string is an empty JSON array or object. This method replaces all whitespace characters with an empty string using a regular expression, and then checks if the resulting string is equal to [] or {}.

Example:

string json = "   {}   ";
bool isEmptyJson = json.DetectIsEmptyJson();
// isEmptyJson: true

ReplaceNonAlphanumericChars()

Parameters: this string input, char replacement

The ReplaceNonAlphanumericChars() extension method replaces any non-alphanumeric characters in a string with a specified replacement string or character.

Example:

var input = "This is a string with some non-alphanumeric characters: $100, @username";
var replacedString = input.ReplaceNonAlphanumericChars("-");
// replacedString: "This-is-a-string-with-some-non-alphanumeric-characters--100---username"

var replacedChar = input.ReplaceNonAlphanumericChars('_');
// replacedChar: "This_is_a_string_with_some_non_alphanumeric_characters__100___username"

CleanForXss()

Parameters: this string input, params char[] ignoreFromClean

The CleanForXss() extension method helps prevent cross-site scripting (XSS) attacks by stripping out potentially harmful characters from a string. It uses the StripHtml method to remove any HTML tags from the string, then removes any characters listed in a predefined list (CleanForXssChars). You can optionally specify additional characters to ignore by passing them as arguments to the method.

Example:

string userInput = "<script>alert('XSS!');</script>";
string sanitizedInput = userInput.CleanForXss();

// sanitizedInput: "alert('XSS!');"

ExceptChars()

Parameters: this string str, HashSet<char> toExclude

The ExceptChars() extension method removes all characters in a string that match a set of specified characters. It takes a HashSet as input, which contains the characters to exclude.

Example:

string input = "Hello, world!";
HashSet<char> excludedChars = new HashSet<char>(new[] { 'o', 'l' });
string output = input.ExceptChars(excludedChars);

// output: "He, wrd!"

GenerateStreamFromString()

Parameters: this string s

The GenerateStreamFromString() extension method converts a string into a stream object, which can be useful when working with streams in .NET.

Example:

string input = "Hello, world!";
Stream stream = input.GenerateStreamFromString();
byte[] buffer = new byte[stream.Length];
stream.Read(buffer, 0, buffer.Length);
var output = Encoding.UTF8.GetString(buffer);

// output: "Hello, world!"

AppendQueryStringToUrl()

Parameters: this string url, params string[] queryStrings

The AppendQueryStringToUrl() extension method appends a set of query string parameters to a URL. It ensures that the resulting URL is structured correctly, with only one '?' character and proper delimiters between parameters.

Example:

string url = "https://example.com";
string queryString = "foo=bar&baz=qux";
string result = url.AppendQueryStringToUrl(queryString);

// result: "https://example.com?foo=bar&baz=qux"

MakePluralName()

Parameters: this string name

The MakePluralName() extension method pluralizes a singular noun. It's a fun little extension method that uses a set of simple rules to convert a word into its plural form.

Example:

string singular = "apple";
string plural = singular.MakePluralName();

// plural: "apples"

IsVowel()

Parameters: this char c

The IsVowel() extension method checks whether a character is a vowel.

Example:

char c = 'a';
bool isVowel = c.IsVowel();

// isVowel: true

Trim()

Parameters: this string value, string forRemoving

The Trim() extension method trims a string using another string as the trim value. It works similarly to the built-in Trim method, but allows you to specify a string rather than a single character.

Example:

string input = "Hello, world!";
string trimValue = "Hdlr!";
string output = input.Trim(trimValue);

// output: ", wor"

EncodeJsString()

Parameters: this string s

The EncodeJsString() extension method encodes a string for use in JavaScript code. It replaces certain special characters with their escape codes.

Example:

string input = "Hello, \"world\"!";
string output = input.EncodeJsString();

// output: "Hello, \\\"world\\\"!"

EnsureStartsWith()

Parameters: this string input, string toStartWith, this string input, char value

The EnsureStartsWith() extension method ensures that a string starts with a specified character or string. If the input string already starts with the specified character or string, the original string is returned. If not, the specified character or string is prepended to the input string.

Example:

string input = "world!";
string output = input.EnsureStartsWith("Hello, ");

// output: "Hello, world!"

EnsureEndsWith()

Parameters: this string input, string toEndWith, this string input, char value

The EnsureEndsWith() extension method ensures that a string ends with a specified character or string. If the input string already ends with the specified character or string, the original string is returned. If not, the specified character or string is appended to the input string.

Example:

string input = "Hello,";
string output = input.EnsureEndsWith(" world!");

// output: "Hello, world!"

IsLowerCase()

Parameters: this char ch

The IsLowerCase() extension method checks whether a character is a lowercase letter or not.

Example:

char ch = 'a';
bool isLower = ch.IsLowerCase(); 
// isLower: True

char ch2 = 'A';
bool isNotLower = ch2.IsLowerCase(); 
// isNotLower: False

IsUpperCase()

Parameters: this char ch

The IsUpperCase() extension method checks whether a character is an uppercase letter or not.

Example:

char ch = 'A';
bool isUpper = ch.IsUpperCase(); 
// isUpper: True

char ch2 = 'a';
bool isNotUpper = ch2.IsUpperCase(); 
// isNotUpper: False

IsNullOrWhiteSpace()

Parameters: this string? value

The IsNullOrWhiteSpace() extension method checks whether a string is null, empty, or consists only of white-space characters.

Example:

string input = "   ";
bool isNullOrWhiteSpace = input.IsNullOrWhiteSpace(); 
// isNullOrWhiteSpace: True

string input2 = " Hello ";
bool isNotNullOrWhiteSpace = input2.IsNullOrWhiteSpace(); 
// isNotNullOrWhiteSpace: False

IfNullOrWhiteSpace()

Parameters: this string? str, string? defaultValue

The IfNullOrWhiteSpace() extension method checks whether a string is null, empty, or consists only of white-space characters. If it is, it returns the default value provided; otherwise, it returns the input string.

Example:

string input = null;
string output = input.IfNullOrWhiteSpace("Hello, world!");

// output: "Hello, world!"

ToDelimitedList()

Parameters: this string list, string delimiter = ","

The ToDelimitedList() extension method converts a string containing a delimited list of items into an IList. By default, the delimiter is a comma (","), but a different delimiter can be specified.

Example:

string input = "one, two, three";
IList<string> output = input.ToDelimitedList();

// output: [ "one", "two", "three" ]

EnumTryParse()

Parameters: this string strType, bool ignoreCase, out T? result

The EnumTryParse() extension method provides a safer way to parse a string value to a specified enum type. This method takes three parameters: the first parameter strType is the string value that needs to be converted to the specified enum type, the second parameter ignoreCase is a bool value that specifies whether the conversion should be case-insensitive, and the third parameter result is an out parameter that holds the converted value.

Example:

string strValue = "Red";
bool success = strValue.EnumTryParse<Color>(true, out Color color); // Case-insensitive conversion

In the example above, we are converting a string value "Red" to a Color enum value. The second parameter true specifies that the conversion should be case-insensitive. If the conversion is not possible, this method will set the result parameter to null and return false. Otherwise, it will set the result parameter to the converted value and return true.

EnumParse()

Parameters: this string strType, bool ignoreCase

The EnumParse<T>() extension method provides an easy way to parse a string value to a specified enum type. This method takes two parameters: the first parameter strType is the string value that needs to be converted to the specified enum type, and the second parameter ignoreCase is a bool value that specifies whether the conversion should be case-insensitive.

Example:

string strValue = "Red";
Color color = strValue.EnumParse<Color>(true); // Case-insensitive conversion

StripHtml()

Parameters: this string text

The StripHtml() extension method removes all HTML tags from a string. It is helpful when a user's input is in HTML format and needs to be displayed without HTML tags.

Example:

string input = "<p>Hello <b>world!</b></p>";
string output = input.StripHtml();

// output: "Hello world!"

EncodeAsGuid()

Parameters: this string input

The EncodeAsGuid() extension method encodes a string as a GUID. This method takes a string input, converts it into a hexadecimal format, and then returns a GUID based on the resulting hexadecimal string. This can be useful for scenarios like generating unique IDs.

Example:

string input = "Hello, world!";
Guid output = input.EncodeAsGuid();

// output: f2f8bf54-c72c-4db4-b35f-e21cb9cc4a4a

ConvertToHex()

Parameters: this string input

The ConvertToHex() extension method converts a string into its hexadecimal representation. Each character in the input string is converted to a two-digit hexadecimal value.

Example:

string input = "Hello, world!";
string output = input.ConvertToHex();

// output: 48656c6c6f2c20776f726c6421

DecodeFromHex()

Parameters: this string hexValue

The DecodeFromHex() extension method converts a hexadecimal string into its original string representation.

Example:

string input = "48656c6c6f2c20776f726c6421";
string output = input.DecodeFromHex();

// output: "Hello, world!"

ToUrlBase64()

Parameters: this string input

The ToUrlBase64() extension method encodes a string as a URL-safe Base64 string. This method replaces special characters in the output string with URL-safe equivalents.

Example:

string input = "Hello, world!";
string output = input.ToUrlBase64();

// output: "SGVsbG8sIHdvcmxkIQ=="

FromUrlBase64()

Parameters: this string input

The FromUrlBase64() extension method decodes a URL-safe Base64 string into its original string representation.

Example:

string input = "SGVsbG8sIHdvcmxkIQ==";
string output = input.FromUrlBase64();

// output: "Hello, world!"

InvariantFormat()

Parameters: this string? format, params object?[] args

The InvariantFormat() extension method formats a string with invariant culture. It is useful when formatting strings that need to be displayed across different cultures.

Example:

string output = "{0} is {1} years old.".InvariantFormat("John", 30);

// output: "John is 30 years old."

ToInvariantString()

Parameters: this int str, this long str

The ToInvariantString() extension method converts an integer or long value to its invariant string representation.

Example:

int input = 42;
string output = input.ToInvariantString();

// output: "42"

InvariantEquals()

Parameters: this string? compare, string? compareTo

The InvariantEquals() extension method compares two strings in a case-insensitive manner and with invariant culture.

Example:

string input1 = "Hello, world!";
string input2 = "hello, World!";
bool output = input1.InvariantEquals(input2);

// output: true

InvariantStartsWith()

Parameters: this string compare, string compareTo

The InvariantStartsWith() extension method is used to check if a string starts with a specific substring. This method performs a case-insensitive comparison using the InvariantCultureIgnoreCase option.

Example:

string input = "Hello World";
bool result = input.InvariantStartsWith("Hello");
// result: true

InvariantEndsWith()

Parameters: this string compare, string compareTo

The InvariantEndsWith() extension method is used to check if a string ends with a specific substring. This method performs a case-insensitive comparison using the InvariantCultureIgnoreCase option.

Example:

string input = "Hello World";
bool result = input.InvariantEndsWith("world");
// result: true

InvariantContains()

Parameters: this string compare, string compareTo, this IEnumerable<string> compare, string compareTo

The InvariantContains() extension methods are used to check if a string or IEnumerable of strings contains a specific substring. This method performs a case-insensitive comparison.

Example:

string input = "Hello World";
bool result1 = input.InvariantContains("world");
// result1: true

string[] words = { "hello", "world", "dotnet" };
bool result2 = words.InvariantContains("DoTnEt");
// result2: true

InvariantIndexOf()

Parameters: this string s, string value

The InvariantIndexOf() extension method is used to find the index of the first occurrence of a specific substring in a string. This method performs a case-insensitive comparison using the OrdinalIgnoreCase option.

Example:

string input = "Hello World";
int index = input.InvariantIndexOf("world");
// index: 6

InvariantLastIndexOf()

Parameters: this string s, string value

The InvariantLastIndexOf() extension method is used to find the index of the last occurrence of a specific substring in a string. This method performs a case-insensitive comparison using the OrdinalIgnoreCase option.

Example:

string input = "Hello World, hello world!";
int index = input.InvariantLastIndexOf("world");
// index: 18

ParseInto()

Parameters: this string val, Type type

The ParseInto() extension method attempts to parse a string into the supplied type by finding and using the Type's "Parse" method. It can be used to convert a string representation of a value to an instance of that value's type. There are two overloads of this method: one that returns the parsed value directly and another that returns an object that can be cast to the target type.

Example:

string str = "123";
int i = (int)str.ParseInto(typeof(int));
// i: 123

The method also accepts a type parameter which I favour over the two.

ParseInto<T>(this string val)

Example:

string str = "123";
int i = str.ParseInto<int>();
// i: 123

GenerateHash()

Parameters: this string str

The GenerateHash() extension method is used to generate a hash of a string using a specified hash algorithm. There are two overloads of this method: one that uses the FIPS compliance setting and another that takes a generic type parameter specifying the hash algorithm to use. The default hash algorithm used by the ToSHA1 method is SHA1.

Example:

string str = "Hello World!";
string md5Hash = str.GenerateHash<MD5>();
// md5Hash: "5eb63bbbe01eeed093cb22bb8f5acdc3"

ToSHA1()

Parameters: this string stringToConvert

The ToSHA1() extension method is a shorthand for GenerateHash("SHA1"). It is used to convert a string to its SHA1 hash value.

Example:

string str = "Hello World!";
string sha1Hash = str.ToSHA1();
// sha1Hash: "0a4d55a8d778e5022fab701977c5d840bbc486d0"

UrlTokenDecode()

Parameters: this string input

The UrlTokenDecode() extension method decodes a string that was encoded with UrlTokenEncode. It is used to convert a string that has been encoded using the UrlTokenEncode method back to its original byte array representation.

Example:

string str = "SGVsbG8sIHdvcmxkIQ==";
byte[] decodedBytes = str.UrlTokenDecode(); 
// decodedBytes: [72, 101, 108, 108, 111, 44, 32, 119, 111, 114, 108, 100, 33]

UrlTokenEncode()

Parameters: this byte[] input

The UrlTokenEncode() extension method encodes a byte array for use in URLs, files, or other places where a string is required. It converts the input byte array to a Base64 string and replaces characters that could cause problems in URLs.

Example:

string input = "Hello, world!";
byte[] bytes = Encoding.UTF8.GetBytes(input);
string output = bytes.UrlTokenEncode();

// output: "SGVsbG8sIHdvcmxkIQ=="

NormaliseDirectoryPath()

Parameters: this string currentFolder

The NormaliseDirectoryPath() extension method ensures that a given directory path ends with a directory separator character. It is useful when dealing with directory paths in different platforms, as Windows uses \ and Unix uses /.

Example:

string input = @"C:\Program Files\MyApp";
string output = input.NormaliseDirectoryPath();

// output: "C:\\Program Files\\MyApp\\"

Truncate()

Parameters: this string text, int maxLength, string suffix = "..."

The Truncate() extension method truncates a given string to a specified length and appends a suffix at the end of it. It is useful when displaying a long text on a user interface and we want to limit its length.

Example:

string input = "Lorem ipsum dolor sit amet, consectetur adipiscing elit. Praesent convallis dolor vel augue imperdiet mollis.";
string output = input.Truncate(50);

// output: "Lorem ipsum dolor sit amet, consectetur adipisci..."

StripNewLines()

Parameters: this string input

The StripNewLines() extension method removes carriage returns and line feeds from a given string. It is useful when we want to clean up a string and remove any line breaks.

Example:

string input = "Hello\nWorld\r\n!";
string output = input.StripNewLines();

// output: "HelloWorld!"

ToSingleLine()

Parameters: this string text

The ToSingleLine() extension method converts a multiline string to a single line by replacing line breaks with spaces. It is useful when we want to concatenate a multiline string into a single line.

Example:

string input = "Lorem ipsum dolor sit amet,\r\nconsectetur adipiscing elit.\nSed do eiusmod tempor incididunt ut labore et dolore magna aliqua.";
string output = input.ToSingleLine();

// output: "Lorem ipsum dolor sit amet, consectetur adipiscing elit. Sed do eiusmod tempor incididunt ut labore et dolore magna aliqua."

OrIfNullOrWhiteSpace()

Parameters: this string input, string alternative

The OrIfNullOrWhiteSpace() extension method returns the input string if it is not null or whitespace, otherwise, it returns the alternative string. It is useful when we want to provide a default value for a string if it is empty.

Example:

string input = "";
string output = input.OrIfNullOrWhiteSpace("Hello, world!");

// output: "Hello, world!"

ToFirstUpper()

Parameters: this string input, this string input, CultureInfo culture

The ToFirstUpper() extension method converts the first character of a string to uppercase. It takes an optional CultureInfo parameter to specify the culture-specific casing rules to be used. If the input string is null or contains only whitespace, the method returns the input string without modification.

Example:

string input = "hello, world!";
string output = input.ToFirstUpper();

// output: "Hello, world!"

string input2 = "hello, world!";
string output2 = input2.ToFirstUpper(CultureInfo.GetCultureInfo("tr-TR"));

// output2: "Hello, World!"

ToFirstLower()

Parameters: this string input, this string input, CultureInfo culture

The ToFirstLower() extension method converts the first character of a string to lowercase. It takes an optional CultureInfo parameter to specify the culture-specific casing rules to be used. If the input string is null or contains only whitespace, the method returns the input string without modification.

Example:

string input = "HELLO, WORLD!";
string output = input.ToFirstLower();

// output: "hELLO, WORLD!"

string input2 = "HELLO, WORLD!";
string output2 = input2.ToFirstLower(CultureInfo.GetCultureInfo("tr-TR"));

// output2: "hello, World!"

ToFirstUpperInvariant() / ToFirstLowerInvariant()

Parameters: this string input

The ToFirstUpperInvariant() and ToFirstLowerInvariant() extension methods are similar to ToFirstUpper() and ToFirstLower(), respectively, but they use the casing rules of the invariant culture.

Example:

string input = "hello, world!";
string output = input.ToFirstUpperInvariant();

// output: "Hello, world!"

string input2 = "HELLO, WORLD!";
string output2 = input2.ToFirstLowerInvariant();

// output2: "hELLO, WORLD!"

ReplaceMany()

Parameters: this string text, IDictionary<string, string> replacements, this string text, char[] chars, char replacement

The ReplaceMany() extension method replaces multiple occurrences of a set of characters or strings in a given string with a specified replacement character or string.

The first overload of the method takes an IDictionary parameter, where each key-value pair represents the string to be replaced and the string to replace it with.

Example:

string input = "The quick brown fox jumps over the lazy dog.";
var replacements = new Dictionary<string, string> { { "quick", "slow" }, { "brown", "red" } };
string output = input.ReplaceMany(replacements);

// output: "The slow red fox jumps over the lazy dog."

string input2 = "The quick brown fox jumps over the lazy dog.";
char[] chars2 = { 'q', 'b', 'f' };
char replacement2 = '-';
string output2 = input2.ReplaceMany(chars2, replacement2);

// output2: "The ---k ---rown ox jumps over the lazy dog."

ReplaceFirst()

Parameters: this string text, string search, string replace

The ReplaceFirst() extension method returns a new string in which only the first occurrence of a specified string is replaced by a specified replacement string.

Example:

string input = "Hello, world!";
string output = input.ReplaceFirst("o", "0");

// output: Hell0, world!

Replace()

Parameters: this string source, string oldString, string newString, StringComparison stringComparison

The Replace() extension method returns a new string in which all occurrences of a specified string in the current instance are replaced with another specified string. StringComparison specifies the type of search to use for the specified string.

Example:

string input = "HELLO, world!";
string output = input.Replace("o", "0", StringComparison.OrdinalIgnoreCase);

// output: HELL0, w0rld!

ToCSharpString()

Parameters: this string s

The ToCSharpString() extension method converts a literal string into a C# expression.

Example:

string input = "Hello, world!";
string output = input.ToCSharpString();

// output: "Hello, world!"

EscapeRegexSpecialCharacters()

Parameters: this string text

The EscapeRegexSpecialCharacters() extension method escapes all the special characters used in a regular expression.

Example:

string input = "hello[world].";
string output = input.EscapeRegexSpecialCharacters();

// output: hello\[world\]\.

ContainsAny()

Parameters: this string haystack, IEnumerable<string> needles, StringComparison comparison = StringComparison.CurrentCulture

The ContainsAny() extension method checks whether a string "haystack" contains within it any of the strings in the "needles" collection and returns true if it does or false if it doesn't.

Example:

string input = "Hello, world!";
bool output = input.ContainsAny("o", "0", "1");

// output: true

CsvContains()

Parameters: this string csv, string value

The CsvContains() extension method checks if a comma-separated string (CSV) contains a given value. It splits the input string into a list and uses the Contains() method to check if the value is in the list.

Example:

string csv = "apple,banana,cherry,date,elderberry";
string value = "cherry";
bool output = csv.CsvContains(value1); 
// output: true

string value2 = "kiwi";
bool output2 = csv.CsvContains(value2); 
// output2: false

ToFriendlyName()

Parameters: this string fileName

The ToFriendlyName() extension method can convert a file name to a user-friendly name for a content item. It performs several string manipulations to transform the file name, including stripping the file extension, replacing underscores and dashes with spaces, converting to title case, and replacing consecutive spaces with a single space.

Example:

string fileName = "the_quick_brown-fox.txt";
string friendlyName = fileName.ToFriendlyName(); 
// friendlyName: "The Quick Brown Fox"

ToValidXmlString()

Parameters: this string text

The ToValidXmlString() extension method returns a new string in which all occurrences of Unicode characters that are invalid in XML files are replaced with an empty string. It uses a regular expression to filter out control characters but allows only properly-formed surrogate sequences.

Example:

string text = "This is a \u0001 test string \uDC00 with invalid characters.";
string validXmlString = text.ToValidXmlString(); 
//validXmlString: "This is a  test string  with invalid characters."

ToGuid()

Parameters: this string text

The ToGuid() extension method converts a string to a GUID (Globally Unique Identifier). It creates a name-based UUID using the algorithm from RFC 4122 §4.3, which generates a deterministic GUID that is dependent on the namespace and name. Depending on the input string, the resulting GUID may not be unique.

Example:

string text = "This is a test string";
Guid guid = text.ToGuid(); 
//guid: {B6C89F6F-DA6F-3246-9F77-2CE7C8885CF5}

NullOrWhiteSpaceAsNull()

Parameters: this string? text

The NullOrWhiteSpaceAsNull() extension method turns a null-or-whitespace string into a null string.

Example:

string text = "  ";
string result = text.NullOrWhiteSpaceAsNull();

// result: null

IsFullPath()

Parameters: this string path

The IsFullPath() extension method provides a quick way to check whether a given path is a full path including drive letter. This method takes one parameter path, which is a string value representing the path to be checked.

Example:

string path = @"C:\Program Files\Microsoft";
bool isFullPath = path.IsFullPath(); 
// isFullPath: True

In the example above, we are checking whether the given path @"C:\Program Files\Microsoft" is a full path including drive letter. The return value is true because the path includes a drive letter.

ToSafeAlias()

Parameters: this string alias, IShortStringHelper? shortStringHelper, (this string alias, IShortStringHelper shortStringHelper, bool camel, this string alias, IShortStringHelper shortStringHelper, string culture

The ToSafeAlias() extension method is designed to clean a string to produce a string that can be safely used in an alias. It takes a string parameter and an object of IShortStringHelper. IShortStringHelper is an interface that specifies a few methods to clean a string and return a safe one. If you don't provide a IShortStringHelper object, you will get a NullReferenceException. For this example I am using DI to inject Umbraco.Cms.Core.Strings.IShortStringHelper as the _shortStringHelper variable.

Example:

string alias = "Sample alias: $@$*2-+()";
string safeAlias = alias.ToSafeAlias(_shortStringHelper);

// safeAlias: "samplealias22"

You can also pass a bool value for camel, which means you want the alias to be camel-cased. If camel is true, then the first character of the alias will be converted to lower case.

Example:

string alias = "Sample alias: $@$*2-+()";
string safeAlias = alias.ToSafeAlias(_shortStringHelper, true);

// safeAlias: "sampleAlias22"

Lastly, you can clean a string in the context of a specified culture by passing a string value for culture. The alias will then be cleaned up to be used safely as an alias in the context of that specific culture.

Example:

string alias = "Sample alias: $@$*2-+()";
string safeAlias = alias.ToSafeAlias(_shortStringHelper, "en-US");

// safeAlias: "samplealias22"

ToUrlSegment()

Parameters: this string text, IShortStringHelper shortStringHelper, this string text, IShortStringHelper shortStringHelper, string? culture

The ToUrlSegment() extension method is designed to clean a string to produce a string that can safely be used in an URL segment. It takes a string parameter and an object of IShortStringHelper. IShortStringHelper is an interface that specifies a few methods to clean a string and return a safe one. If you don't provide a IShortStringHelper object, you will get a NullReferenceException.

Example:

string text = "Text to clean: $@$*2-+()";
string urlSegment = text.ToUrlSegment(new DefaultShortStringHelper());

// urlSegment: "text-to-clean-22"

You can also clean a string, using a specified culture, to produce a string that can safely be used in an URL segment by passing a string value for culture.

Example:

string text = "Text to clean: $@$*2-+()";
string urlSegment = text.ToUrlSegment(new DefaultShortStringHelper(), "en-US");

// urlSegment: "text-to-clean-22"

ToCleanString()

Parameters: this string text, IShortStringHelper shortStringHelper, CleanStringType stringType, this string text, IShortStringHelper shortStringHelper, CleanStringType stringType, char separator, this string text, IShortStringHelper shortStringHelper, CleanStringType stringType, string culture, this string text, IShortStringHelper shortStringHelper, CleanStringType stringType, char separator, string culture

The ToCleanString() extension method cleans a string by removing any unwanted characters and formatting it according to the provided options. This can be useful when working with strings that need to conform to certain conventions, such as URLs or file names.

Example:

string input = "The Quick Brown Fox Jumps Over The Lazy Dog.";
string output = input.ToCleanString(new DefaultShortStringHelper(), CleanStringType.UrlFriendly);

// output: "the-quick-brown-fox-jumps-over-the-lazy-dog"

In the above example, the input string is cleaned up to be URL friendly using the default short string helper. Other options for stringType include PascalCase and CamelCase. If a separator is specified, it will be used to separate words in the output string.

The ToCleanString() method can also take an optional culture parameter to specify a specific culture to use when cleaning the string.

string input = "The Quick Brown Fox Jumps Over The Lazy Dog.";
string output = input.ToCleanString(new DefaultShortStringHelper(), CleanStringType.CamelCase, '_', "en-US");

// output: "the_Quick_Brown_Fox_Jumps_Over_The_Lazy_Dog"

In this example, the input string is cleaned up to be camelCase and the separator is set to an underscore. The culture parameter is set to "en-US".

SplitPascalCasing()

Parameters: this string phrase, IShortStringHelper shortStringHelper

The SplitPascalCasing() extension method splits a Pascal-cased string into a phrase separated by spaces. It is useful for displaying text in a more readable format.

Example:

string input = "PascalCasedString";
string output = input.SplitPascalCasing(new ShortStringHelper());

// output: "Pascal Cased String"

ToSafeFileName()

Parameters: this string text, IShortStringHelper shortStringHelper, this string text, IShortStringHelper shortStringHelper, string culture

The ToSafeFileName() extension method cleans a string to produce a safe filename for use internally (on disk) or externally (as a URL). It replaces characters that are not safe for filenames with safe equivalents.

Example:

string input = "Some filename with spaces.txt";
string output = input.ToSafeFileName(new ShortStringHelper());

// output: "Some_filename_with_spaces.txt"

The ToSafeFileName() extension method also has an overload that takes a culture parameter, allowing you to specify the culture context for cleaning the string.

Example:

string input = "Some filename with spaces.txt";
string output = input.ToSafeFileName(new ShortStringHelper(), "en-US");

// output: "Some_filename_with_spaces.txt"

EscapedSplit()

Parameters: this string value, char splitChar, char escapeChar = DefaultEscapedStringEscapeChar

The EscapedSplit() extension method splits a string with an escape character that allows for the split character to exist within the string. This is useful when dealing with strings that contain characters that are used to split the string into parts.

Example:

string input = "one|two\\|three|four";
IEnumerable<string> output = input.EscapedSplit('|', '\\');

// output: ["one", "two|three", "four"]

Source: GitHub

Thank You For Reading!

What are your favourites? Let me know in the comments section below 👇

Codegarden 2022 - The Umbraco Keynote Breakdown

Andy Boot — Sun, 30 Oct 2022 10:00:07 +0000

This article was written shortly after Umbraco Codegarden 2022 which ended on Friday, 17th June 2022. Parts of this article may have changed at the time of publication.

Summary
The Umbraco Keynote
- MVP's
- New vision
- Product Focused
Umbraco Product Updates
- Umbraco Cloud
- Umbraco Heartcore
- Umbraco Forms
- Umbraco CMS
- DXP
- Long-term Support (LTS) and End-of-Life (EOL)
Video Replay

Summary

Codegarden is the biggest annual one-of-a-kind knowledge-sharing conference in the world, and I was proud to be representing Pixel Builders. The event was held between Wednesday, 15th June 2022 to Friday, 17th June 2022 in Odense, Denmark and for the first time ever it is a hybrid event which had both in-person & virtual attendees (pre-COVID it was traditionally in-person attendees only). I was fortunate to be attending as an unlimited access virtual attendee for a second year running (last year it was free and virtual only) and went full throttle with my listening ears with the hope to learn one or two new things.

The Umbraco Keynote

With every Codegarden comes a traditional opening Keynote to kick things off. The Keynote included a look back at the past year, including several announcements and things to look forward to in the future. The speakers on stage were Kim Sneum Madsen, Filip Bech-Larsen and Emma Burstow. Umbraco welcomed a special guest on stage to kick things off with Peter Rahbæk Juel, the mayor of Odense who gave a warm welcome to all Codegarden attendees.

MVP’s

The session began honouring 7 new & 59 renewed Umbraco MVP’s (“Most Valuable People”). Congratulations to all those people who have received this unique title. #H5YR!

Notable mentions to the 7 new 2022 MVP's:

More about the 2022 MVP's can be found here: https://umbraco.com/blog/the-umbraco-2022-mvps/

New vision

Umbraco HQ have a positive future ahead of themselves and have set quite a few goals which they’re hoping to all accomplish by the end of 2027. These include:

Umbraco Cloud including strong headless offering, is the preferred CMS for partners and mid-market to lower enterprise customers by continuing to be #1 in editing experience and the most loved CMS by developers
That we enable customers and partners to compose their preferred tech stack by simplifying integrations – Composable DXP
Continue developing and innovating Umbraco CMS together with a growing and thriving Umbraco Community ensuring true outside-in perspective. Resulting in us having more than 2 million websites running on Umbraco.
Global coverage (24/7/365) with national/regional offices covering our key markets

Which direction?

Umbraco has been trying to map what the competitive landscape looks like and where it sees itself in the future and where it sees itself now. Currently it sees itself in the lower mid-market segment (along with Orchard, DNN, Joomal) and the vision is that they see themselves in the upper market and enterprise DXP space (along with Sitecore, Optimizely and Kentico). Heartcore also shares a similar vision within the CMS space (along with Contentful). Umbraco HQ have rest assured that they won’t leave people behind and CMS will continue to live on as it currently does.

Product Focused

Commercial & Open Source – The great thing about having an open-source platform of which all of their commercial products are based upon is that community contributions which make their way into a final release enhance and improve the experience of products such as Umbraco Cloud and Heartcore given they inherit those same features.
Open source is about transparency – Their values are about openness and being transparent about what they’re doing. One of the values is openness that speaks to the same point and want to share as much information as they can about what, why, how they do it and what the long-term plans are.
Listening to feedback – Proactive in listening to feedback over the last year from developers, agencies, end-users, editor & partners. There is a new community team listening to feedback from the community

Umbraco Product Updates

Umbraco Cloud

Umbraco Cloud is one of the available commercial offerings and is the one-stop-shop for all your Umbraco needs - the fastest, easiest, and best way to work with the most advanced open-source .NET CMS. Everything is installed, configured, and ready for development. Just click Create Project and in a few steps, Umbraco CMS is up and running.

It will speed up your time-to-market, allows you to spend your time on features and helps you stay safe and up to date.

Best place to host Umbraco

Umbraco vision is that they want it to be the best place to host Umbraco CMS want to push it to everybody as a no-brainer solution to choose Cloud for all of your products. A few key features which were highlighted were:

Deployment of culture & hostnames
Static outgoing IP
Transport security options
2 Factor Authentication (2FA)
Partial restore of forms
Named firewall rules
Content Comparison
Schema comparison and configuration surfacing
CDN – Now an out of the box feature running Cloudflare
Backoffice User Group Selection
Domain Deployment
Usage metrics and top10
New infrastructure on Azure
Umbraco 9/10 & .Net 5+
Deploy Dashboard
Single Sign-On (SSO)
Member deployment
Restore options

Updated cloud plans

Umbraco Cloud has 3 premium plans which customers can choose from:

Starter – Restricted to 500 content nodes, 50000 page views per month, 5 GB media storage, 50GB bandwidth per month and 3 custom domains.
Standard – Restricted to 2500 content nodes, 250000 page views per month, 50 GB media storage, 300GB bandwidth per month and 10 custom domains.
Professional - Restricted to 7500 content nodes, 750000 page views per month, 500 GB media storage, 1000GB bandwidth per month and 50 custom domains.

From now on, all the above plans can have unlimited content nodes, page views per month and many more custom domains to associate with their site. All for no extra cost when compared to before.

What’s next for Cloud?

2FA for Umbraco ID
Scheduled and API driven content transfers – deploy content changes at the right time.
Secret management – A secure place to store API keys or any other private settings
US Region with more regions to follow later
Dedicated resources – 3 exclusive options to choose a dedicated option for reasonable prices for exclusivity.
More to come! What out for the roadmap.

Read more about the Umbraco Cloud updates here: https://umbraco.com/blog/umbraco-cloud-update-june-2022/

Umbraco Heartcore

Umbraco Heartcore is a headless CMS that's friendly for editors and flexible for developers. It's built on top of the open-source CMS and a collaboration with Cloudflare.

A few key features from the last year:

Scaled with Cloudflare
Content notifications
Eye dropper color picker
Umbraco ID
BlockList editor
Improved caching
Data Property Editor
Content Delivery Platform
New infrastructure
Google Maps Property Editor
Extended GraphQL support
Dedicated issue-tracker
Edge-side caching
GraphQL Persisted queries – now available to all plans!

Roadmap

Custom Grid editors
Custom Property Editors
Secured Webhooks
Zapier for Forms
REST API v3 on OpenAPI

Umbraco Forms

With the latest set of releases, Umbraco Forms now makes it easy to organise thanks to its new folder structure which can individually be permissions based so you can assign the right responsibilities to specific personnel. Another great new feature is being able to localise the editing experience with your editors so they can enjoy the UI in their native language.

Roadmap

Improvements for Workflow & multi-step forms
Backoffice Form previews
Still 249 USD & Free in Cloud

Umbraco CMS

Umbraco now runs .Net 5 and .Net 6. As of June 2022, Umbraco 9 has overtaken Umbraco 8 with the number of dashboard requests. Since launch, there’s been 13 releases shipped for Umbraco CMS version 9. These have included the following new features:

Telemetry options – A feature since Umbraco 8.1 which sends statistical data to Umbraco HQ about how Umbraco is used. This is a feature regardless of the environment, however there is the ability to opt out.
Content Version Clean-up
Stabilisation
User & Member 2FA
Package telemetry - Statistics show that 54.88% of packages used on sites were community created, but only 24.56% were by HQ. Most used packages being Umbraco Forms, Umbraco Deploy, Umbraco ID, uSync, Contentment, HeartCore & GMaps.
Item tracking - Warning to prevent related content from affecting others
Easy external login providers for members

There is now a release cadence of new major releases every 6 months (June & December) and 6 weeks for every minor version. This aims to reduce the number of changes with each upgrade.

Umbraco 10

Out of pure coincidence, Umbraco’s next flagship version was released on day 2 of Codegarden (16/06/2022). The first all public and feature complete release candidate was released on 04/05/2022 and has had 5 release candidates available until launch.

Umbraco 10 has a few major upgrades since Umbraco 9, these include the following:

Nullable reference types – Following on from Microsoft’s own best practices, this helps a developer minimise the likelihood that code causes the runtime to throw a Null Reference Exception.
SQLite – Replaces SQL CE (Compact Edition) which caused limitations with .Net 6. SQLite is cross platform, fast embedded database perfect for development and small sites.
Microsoft .Net 6 – The latest long-term support (LTS) version their flagship cross platform framework. Microsoft ships with a new LTS .Net version every second year which falls in line with Umbraco LTS release schedule (see below).
- 3rd party packages –
- Imagesharp 2 – Image manipulation library now with native WebP support.
- Examine 3 – The search abstraction and library now build on the latest version of Lucene.Net
- NPoco 5 – Object-relational mapping
- AngularJS
Cross platform support – Starting from version 10, Umbraco is now officially supported on UNIX. With the experiences from version 9, core devs on multiple platforms, and support for a cross-platform embedded database, you can use Umbraco 10 on all UNIX platforms.
Cleaner code base – More Umbraco files have been moved out of the projects file set and embedded within the Umbraco class libraries.

Read more about the Umbraco 10 release here: https://umbraco.com/blog/umbraco-10-release/

What’s next

Permissions for variants – Expected in Umbraco 11 (2022 Q4)
Block Grid Editor – Work in progress to replaces the old Grid Editor. Block Editor Meets Grid Editor. – Expected in Umbraco 11 (2022 Q4)
Entity Framework (EF) Core – Expected in Umbraco 12 (2023 Q2)
Headless API – Adding headless to the core! – Expected in Umbraco 12 (2023 Q2)
Block level variation – Expected in Umbraco 13 (2023 Q4)
Content reuse – Expected in Umbraco 13 (2023 Q4)
Enterprise focus – Expected in Umbraco 13 (2023 Q4)
New ORM – In the future. Replacement for NPoco. – Expected in Umbraco 13 (2023 Q4)
Lazy Loaded Content – Expected in Umbraco 13 (2023 Q4)
Webhooks – Expected in Umbraco 13 (2023 Q4)
New Backoffice – In the future. Get rid of AngularJS & technical debt from old framework. 3 parts:
- Standalone UI library (uui.umbraco.com)
- Well-defined API
- New implementation
  - RFC out – RFC 0024 – Implement the New Backoffice
  - New prototype
- Aiming for Umbraco 13 – Dec 23

Read more about the future of Umbraco CMS here: https://umbraco.com/blog/umbraco-cms-roadmap-something-to-look-forward-to/

DXP (Digital Experience Platform)

Umbraco sees itself as a Composable DXP – a DXP assembled from integrating a series of externally run best-of-breed solutions that work together via APIs and leverage microservices architecture. These include (but not limited to) the following technology partners:

Commercetools - https://umbraco.com/blog/integrating-umbraco-cms-with-commercetools/
Hubspot - https://umbraco.com/blog/integrating-umbraco-forms-with-hubspot-crm/
SEMrush - https://umbraco.com/blog/integrating-umbraco-cms-with-semrush/
Zapier - https://our.umbraco.com/documentation/tutorials/Connecting-Umbraco-Forms-and-Zapier/
Google Search Console - https://umbraco.com/blog/integrating-umbraco-cms-with-google-search-console-url-inspection-tool/
Shopify - https://umbraco.com/blog/integrating-umbraco-cms-with-shopify/

There will also be a new Umbraco Marketplace which will replace the Our Packages catalog (https://our.umbraco.com/packages/) which will be populated from NuGet with packages tagged “umbraco-marketplace”.

Long-term Support (LTS) and End-of-Life (EOL)

This wasn't mentioned in the keynote, however it's still worth mentioning.

So as already noted above that Umbraco CMS will release a LTS version every 2 years (or every 4th major version) to coincide with the Microsoft release schedule for each LTS version of .Net (formally .Net Core). These versions (i.e., 10, 13, 17) will have an extended support and security phase when compared with the non-LTS versions (i.e., 9, 11, 12) which will see a shorter support and security phase before eventually seeing an earlier EOL in comparison.

Whilst a product version is still within a support phase, it will receive bug fixes, regressions, and security patches. These will be released as per a fixed release cadence of every 6 weeks. After the support phase we will enter the security phase which continue to receive security fixes as per the 6-week release cadence. Once the product has reached EOL it will no longer continue to see any releases.

More information about this and other Umbraco products can be found on the Umbraco knowledge center: https://umbraco.com/products/knowledge-center/long-term-support-and-end-of-life/

Another interesting article I found by Eric Seng, which consolidates all the information regarding LTD & EOL for the .NET family can be read here: https://blog.inedo.com/dotnet/3-dotnet-lts-charts

Video Replay

If you'd like to watch the Keynote for yourself, then Umbraco have now uploaded this to YouTube:

You can also access all the other talks made over the 3 day period:
https://www.youtube.com/playlist?list=PLG_nqaT-rbpx7QcHtQE4Efr83U6Lqf4Fp

Thank you for taking the time to read this article. I'm hoping you managed to take away some useful insights and gave you a clearer vision of Umbraco's future.

If this article has helped you in any way, or would like to provide any constructive feedback please drop me a comment below.

Umbraco Forms - Add additional attributes to existing field types

Andy Boot — Tue, 25 Oct 2022 15:43:01 +0000

We've all been there; the website designers introduce additional elements or layout which the off the shelf tools simply cannot cater for.

Recently I encountered this issue for building what I originally thought was a simple contact form with a relatively straightforward layout. Here's a similar mock-up of the design I was provided:

The main contact form on the right looks somewhat straightforward enough which Umbraco Forms can easily accommodate for, right?

Let's get started with a first draft of the form configuration:

As you can see, I've managed to create the 2 groups for the 'Your details' and 'Enquiry type' areas. Each area appears to be set within a 2-column grid layout, so I've configured it like so. So far so good, but here's my problem... how on Earth do I allow fields such as 'Company Name' to span across both grid columns?

Well, as far as I can initially tell there's no clear-cut way of doing this, given you can only define the column layout on the group and not on a per row basis. Each column is just a container where each field stacks upon one another. Perhaps in future versions we'll see an expansion of this so groups are able to create rows, and each row creates the columns.

So, plan B. Scrap two columns in our group containers at HTML level, but instead add each field on a single column basis and use CSS to structure the layout (1 or 2 columns). However, we also need a mechanism to tell each field how many columns it should span.

The Umbraco Forms API allows us to extend the original implementation of field types to perform additional duties such as custom field validation, alternative views or more importantly adding our own attributes!

As our 'Company Name' field is basic textbox (AKA 'Short Answer'), we'll focus our efforts on adapting this, and if it works apply it to other related field types afterwards.

First we'll create a new C# class, inherit from Umbraco.Forms.Core.Providers.FieldTypes.Textfield, add a new checkbox attribute named 'Span all columns?' and leave as is.



namespace MyProject.UmbracoForms.CustomFieldTypes
{
    public class Textfield : Umbraco.Forms.Core.Providers.FieldTypes.Textfield
    {
        [Umbraco.Forms.Core.Attributes.Setting("Span all columns?",
        Description = "Allows the field to span across both columns in the layout.",
        View = "Checkbox")]
        public string SpanAllColumns { get; set; } = string.Empty;

        public Textfield()
        {
        }
    }
}

We also need a composer to register this inherited class to tell Umbraco Forms to use our custom field type instead of the default one:



namespace MyProject.UmbracoForms.Composers
{
    public class UmbracoFormsCustomProvidersComposer : IComposer
    {
        public void Compose(IUmbracoBuilder builder)
        {
            builder.FormsFields().Add<Textfield>();
        }
    }
}

If we build our project and refresh the browser, we can now see our freshly added checkbox toggle against each of our 'Short Answer' fields:

Finally, with our new attribute in place we can now instruct the HTML output to add a CSS class to one of the <div> elements which wraps our field type.

Using the 'default' Umbraco Forms theme as an example, I've modified the Form.cshtml file with the following changes:



@foreach (FieldViewModel f in c.Fields)
{
    bool hidden = f.HasCondition && f.ConditionActionType == FieldConditionActionType.Show;

    // REFERENCE 1
    bool spanAllColumns = f.AdditionalSettings.ContainsKey("SpanAllColumns") ? f.AdditionalSettings["SpanAllColumns"] == "True" : false;
    int fieldTypeCols = spanAllColumns ? 12 : 6;

    // REFERENCE 2
    <div class="col-md-@fieldTypeCols @Html.GetFormFieldWrapperClass(f.FieldTypeName) @f.CssClass" @{ if (hidden) { <text> style="display: none" </text>  } }>

        @if (!f.HideLabel)
        {
            <label for="@f.Id" class="umbraco-forms-label">
                @f.Caption @if (f.ShowIndicator)
                {
                    <span class="umbraco-forms-indicator">@Model.Indicator</span>
                }
            </label>
        }

        @if (!string.IsNullOrEmpty(f.ToolTip))
        {
            <span class="umbraco-forms-tooltip help-block">@f.ToolTip</span>
        }

        <div class="umbraco-forms-field-wrapper">

            @await Html.PartialAsync(FormThemeResolver.GetFieldView(Model, f), f)

            @if (Model.ShowFieldValidaton)
            {
                @Html.ValidationMessage(f.Id)
            }

        </div>

    </div>
}

Please locate REFERENCE 1 and REFERENCE 2 in the code above.

REFERENCE 1 - Added a boolean variable named spanAllColumns to retrieve our new field type value (if exists). Also added an integer variable named fieldTypeCols to set the number of columns to either 6 or 12 based on our preference.
REFERENCE 2 - Added col-md-@fieldTypeCols to the class property of the <div> element.

The intended output after all this is something like this:

The 'Company Name' field now spans both columns thanks to it using all 12 Bootstrap 3 grid columns instead of the default 6. Now all that's left to do is to replicate our changes for the Textarea field type exactly the same as we did for the Textfield and the core basics are done.

Thank you for taking the time to read this article. Hopefully this helps somebody in their quest to perform the same task, or something similar.

If this article has helped you in any way, or would like to provide any constructive feedback please drop me a comment below.