Adding a default callback script in the form of a TagHelperComponent which will be added if no callback is set and a form id is provided instead.

This makes usage of the invisible recaptcha tag even simpler.

Author: jooni91

docs/Griesoft.AspNetCore.ReCaptcha.xml

@@ -39,7 +39,7 @@ public async Task OnActionExecutionAsync(ActionExecutingContext context, ActionE
 
             ValidationResponse validationResponse;
 
-            if (!ValidateRecaptchaFilter.TryGetRecaptchaToken(context.HttpContext.Request, out string? token))
+            if (!TryGetRecaptchaToken(context.HttpContext.Request, out string? token))
             {
                 _logger.LogWarning(Resources.RecaptchaResponseTokenMissing);
 
@@ -57,7 +57,7 @@ public async Task OnActionExecutionAsync(ActionExecutingContext context, ActionE
                 validationResponse = await _recaptchaService.ValidateRecaptchaResponse(token, GetRemoteIp(context)).ConfigureAwait(true);
             }
 
-            ValidateRecaptchaFilter.TryAddResponseToActionAguments(context, validationResponse);
+            TryAddResponseToActionAguments(context, validationResponse);
 
             if (!ShouldShortCircuit(context, validationResponse))
             {

src/ReCaptcha/Filters/ValidateRecaptchaFilter.cs

@@ -24,6 +24,7 @@
     </PropertyGroup>
 
     <ItemGroup>
+        <PackageReference Include="Microsoft.AspNetCore.Mvc.Razor" Version="2.2.0" />
         <PackageReference Include="Microsoft.CodeAnalysis.NetAnalyzers" Version="6.0.0">
             <PrivateAssets>all</PrivateAssets>
             <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>

src/ReCaptcha/ReCaptcha.csproj

@@ -0,0 +1,40 @@
+using System;
+using Microsoft.AspNetCore.Razor.TagHelpers;
+
+namespace Griesoft.AspNetCore.ReCaptcha.TagHelpers
+{
+    /// <summary>
+    /// This tag helper component is used to add a short callback script to the bottom of a body tag.
+    /// </summary>
+    /// <remarks>
+    /// The callback script is used as a default callback function to submit a form after a reCAPTCHA challenge was successful.
+    /// </remarks>
+    public class CallbackScriptTagHelperComponent : TagHelperComponent
+    {
+        private readonly string _formId;
+
+        /// <summary>
+        /// 
+        /// </summary>
+        /// <param name="formId"></param>
+        public CallbackScriptTagHelperComponent(string formId)
+        {
+            _formId = formId;
+        }
+
+        /// <inheritdoc />
+        public override void Process(TagHelperContext context, TagHelperOutput output)
+        {
+            if (string.Equals(context.TagName, "body", StringComparison.OrdinalIgnoreCase))
+            {
+                output.PostContent.AppendHtml(CallbackScript(_formId));
+            }
+        }
+
+        private static string CallbackScript(string formId)
+        {
+            // Append the formId to the function name in case that multiple recaptcha tags are added in a document.
+            return $"<script>function submit{formId}(token){{document.getElementById('{formId}').submit();}}</script>";
+        }
+    }
+}

src/ReCaptcha/TagHelpers/CallbackScriptTagHelperComponent.cs

@@ -3,19 +3,29 @@
 using Griesoft.AspNetCore.ReCaptcha.Configuration;
 using Griesoft.AspNetCore.ReCaptcha.Extensions;
 using Griesoft.AspNetCore.ReCaptcha.Localization;
+using Microsoft.AspNetCore.Mvc.Razor.TagHelpers;
 using Microsoft.AspNetCore.Razor.TagHelpers;
 using Microsoft.Extensions.Options;
 
 namespace Griesoft.AspNetCore.ReCaptcha.TagHelpers
 {
     /// <summary>
-    /// Add a invisible reCAPTCHA div element to your page or automatically bind the invisible captcha to a button element
-    /// by adding a re-invisible attribute to it. Both require in addition the callback attribute.
+    /// Add a invisible reCAPTCHA div element to your page. Or add a 're-invisible' attribute to a button element to bind the invisible captcha to a button.
     /// </summary>
+    /// <remarks>
+    /// The <see cref="FormId"/> is required. With the exception that you set a <see cref="Callback"/> instead.
+    /// When setting both the value set to <c>Callback</c> always wins and the <c>FormId</c> value is basically irrelevant.
+    /// 
+    /// For easiest use of this tag helper set only the <c>FormId</c>. This will add a default callback function to the body. That function does
+    /// submit the form after a successful reCAPTCHA challenge.
+    /// </remarks>
     [HtmlTargetElement("recaptcha-invisible", Attributes = "callback", TagStructure = TagStructure.WithoutEndTag)]
+    [HtmlTargetElement("recaptcha-invisible", Attributes = "formid", TagStructure = TagStructure.WithoutEndTag)]
     [HtmlTargetElement("button", Attributes = "re-invisible,callback")]
+    [HtmlTargetElement("button", Attributes = "re-invisible,formid")]
     public class RecaptchaInvisibleTagHelper : TagHelper
     {
+        private readonly ITagHelperComponentManager _tagHelperComponentManager;
         private readonly RecaptchaSettings _settings;
         private readonly RecaptchaOptions _options;
 
@@ -24,14 +34,18 @@ public class RecaptchaInvisibleTagHelper : TagHelper
         /// </summary>
         /// <param name="settings"></param>
         /// <param name="options"></param>
+        /// <param name="tagHelperComponentManager"></param>
         /// <exception cref="ArgumentNullException"></exception>
-        public RecaptchaInvisibleTagHelper(IOptionsMonitor<RecaptchaSettings> settings, IOptionsMonitor<RecaptchaOptions> options)
+        public RecaptchaInvisibleTagHelper(IOptionsMonitor<RecaptchaSettings> settings, IOptionsMonitor<RecaptchaOptions> options,
+            ITagHelperComponentManager tagHelperComponentManager)
         {
             _ = settings ?? throw new ArgumentNullException(nameof(settings));
             _ = options ?? throw new ArgumentNullException(nameof(options));
+            _ = tagHelperComponentManager ?? throw new ArgumentNullException(nameof(tagHelperComponentManager));
 
             _settings = settings.CurrentValue;
             _options = options.CurrentValue;
+            _tagHelperComponentManager = tagHelperComponentManager;
 
             Badge = _options.Badge;
         }
@@ -47,6 +61,12 @@ public RecaptchaInvisibleTagHelper(IOptionsMonitor<RecaptchaSettings> settings,
         /// </summary>
         public int? TabIndex { get; set; } = null;
 
+        /// <summary>
+        /// The id of the form that will be submitted after a successful reCAPTCHA challenge. 
+        /// This does only apply when not specifying a custom <see cref="Callback"/>.
+        /// </summary>
+        public string? FormId { get; set; }
+
         /// <summary>
         /// Set the name of your callback function, executed when the user submits a successful response. The "g-recaptcha-response" token is passed to your callback.
         /// </summary>
@@ -65,12 +85,12 @@ public RecaptchaInvisibleTagHelper(IOptionsMonitor<RecaptchaSettings> settings,
 
         /// <inheritdoc />
         /// <exception cref="ArgumentNullException"></exception>
-        /// <exception cref="NullReferenceException"><see cref="Callback"/> must not be null. It is required for invisible reCAPTCHA to work.</exception>
+        /// <exception cref="NullReferenceException">Thrown when both <see cref="Callback"/> and <see cref="FormId"/> are null or empty.</exception>
         public override void Process(TagHelperContext context, TagHelperOutput output)
         {
             _ = output ?? throw new ArgumentNullException(nameof(output));
 
-            if (string.IsNullOrEmpty(Callback))
+            if (string.IsNullOrEmpty(Callback) && string.IsNullOrEmpty(FormId))
             {
                 throw new NullReferenceException(Resources.CallbackPropertyNullErrorMessage);
             }
@@ -86,6 +106,12 @@ public override void Process(TagHelperContext context, TagHelperOutput output)
                 output.Attributes.SetAttribute("data-size", "invisible");
             }
 
+            if (string.IsNullOrEmpty(Callback))
+            {
+                Callback = $"submit{FormId}";
+                _tagHelperComponentManager.Components.Add(new CallbackScriptTagHelperComponent(FormId!));
+            }
+
             output.TagMode = TagMode.StartTagAndEndTag;
 
             output.AddClass("g-recaptcha", HtmlEncoder.Default);

src/ReCaptcha/TagHelpers/RecaptchaInvisibleTagHelper.cs

@@ -4,6 +4,7 @@
 using System.Threading.Tasks;
 using Griesoft.AspNetCore.ReCaptcha.Configuration;
 using Griesoft.AspNetCore.ReCaptcha.TagHelpers;
+using Microsoft.AspNetCore.Mvc.Razor.TagHelpers;
 using Microsoft.AspNetCore.Razor.TagHelpers;
 using Microsoft.Extensions.Options;
 using Moq;
@@ -19,6 +20,8 @@ public class RecaptchaInvisibleTagHelperTests
 
         private Mock<IOptionsMonitor<RecaptchaSettings>> _settingsMock;
         private Mock<IOptionsMonitor<RecaptchaOptions>> _optionsMock;
+        private Mock<ITagHelperComponentManager> _tagHelperComponentManagerMock;
+        private Mock<ICollection<ITagHelperComponent>> _tagHelperComponentCollectionMock;
         private TagHelperOutput _tagHelperOutputStub;
         private TagHelperContext _contextStub;
         private RecaptchaInvisibleTagHelper invisibleTagHelper;
@@ -40,6 +43,14 @@ public void Initialize()
                 .Returns(new RecaptchaOptions())
                 .Verifiable();
 
+            _tagHelperComponentCollectionMock = new Mock<ICollection<ITagHelperComponent>>();
+            _tagHelperComponentCollectionMock.Setup(instance => instance.Add(It.IsAny<CallbackScriptTagHelperComponent>()))
+                .Verifiable();
+
+            _tagHelperComponentManagerMock = new Mock<ITagHelperComponentManager>();
+            _tagHelperComponentManagerMock.SetupGet(instance => instance.Components)
+                .Returns(_tagHelperComponentCollectionMock.Object);
+
             _tagHelperOutputStub = new TagHelperOutput("recaptcha-invisible",
                 new TagHelperAttributeList(), (useCachedResult, htmlEncoder) =>
                 {
@@ -52,7 +63,7 @@ public void Initialize()
                 new Dictionary<object, object>(),
                 Guid.NewGuid().ToString("N"));
 
-            invisibleTagHelper = new RecaptchaInvisibleTagHelper(_settingsMock.Object, _optionsMock.Object)
+            invisibleTagHelper = new RecaptchaInvisibleTagHelper(_settingsMock.Object, _optionsMock.Object, _tagHelperComponentManagerMock.Object)
             {
                 Callback = CallbackName
             };
@@ -73,7 +84,7 @@ public void Construction_IsSuccessful()
                 .Verifiable();
 
             // Act
-            var instance = new RecaptchaInvisibleTagHelper(_settingsMock.Object, _optionsMock.Object);
+            var instance = new RecaptchaInvisibleTagHelper(_settingsMock.Object, _optionsMock.Object, _tagHelperComponentManagerMock.Object);
 
             // Assert
             Assert.NotNull(instance);
@@ -91,7 +102,7 @@ public void Constructor_ShouldThrow_WhenSettingsNull()
 
 
             // Assert
-            Assert.Throws<ArgumentNullException>(() => new RecaptchaInvisibleTagHelper(null, _optionsMock.Object));
+            Assert.Throws<ArgumentNullException>(() => new RecaptchaInvisibleTagHelper(null, _optionsMock.Object, _tagHelperComponentManagerMock.Object));
         }
 
         [Test]
@@ -104,7 +115,20 @@ public void Constructor_ShouldThrow_WhenOptionsNull()
 
 
             // Assert
-            Assert.Throws<ArgumentNullException>(() => new RecaptchaInvisibleTagHelper(_settingsMock.Object, null));
+            Assert.Throws<ArgumentNullException>(() => new RecaptchaInvisibleTagHelper(_settingsMock.Object, null, _tagHelperComponentManagerMock.Object));
+        }
+
+        [Test]
+        public void Constructor_ShouldThrow_WhenTagHelperComponentManagerNull()
+        {
+            // Arrange
+
+
+            // Act
+
+
+            // Assert
+            Assert.Throws<ArgumentNullException>(() => new RecaptchaInvisibleTagHelper(_settingsMock.Object, _optionsMock.Object, null));
         }
 
         [Test]
@@ -125,7 +149,7 @@ public void Constructor_ShouldSet_DefaultValues_FromGlobalOptions()
                 .Verifiable();
 
             // Act
-            var tagHelper = new RecaptchaInvisibleTagHelper(_settingsMock.Object, _optionsMock.Object);
+            var tagHelper = new RecaptchaInvisibleTagHelper(_settingsMock.Object, _optionsMock.Object, _tagHelperComponentManagerMock.Object);
 
             // Assert
             _optionsMock.Verify(options => options.CurrentValue, Times.Once);
@@ -146,16 +170,18 @@ public void Process_ShouldThrow_ArgumentNullException_WhenOutputNull()
         }
 
         [Test]
-        public void Process_ShouldThrow_NullReferenceException_WhenCallbackNullOrEmpty()
+        public void Process_ShouldThrow_NullReferenceException_WhenCallbackAndFormIdNullOrEmpty()
         {
             // Arrange
-            var nullCallbackTagHelper = new RecaptchaInvisibleTagHelper(_settingsMock.Object, _optionsMock.Object)
+            var nullCallbackTagHelper = new RecaptchaInvisibleTagHelper(_settingsMock.Object, _optionsMock.Object, _tagHelperComponentManagerMock.Object)
             {
-                Callback = null
+                Callback = null,
+                FormId = null
             };
-            var emptyCallbackTagHelper = new RecaptchaInvisibleTagHelper(_settingsMock.Object, _optionsMock.Object)
+            var emptyCallbackTagHelper = new RecaptchaInvisibleTagHelper(_settingsMock.Object, _optionsMock.Object, _tagHelperComponentManagerMock.Object)
             {
-                Callback = string.Empty
+                Callback = string.Empty,
+                FormId = string.Empty
             };
 
             // Act
@@ -180,6 +206,35 @@ public void Process_ShouldRemove_ReInvisibleAttribute_WhenButtonTag()
             Assert.IsFalse(_tagHelperOutputStub.Attributes.ContainsName("re-invisible"));
         }
 
+        [Test]
+        public void Process_ShouldSet_CallbackToDefaultCallback_WhenCallbackIsNullOrEmpty()
+        {
+            // Arrange
+            var formId = $"formId";
+            invisibleTagHelper.Callback = null;
+            invisibleTagHelper.FormId = formId;
+
+            // Act
+            invisibleTagHelper.Process(_contextStub, _tagHelperOutputStub);
+
+            // Assert
+            Assert.AreEqual(invisibleTagHelper.Callback, $"submit{formId}");
+        }
+
+        [Test]
+        public void Process_ShouldAdd_CallbackScriptTagHelperComponent_WhenCallbackIsNullOrEmpty()
+        {
+            // Arrange
+            invisibleTagHelper.Callback = null;
+            invisibleTagHelper.FormId = "formId";
+
+            // Act
+            invisibleTagHelper.Process(_contextStub, _tagHelperOutputStub);
+
+            // Assert
+            _tagHelperComponentCollectionMock.Verify();
+        }
+
         [Test]
         public void Process_ShouldChange_TagNameToDiv_WhenNotButtonTag()
         {