update the cookie consent control.

Oqtane.Server/Services/CookieConsentService.cs

@@ -1,10 +1,13 @@
 using System;
 using System.Diagnostics.Contracts;
 using System.Threading.Tasks;
+using Microsoft.AspNetCore.Builder;
 using Microsoft.AspNetCore.Http;
 using Microsoft.AspNetCore.Http.Features;
 using Microsoft.AspNetCore.Localization;
+using Microsoft.Extensions.Options;
 using Oqtane.Documentation;
+using Oqtane.Shared;
 
 namespace Oqtane.Services
 {
@@ -12,27 +15,106 @@ namespace Oqtane.Services
     public class ServerCookieConsentService : ICookieConsentService
     {
         private readonly IHttpContextAccessor _accessor;
+        private readonly CookiePolicyOptions _cookiePolicyOptions;
 
-        public ServerCookieConsentService(IHttpContextAccessor accessor)
+        public ServerCookieConsentService(IHttpContextAccessor accessor, IOptions<CookiePolicyOptions> cookiePolicyOptions)
         {
             _accessor = accessor;
+            _cookiePolicyOptions = cookiePolicyOptions.Value;
         }
 
-        public Task<bool> CanTrackAsync()
+        public Task<bool> IsActionedAsync()
         {
-            var consentFeature = _accessor.HttpContext?.Features.Get<ITrackingConsentFeature>();
-            var canTrack = consentFeature?.CanTrack ?? true;
+            var actioned = false;
+            if (_accessor.HttpContext != null)
+            {
+                var cookieValue = GetCookieValue("actioned");
+                actioned = cookieValue == Constants.CookieConsentActionCookieValue;
+            }
+            return Task.FromResult(actioned);
+        }
+
+        public Task<bool> CanTrackAsync(bool optOut)
+        {
+            var canTrack = true;
+            if (_accessor.HttpContext != null)
+            {
+                var cookieValue = GetCookieValue("consent");
+                var saved = cookieValue == Constants.CookieConsentCookieValue;
+                if (optOut)
+                {
+                    canTrack = string.IsNullOrEmpty(cookieValue) || !saved;
+                }
+                else
+                {
+                    canTrack = cookieValue == Constants.CookieConsentCookieValue;
+                }
+            }
 
             return Task.FromResult(canTrack);
         }
 
+        public Task<string> CreateActionedCookieAsync()
+        {
+            var cookieString = CreateCookieString(false, string.Empty);
+            return Task.FromResult(cookieString);
+        }
+
         public Task<string> CreateConsentCookieAsync()
         {
-            var consentFeature = _accessor.HttpContext?.Features.Get<ITrackingConsentFeature>();
-            consentFeature?.GrantConsent();
-            var cookie = consentFeature?.CreateConsentCookie() ?? string.Empty;
+            var cookieString = CreateCookieString(true, Constants.CookieConsentCookieValue);
+            return Task.FromResult(cookieString);
+        }
 
-            return Task.FromResult(cookie);
+        public Task<string> WithdrawConsentCookieAsync()
+        {
+            var cookieString = CreateCookieString(true, string.Empty);
+            return Task.FromResult(cookieString);
+        }
+
+        private string GetCookieValue(string type)
+        {
+            var cookieValue = string.Empty;
+            if (_accessor.HttpContext != null)
+            {
+                var value = _accessor.HttpContext.Request.Cookies[Constants.CookieConsentCookieName];
+                var index = type == "actioned" ? 1 : 0;
+                cookieValue = !string.IsNullOrEmpty(value) && value.Contains("|") ? value.Split('|')[index] : string.Empty;
+            }
+
+            return cookieValue;
+        }
+
+        private string CreateCookieString(bool saved, string savedValue)
+        {
+            var cookieString = string.Empty;
+            if (_accessor.HttpContext != null)
+            {
+                var savedCookie = saved ? savedValue : GetCookieValue("consent");
+                var actionedCookie = Constants.CookieConsentActionCookieValue;
+                var cookieValue = $"{savedCookie}|{actionedCookie}";
+                var options = _cookiePolicyOptions.ConsentCookie.Build(_accessor.HttpContext);
+
+                if (!_accessor.HttpContext.Response.HasStarted)
+                {
+                    _accessor.HttpContext.Response.Cookies.Append(
+                        Constants.CookieConsentCookieName,
+                        cookieValue,
+                        new CookieOptions()
+                        {
+                            Expires = options.Expires,
+                            IsEssential = true,
+                            SameSite = options.SameSite,
+                            Secure = options.Secure
+                        }
+                    );
+                }
+
+                //get the cookie string from response header
+                cookieString = options.CreateCookieHeader(Constants.CookieConsentCookieName, Uri.EscapeDataString(cookieValue)).ToString();
+            }
+
+            return cookieString;
         }
     }
 }