New Screen Workflow

I’ve made a screen and I need help with creating a workflow. I’ve copied the Opportunities workflow from 2020 R2 and repurposed it for my new screen. There isn’t any errors also. The workflow shows up when I go to the screen but the actions aren’t enabled in the screen. Any help would be great.

using PX.Common;
using PX.Data;
using PX.Data.BQL;
using PX.Data.WorkflowAPI;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using MS;
using PX.Objects.CR;
using PX.Objects.CR.MassProcess;
using PX.Objects.CR.Workflows;

namespace MS.Workflows
{
  using static PX.Data.WorkflowAPI.BoundedTo<MSMaint, MSOrder>;
  public class MSOrderWorkflow : PX.Data.PXGraphExtension<MSMaint>
  {
    // workflow works without checking active
    public static bool IsActive() => false;

    #region Consts

    public static class States
    {
      public const string New = "N";
      public const string Open = "O";
      public const string Hold = "H";
      public const string Completed = "C";

      internal class ListAttribute : PXStringListAttribute
      {
        public ListAttribute()
          : base(
            new[]
            {
              New,
              Open,
              Hold,
              Completed,
            },
            new[]
            {
              "New",
              "Open",
              "Hold",
              "Completed",
            }
          )
        { }
      }
    }

    private const string
        _fieldStatus = "Status",

        _formOpen = "FormOpen",
        _formHold = "FormHold",
        _formCompleted = "FormCompleted",

        _actionOpen = "Open",
        _actionHold = "Hold",
        _actionCompleted = "Completed";

    #endregion

    public override void Configure(PXScreenConfiguration config)
    {
      var context = config.GetScreenConfigurationContext<MSMaint, MSOrder>();

      #region forms

      var formOpen = context.Forms.Create(_formOpen, form => form
          .Prompt("Details")
          .WithFields(fields =>
          {
            AddStatusFormField(fields, _actionOpen);
          }));

      var formHold = context.Forms.Create(_formHold, form => form
          .Prompt("Details")
          .WithFields(fields =>
          {
            AddStatusFormField(fields, _actionHold);
          }));

      var formCompleted = context.Forms.Create(_formCompleted, form => form
          .Prompt("Details")
          .WithFields(fields =>
          {
            AddStatusFormField(fields, _actionCompleted);
          }));

      void AddStatusFormField(FormField.IContainerFillerFields filler, string defaultValue, params string[] values)
      {
        filler.Add(_fieldStatus, field => field
          .WithSchemaOf<MSOrder.status>()
          .IsRequired()
          .Prompt("Status")
          .DefaultValue(defaultValue)
          .OnlyComboBoxValues(values));
      }

      #endregion

            var actionOpen = context.ActionDefinitions.CreateNew(_actionOpen, action => action
                .WithFieldAssignments(fields =>
                {
                    fields.Add<MSOrder.status>(f => f.SetFromFormField(formOpen, _actionOpen));
                    fields.Add<MSOrder.isActive>(f => f.SetFromValue(true));
                })
                .DisplayName("Open")
                .WithForm(formOpen)
                .WithPersistOptions(ActionPersistOptions.ForcePersist));

            var actionHold = context.ActionDefinitions.CreateNew(_actionHold, action => action
                .WithFieldAssignments(fields =>
                {
                    fields.Add<MSOrder.status>(f => f.SetFromFormField(formHold, _actionHold));
                    fields.Add<MSOrder.isActive>(f => f.SetFromValue(true));
                })
                .DisplayName("Hold")
                .WithForm(formHold)
                .WithPersistOptions(ActionPersistOptions.ForcePersist));

            var actionCompleted = context.ActionDefinitions.CreateNew(_actionCompleted, action => action
                .WithFieldAssignments(fields =>
                {
                    fields.Add<MSOrder.status>(f => f.SetFromFormField(formCompleted, _actionCompleted));
                    fields.Add<MSOrder.isActive>(f => f.SetFromValue(true));
                })
                .DisplayName("Completed")
                .WithForm(formCompleted)
                .WithPersistOptions(ActionPersistOptions.ForcePersist));

      context.AddScreenConfigurationFor(screen =>
      {
        return screen
          .StateIdentifierIs<MSOrder.status>()
          .AddDefaultFlow(MSOrderWorkflow)
          .WithActions(actions =>
          {
            actions.Add(actionOpen);
            actions.Add(actionHold);
            actions.Add(actionCompleted);
                    })
                    .WithForms(forms =>
          {
            forms.Add(formOpen);
            forms.Add(formHold);
            forms.Add(formCompleted);
          })
          .WithFieldStates(fields =>
          {

              fields.Add<MSOrder.status>(field => field
                .SetComboValues(
                  (States.Open, "Open"),
                  (States.Hold, "Hold"),
                  (States.Completed, "Completed")));
          });
      });

      Workflow.IConfigured MSOrderWorkflow(Workflow.INeedStatesFlow flow)
      {
        #region states

        var newState = context.FlowStates.Create(States.New, state => state
          .IsInitial()
          .WithFieldStates(fields =>
          {
            fields.AddField<MSOrder.status>(field =>
              field.DefaultValue(States.Open).ComboBoxValues(States.Open));

          })
          .WithActions(actions =>
          {
            AddOpenAction(actions, isDuplicationInToolbar: true);
            AddWonAction(actions, isDuplicationInToolbar: true);
            AddLostAction(actions, isDuplicationInToolbar: true);
          }));

        var openState = context.FlowStates.Create(States.Open, state => state
          .WithFieldStates(fields =>
          {
            fields.AddField<MSOrder.status>(field =>
              field.ComboBoxValues(States.Open));

          })
          .WithActions(actions =>
          {
            AddWonAction(actions, isDuplicationInToolbar: true);
            AddLostAction(actions, isDuplicationInToolbar: true);
          }));

        var holdState = context.FlowStates.Create(States.Hold, state => state
          .WithFieldStates(fields =>
          {
            fields.AddField<MSOrder.status>(field => field
              .ComboBoxValues(States.Hold)
              .IsDisabled());

            DisableFieldsForFinalStates(fields);
          })
          .WithActions(actions =>
          {
            AddOpenAction(actions, isDuplicationInToolbar: true);
          }));

        var completedState = context.FlowStates.Create(States.Completed, state => state
          .WithFieldStates(fields =>
          {
            fields.AddField<MSOrder.status>(field => field
              .ComboBoxValues(States.Completed)
              .IsDisabled());

          })
          .WithActions(actions =>
          {
            AddOpenAction(actions, isDuplicationInToolbar: true);
          }));

        #endregion

        return flow
          .WithFlowStates(states =>
          {
            states.Add(newState);
            states.Add(openState);
            states.Add(holdState);
            states.Add(completedState);
          })
          .WithTransitions(transitions =>
          {
            transitions.Add(transition => transition
              .From(newState)
              .To(openState)
              .IsTriggeredOn(actionOpen));

            transitions.Add(transition => transition
              .From(newState)
              .To(holdState)
              .IsTriggeredOn(actionHold));

            transitions.Add(transition => transition
              .From(newState)
              .To(completedState)
              .IsTriggeredOn(actionCompleted));

            transitions.Add(transition => transition
              .From(openState)
              .To(holdState)
              .IsTriggeredOn(actionHold));

            transitions.Add(transition => transition
              .From(openState)
              .To(completedState)
              .IsTriggeredOn(actionCompleted));

            transitions.Add(transition => transition
              .From(holdState)
              .To(openState)
              .IsTriggeredOn(actionOpen));

            transitions.Add(transition => transition
              .From(completedState)
              .To(openState)
              .IsTriggeredOn(actionOpen));
                    });

        void AddOpenAction(ActionState.IContainerFillerActions filler, bool isDuplicationInToolbar = false)
        {
          filler.Add(actionOpen, a => a

            .IsDuplicatedInToolbar(isDuplicationInToolbar));
        }

        void AddWonAction(ActionState.IContainerFillerActions filler, bool isDuplicationInToolbar = false)
        {
          filler.Add(actionHold, a => a

            .IsDuplicatedInToolbar(isDuplicationInToolbar));
        }

        void AddLostAction(ActionState.IContainerFillerActions filler, bool isDuplicationInToolbar = false)
        {
           filler.Add(actionCompleted, field => field

            .IsDuplicatedInToolbar(isDuplicationInToolbar));
        }


        void DisableFieldsForFinalStates(FieldState.IContainerFillerFields fields)
        {
          fields.AddTable<MSOrder>(field => field.IsDisabled());
          fields.AddField<MSOrder.orderNbr>();  
        }
      }
    }
  }
}