PowerShell-scripts triggeren vanuit een Sitecore Forms Submit Action

Door Marek Musielak, 10/07/2026

Wat als je code kon uitvoeren als Sitecore Forms Submit Action, zonder ook maar iets naar je servers te deployen? Ad hoc, gelijk welke code. In de Sitecore-wereld denk je dan waarschijnlijk meteen aan "PowerShell", en terecht. Het probleem is dat Sitecore PowerShell Extensions niet geïnstalleerd zou mogen zijn op Content Delivery-servers. Dus waarom voer je het niet uit op Content Management?

Eerst hebben we de code voor de Sitecore Forms Submit Action zelf nodig. Dit is een eenvoudige opzet: we maken een remote event object aan, geven de FormSubmitContext samen met parameters die de ID van het script bevatten mee aan dat event object, en plaatsen het event vervolgens in de EventQueue van de huidige database.

using System;
using Sitecore;
using Sitecore.Diagnostics;
using Sitecore.ExperienceForms.Models;
using Sitecore.ExperienceForms.Processing;
using Sitecore.ExperienceForms.Processing.Actions;

namespace MyAssembly.MyNamespace
{
    public class ExecuteScriptAction : SubmitActionBase<ExecuteScriptActionParameters>
    {
        public ExecuteScriptAction(ISubmitActionData submitActionData) : base(submitActionData)
        {
        }

        protected override bool Execute(ExecuteScriptActionParameters parameters, FormSubmitContext formSubmitContext)
        {
            try
            {
                var @event = new ExecuteScriptRemoteEvent(Sitecore.Configuration.Settings.InstanceName, "custom:executescriptremote");
                @event.FormSubmitContext = new LimitedFormSubmitContext(formSubmitContext);
                @event.Data = parameters;
                (Context.ContentDatabase ?? Context.Database).RemoteEvents.EventQueue.QueueEvent(@event);
            }
            catch (Exception exc)
            {
                Log.Error("Exception in ExecuteScriptAction", exc, this);
                return false;
            }

            return true;
        }
    }
}

De code voor ExecuteScriptRemoteEvent, LimitedFormSubmitContext en ExecuteScriptActionParameters is eenvoudig. Wat vooral belangrijk is, is hoe we deze serialiseren met Newtonsoft.Json en TypeNameHandling.All. Dit is essentieel om ervoor te zorgen dat field view model objecten weer naar de juiste klassen kunnen worden gedeserialiseerd.

using System;
using System.Collections.Generic;
using System.Linq;
using Sitecore.ExperienceForms.Models;
using Sitecore.ExperienceForms.Processing;

namespace MyAssembly.MyNamespace
{
    public class LimitedFormSubmitContext
    {
        public LimitedFormSubmitContext()
        {
        }

        public LimitedFormSubmitContext(FormSubmitContext context)
        {
            FormId = context.FormId;
            PageId = context.PageId;
            Fields = context.Fields;
            Errors = context.Errors;
            Canceled = context.Canceled;
        }

        public Guid FormId { get; set; }

        public Guid PageId { get; set; }

        public IList<IViewModel> Fields { get; set; } = new List<IViewModel>();

        public IList<FormActionError> Errors { get; set; } = new List<FormActionError>();

        public bool HasErrors => Errors.Any();

        public bool Canceled { get; set; }
    }
}

using System;

namespace MyAssembly.MyNamespace
{
    public class ExecuteScriptActionParameters
    {
        public Guid ReferenceId { get; set; }
    }
}

using Newtonsoft.Json;
using Sitecore.Eventing;
using System.Runtime.Serialization;

namespace MyAssembly.MyNamespace
{
    [DataContract]
    internal class ExecuteScriptRemoteEvent : IHasEventName
    {
        private static JsonSerializerSettings _settings;

        private static JsonSerializerSettings Settings => _settings 
            ?? (_settings = new JsonSerializerSettings
            {
                TypeNameHandling = TypeNameHandling.All
            });

        public ExecuteScriptRemoteEvent(string instanceName, string eventName)
        {
            InstanceName = instanceName;
            EventName = eventName;
        }
    
        [DataMember]
        public string InstanceName { get; protected set; }

        [DataMember]
        public string EventName { get; protected set; }

        [IgnoreDataMember]
        public LimitedFormSubmitContext FormSubmitContext { get; set; }

        [IgnoreDataMember]
        public ExecuteScriptActionParameters Data { get; set; }
        
        [DataMember]
        public string FormSubmitContextJson
        {
            get => FormSubmitContext == null ? null : JsonConvert.SerializeObject(FormSubmitContext, Settings);
            set
            {
                if (!string.IsNullOrEmpty(value))
                {
                    FormSubmitContext = JsonConvert.DeserializeObject<LimitedFormSubmitContext>(value, Settings);
                }
            }
        }
        
        [DataMember]
        public string DataJson
        {
            get => Data == null ? null : JsonConvert.SerializeObject(Data, Settings);
            set
            {
                if (!string.IsNullOrEmpty(value))
                {
                    Data = JsonConvert.DeserializeObject<ExecuteScriptActionParameters>(value, Settings);
                }
            }
        }
    }
}

Het laatste stuk code is een Sitecore <initialize> pipeline processor die zich abonneert op de ExecuteScriptRemoteEvent, het script-item ophaalt uit de Sitecore "master"-database en het uitvoert:

using Sitecore.Data;
using Sitecore.Eventing;
using Sitecore.Pipelines;
using Spe.Core.Host;
using Spe.Core.Settings;
using Sitecore.Data.Items;

namespace MyAssembly.MyNamespace
{
    public class SubscribeToExecuteScriptRemoteEvent
    {
        public void Initialize(PipelineArgs args)
        {
            EventManager.Subscribe<ExecuteScriptRemoteEvent>(OnRemoteEvent);
        }

        private static void OnRemoteEvent<TEvent>(TEvent tEvent) where TEvent : IHasEventName
        {
            var @event = tEvent as ExecuteScriptRemoteEvent;
            if (@event == null)
                return;

            Item scriptItem = Database.GetDatabase("master").GetItem(ID.Parse(@event.Data.ReferenceId));

            if (scriptItem == null) return;

            using (var session = ScriptSessionManager.NewSession(ApplicationNames.Default, true))
            {
                session.SetVariable("formSubmitContext", @event.FormSubmitContext);
                session.ExecuteScriptPart(scriptItem, false);
            }
        }
    }
}

Wanneer alle code op zijn plaats staat, is de laatste stap het registreren van de SubscribeToExecuteScriptRemoteEvent processor in een Sitecore config patch-bestand:

<configuration xmlns:role="http://www.sitecore.net/xmlconfig/role/">
  <sitecore role:require="ContentManagement">
    <pipelines>
      <initialize>
        <processor 
          type="MyAssembly.MyNamespace.SubscribeToExecuteScriptRemoteEvent, MyAssembly" 
          method="Initialize" />
      </initialize>
    </pipelines>
  </sitecore>
</configuration>

Nu is het tijd om alles in Sitecore te configureren. Log in op de Sitecore core-database en dupliceer het item /sitecore/client/Applications/FormsBuilder/Components/Layouts/Actions/RedirectToPage samen met de subitems, en geef het nieuwe item de naam Execute PowerShell Script. Pas de tekst op het nieuwe item en de bijbehorende subitems hierop aan. Stel op het item /sitecore/client/Applications/FormsBuilder/Components/Layouts/Actions/Execute PowerShell Script/PageSettings/ItemTreeView het veld Database in op master en de raw value van het veld Static Data op {A3572733-5062-43E9-A447-54698BC1C637}, zodat de itemselectie beperkt wordt tot het deel /sitecore/system/Modules/PowerShell/Script Library van de boomstructuur:

Schakel nu terug naar de Sitecore master-database en maak een nieuw Submit Action-item aan op /sitecore/system/Settings/Forms/Submit Actions/Execute PowerShell Script. Vul de class-gegevens in en selecteer de editor die je hebt aangemaakt in de core-database.

Maak een nieuw PowerShell Script-item aan onder /sitecore/system/Modules/PowerShell/Script Library en voeg de code toe. Je kan $formSubmitContext gebruiken om toegang te krijgen tot de forminvoer van de gebruiker, bijvoorbeeld:

Write-Log ($formSubmitContext  | ConvertTo-Json )

En daar heb je het, de nieuwe actie is nu klaar om te gebruiken op elk formulier. Voeg ze gewoon toe aan het formulier en selecteer het gewenste script in de action editor.

Dat is alles wat nodig is: een custom Submit Action, een remote event en een PowerShell script item. Geen deployment nodig telkens wanneer je de logica wil aanpassen.