Movable Activities on read only

src/modules/Elsa.Studio.Workflows.Core/Resolvers/DefaultActivityResolver.cs

@@ -1,4 +1,4 @@
-using System.Text.Json.Nodes;
+using System.Text.Json.Nodes;
 using Elsa.Api.Client.Extensions;
 using Elsa.Studio.Workflows.Domain.Contracts;
 using Elsa.Studio.Workflows.Domain.Models;
@@ -17,17 +17,57 @@ public class DefaultActivityResolver : IActivityResolver
     public bool GetSupportsActivity(JsonObject activity) => true;
 
     /// <inheritdoc />
-    public ValueTask<IEnumerable<EmbeddedActivity>> GetActivitiesAsync(JsonObject activity, CancellationToken cancellationToken = default)
+    public ValueTask<IEnumerable<EmbeddedActivity>> GetActivitiesAsync(
+        JsonObject activity,
+        CancellationToken cancellationToken = default
+    )
     {
-        var containedActivities =
-            from prop in activity
-            where prop.Value is JsonObject jsonObject && jsonObject.IsActivity() || prop.Value is JsonArray
-            let isCollection = prop.Value is JsonArray
-            let containedItems = isCollection ? ((JsonArray)prop.Value).ToArray() : new[] { prop.Value.AsObject() }
-            from containedItem in containedItems where containedItem is JsonObject && containedItem.AsObject().IsActivity()
-            let containedObject = containedItem.AsObject()
-            select new EmbeddedActivity(containedObject, prop.Key);
-
-        return new(containedActivities.ToList());
+        var embedded = new List<EmbeddedActivity>();
+
+        foreach (var (propName, node) in activity)
+        {
+            switch (node)
+            {
+                // 1) direct child activity:
+                case JsonObject childObj when childObj.IsActivity():
+                    embedded.Add(new EmbeddedActivity(childObj, propName));
+                    break;
+
+                // 2) array of activities:
+                case JsonArray arr:
+                    foreach (var item in arr.OfType<JsonObject>())
+                    {
+                        // e.g. expectedStatusCodes: pick up item.activity
+                        if (
+                            item.TryGetPropertyValue("activity", out var actNode)
+                            && actNode is JsonObject actObj
+                            && actObj.IsActivity()
+                        )
+                        {
+                            embedded.Add(new EmbeddedActivity(actObj, propName));
+                        }
+                        else if (item.IsActivity())
+                        {
+                            embedded.Add(new EmbeddedActivity(item, propName));
+                        }
+                    }
+                    break;
+            }
+
+            // 3) special‑case any nested Flowchart under "body":
+            if (
+                node is JsonObject container
+                && container.TryGetPropertyValue("body", out var bodyNode)
+                && bodyNode is JsonObject bodyObj
+                && bodyObj.TryGetPropertyValue("activities", out var activitiesNode)
+                && activitiesNode is JsonArray childActivities
+            )
+            {
+                foreach (var child in childActivities.OfType<JsonObject>())
+                    embedded.Add(new EmbeddedActivity(child, propName));
+            }
+        }
+
+        return new ValueTask<IEnumerable<EmbeddedActivity>>(embedded);
     }
-}
+}

src/modules/Elsa.Studio.Workflows.Designer/ClientLib/src/designer/api/create-graph.ts

@@ -37,13 +37,13 @@ export async function createGraph(containerId: string, componentRef: DotNetCompo
             maxScale: 3,
         },
         interacting: {
-            nodeMovable: () => !readOnly,
+            nodeMovable: () => true,
             arrowheadMovable: () => !readOnly,
-            edgeMovable: () => !readOnly,
-            vertexMovable: () => !readOnly,
+            edgeMovable: () => true,
+            vertexMovable: () => true,
             vertexAddable: () => !readOnly,
             vertexDeletable: () => !readOnly,
-            edgeLabelMovable: () => !readOnly,
+            edgeLabelMovable: () => true,
             magnetConnectable: () => !readOnly,
             toolsAddable: () => !readOnly,
             useEdgeTools: () => !readOnly,
@@ -135,9 +135,10 @@ export async function createGraph(containerId: string, componentRef: DotNetCompo
             rubberEdge: false,
             rubberNode: true,
             rubberband: true,
-            movable: !readOnly,
+            movable: true,
             showNodeSelectionBox: true,
             className: 'elsa-selection'
+
         }),
     );
 

src/modules/Elsa.Studio.Workflows.Designer/Components/FlowchartDesigner.razor.cs

@@ -370,6 +370,10 @@ protected override async Task OnAfterRenderAsync(bool firstRender)
             _componentRef = DotNetObjectReference.Create(this);
             _graphApi = await DesignerJsInterop.CreateGraphAsync(_containerId, _componentRef, IsReadOnly);
             await _pendingGraphActions.ProcessAsync();
+            if (IsReadOnly && AllNodesAtOrigin(Flowchart))
+            {
+                await AutoLayoutAsync(Flowchart, ActivityStats);
+            }
         }
     }
 
@@ -472,4 +476,34 @@ void IDisposable.Dispose()
         ThemeService.IsDarkModeChanged -= OnDarkModeChanged;
         _componentRef?.Dispose();
     }
+
+    private bool AllNodesAtOrigin(JsonObject flowchart)
+    {
+        var activities = flowchart.GetActivities(); // extension that pulls the “activities” array
+        foreach (var activity in activities)
+        {
+            // drill into metadata.designer.position.{x,y}
+            if (
+                activity.TryGetPropertyValue("metadata", out var metaNode)
+                && metaNode is JsonObject meta
+                && meta.TryGetPropertyValue("designer", out var designerNode)
+                && designerNode is JsonObject designer
+                && designer.TryGetPropertyValue("position", out var posNode)
+                && posNode is JsonObject pos
+            )
+            {
+                var x = pos["x"]?.GetValue<double>() ?? 0;
+                var y = pos["y"]?.GetValue<double>() ?? 0;
+                if (x != 0 || y != 0)
+                    return false;
+            }
+            else
+            {
+                // no metadata or no position? treat that as “still at origin”
+                continue;
+            }
+        }
+
+        return true;
+    }
 }