Disclaimer: Always check you are GDPR compliant with your own privacy office or legal department

Umbraco Engage cares about privacy and values insights. We have turned this into a standard for you and your customers. Server-side analytics in combination with a first-party cookie is quick to set up. And even better, you own your data.

You can be GDPR compliant out of the box.

Privacy is our concern

Umbraco Engage principles:

• Umbraco Engage uses specific retention periods and personal data is not kept longer than necessary.

• Umbraco Engage has set up its software according to the principles of privacy by design and by default.

GDPR Compliance

Umbraco Engage has been designed with the principles of privacy by design and privacy by default in mind. For example, the following measures have been taken:

• The retention period for the Umbraco Engage cookie is 365 days by default.

• The data is anonymized after two years, and fully deleted after three years.

• The IP address is pseudonymized by default.

• The use of view and click behavior is optional.

• Neither Umbraco Engage nor any other third party has access to the data (except for, for example, custom hosting provider), as the cookie is first party.

You can change the default settings. However, we do not recommend doing so, as they are set in line with the General Data Protection Regulation (GDPR).

Information obligation

As a customer, you must inform the user about using Umbraco Engage. This includes which personal data is processed, why, and how. To comply with the information obligation set by the GDPR, you can add the following template to your privacy (and cookie) statement:

On our website we use Umbraco Engage_. This is add-on software from_ Umbraco_, which allows us, through the use of a cookie, to analyze the website behavior of the website visitor. Based on this information, we can improve the user experience and personalize content for each specific website visitor. In order to do so, we process, amongst other things, your pseudonymized IP address, cookie ID, website and clicking behavior (optional), how you got to visit our website and your browser data. Only we have access to this personal data. The cookies will be deleted from your device after one year. The personal data collected through the use of the cookie will be retained for a maximum of two years. Hereafter, the data will be anonymized and retained for another two years. This way, we can identify trends on the website and improve the website._

Cookie consent

The Umbraco Engage cookie can be categorized as both an analytical and a personalization cookie. The cookie is used to analyze website visitor behavior and personalize content based on this behavior. Based on the GDPR and ePrivacy Directive cookie consent is required for gathering analytic and personalization data.

As the data controller it is your responsibility to obtain consent from the website visitor for the use of the Umbraco Engage cookie. Consent can be obtained using a cookie banner.

You can control the featuresand give your visitors total control over which features they wish to enable.

Integrating a cookie consent banner service such as CookieBot allows you to configure parts of Umbraco Engage based on user consent.

This article gives you a working implementation to use with CookieBot.

Code Example

The code example below shows how to create the backend code to read the CookieBot consent cookie from the end user. Based on that, decide which features of Umbraco Engageit should enable or disable.

1. Create a class that implements the Umbraco.Engage.Business.Permissions.ModulePermissions.IModulePermissions interface.

2. Check the current HTTPContext Request Cookies for the CookieBot cookie which is named CookieConsent.

From some of the documentation from CookieBot, implement the same logic to check if the value of the cookie is -1 or another value. If it is set to -1, CookieBot is indicating to us that this is a user within a region that does not require consent.

The rest of the code is deserializing the JSON string stored inside the cookie from CookieBot. It maps to the relevant cookie permission used for turning Umbraco Engage features on or off.

CookieBotModulePermissions.cs

using Microsoft.AspNetCore.Http;
using Newtonsoft.Json;
using System.Web;
using Umbraco.Engage.Business.Permissions.ModulePermissions;

namespace Umbraco.Engage.StarterKit.CookieBot
{
    public class CookieBotModulePermissions : IModulePermissions
    {
        public bool AbTestingIsAllowed(HttpContext context)
        {
            // Need to check CookieBot consent cookie
            // Did they consent to AB testing
            return IsAllowed(context, "marketing");
        }

        public bool AnalyticsIsAllowed(HttpContext context)
        {
            // Need to check CookieBot consent cookie
            // Did they consent to Analytics
            return IsAllowed(context, "statistics");
        }

        public bool PersonalizationIsAllowed(HttpContext context)
        {
            // Need to check CookieBot consent cookie
            // Did they consent to Personalization
            return IsAllowed(context, "preferences");
        }

        public bool IsAllowed(HttpContext context, string cookiePermission)
        {
            // C# Code from CookieBot to check for their cookie
            // https://www.cookiebot.com/en/developer/#h-server-side-usage
            var rawCookieBotConsentValues = context.Request.Cookies["CookieConsent"];

            if (rawCookieBotConsentValues != null)
            {
                switch (rawCookieBotConsentValues)
                {
                    case "-1":
                        // The user is not within a region that requires consent - all cookies are accepted
                        // Then we can mark Umbraco Engage features as allowed
                        return true;

                    default:
                        // The user has given their consent
                        return CheckCookieBotValue(rawCookieBotConsentValues, cookiePermission);
                }
            }

            //The user has not accepted cookies - set strictly necessary cookies only 
            return false;
        }

        public bool CheckCookieBotValue(string rawCookieBotConsentValues, string cookiePermissionToCheck)
        {
            // Read current user consent in encoded JSON
            // Sample JSON cookie payload
            /*
             * {
             *      stamp:'Ov4gD1JVnDnBaJv8K2wYQlyWlnNlT/AKO768tibZYdQGNj/EolraLw==',
             *      necessary:true,
             *      preferences:false,
             *      statistics:true,
             *      marketing:false,
             *      method:'explicit',
             *      ver:1,
             *      utc:1698057791350,
             *      region:'gb'
             * }
            */

            // Decode the consent string
            var decodedConsent = HttpUtility.UrlDecode(rawCookieBotConsentValues);

            if(decodedConsent == null)
            {
                return false;
            }

            // Deserialize the consent to a dynamic object
            var cookieBotConsentValues = JsonConvert.DeserializeObject(decodedConsent);
            if (cookieBotConsentValues == null)
            {
                // Something went wrong with the cookieConsent deserialization
                return false;
            }

            switch (cookiePermissionToCheck)
            {
                case "necessary":
                    return cookieBotConsentValues.Necessary;

                case "preferences":
                    return cookieBotConsentValues.Preferences;

                case "statistics":
                    return cookieBotConsentValues.Statistics;

                case "marketing":
                    return cookieBotConsentValues.Marketing;
                default:
                    break;
            }

            return false;
        }
    }

    public class CookieBotConsent
    {
        [JsonProperty("necessary")]
        public bool Necessary { get; set; }

        [JsonProperty("preferences")]
        public bool Preferences { get; set; }

        [JsonProperty("statistics")]
        public bool Statistics { get; set; }

        [JsonProperty("marketing")]
        public bool Marketing { get; set; }
    }
}

CookieBotComposer.cs

using Umbraco.Engage.Business.Permissions.ModulePermissions;
using Umbraco.Engage.Common.Composing;
using Umbraco.Cms.Core.Composing;
using Umbraco.Cms.Core.DependencyInjection;
using Umbraco.Extensions;

namespace Umbraco.Engage.StarterKit.CookieBot
{
    [ComposeAfter(typeof(AttributeBasedComposer))]
    public class CookieBotComposer : IComposer
    {
        public void Compose(IUmbracoBuilder builder)
        {
            builder.Services.AddUnique<IModulePermissions, CookieBotModulePermissions>();
        }
    }
}

CookieBot Cookie Keys

The existing CookieBot cookie Keys are mapped to the following Umbraco Engage features:

Configuring CookieBot

For information on setting up and configuring your Cookie Consent Banner, see the Cookiebot Documentation. It contains information on changing the wording and the look and feel of the cookie consent banner.

Installing CookieBot

To install CookieBot, insert the JavaScript tag provided by CookieBot into the <head> of your HTML template:

<script id="Cookiebot" src="https://consent.cookiebot.com/uc.js" 
        data-cbid="your-guid" 
        data-blockingmode="auto" 
        type="text/javascript"></script>

Tracking a Visitor's Initial Pageview

Umbraco Engage does not actively track visitors until they have given their consent to the Cookiebot configuration. After the visitor consents, you need to reload the page to track the visit. If no reload is performed the visitor's referrer and/or campaign information will not be tracked.

Use JavaScript to reload the page when consent is given by handling the CookiebotOnAccept event:

 window.location.reload();

Calling the above method will preserve any referrers and query strings supplied in the current request. It results in Umbraco Engage processing the current page visit and visitor correctly.

For more details, see Cookiebot Documentation.