+ @if (ActionSequence is null)
+ {
+
+ }
+ else
+ {
+
+
+@code {
+ [Parameter] public DbActionSequence? ActionSequence { get; set; }
+ [Parameter] public EventCallback
+
+
+ @if (ActionSequence.Steps.Count == 0)
+ {
+
+
+
+
+
+ No action steps
+ }
+
+ @for (int i = 0; i < ActionSequence.Steps.Count; i++)
+ {
+ var idx = i;
+ var step = ActionSequence.Steps[idx];
+
+
+ }
+
+ @if (!string.IsNullOrWhiteSpace(_argumentError))
+ {
+
+
+
+ @switch (step.Kind)
+ {
+ case DbActionKind.RunCommand:
+
+
+
+
+
+
+
+
+
+ @if (RegisteredCommands.Count > 0)
+ {
+
+ }
+ else
+ {
+
+ }
+
+
+
+
+
+ break;
+ case DbActionKind.RunActionSequence:
+
+
+ @if (AvailableActionSequences.Count > 0)
+ {
+
+ }
+ else
+ {
+
+ }
+
+
+
+
+
+ break;
+ case DbActionKind.SetFieldValue:
+
+
+ break;
+ case DbActionKind.GoToRecord:
+
+
+
+
+
+
+
+
+
+
+ break;
+ case DbActionKind.OpenForm:
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ break;
+ case DbActionKind.ApplyFilter:
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ break;
+ case DbActionKind.ClearFilter:
+
+
+
+
+ break;
+ case DbActionKind.RunSql:
+
+
+
+
+
+
+
+
+ break;
+ case DbActionKind.RunProcedure:
+
+
+
+
+
+
+
+
+ break;
+ case DbActionKind.SetControlProperty:
+
+
+ break;
+ case DbActionKind.SetControlVisibility:
+ case DbActionKind.SetControlEnabled:
+ case DbActionKind.SetControlReadOnly:
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ break;
+ case DbActionKind.ShowMessage:
+ case DbActionKind.Stop:
+
+
+
+
+
+
+
+
+
+
+
+
+ break;
+ }
+
+
+
+
+
+
+
+
+
+ @_argumentError
+ }
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ }
+
+ @if (IsStandalone)
+ {
+
@@ -91,6 +113,7 @@
[Parameter, EditorRequired] public string ChildTableName { get; set; } = "";
[Parameter, EditorRequired] public string ForeignKeyField { get; set; } = "";
[Parameter, EditorRequired] public object? ParentKeyValue { get; set; }
+ [Parameter] public bool IsStandalone { get; set; }
[Parameter] public List
+
+ }
}
+
+
+
+
+
+ Page @_pageNumber of @TotalPages
+
+
+
+ @GetVisibleRangeText()
+
+ @if (EventBindings.Count == 0)
+ {
+
+
+@code {
+ [Parameter, EditorRequired] public IReadOnlyListNo control events
+ }
+
+ @for (int i = 0; i < EventBindings.Count; i++)
+ {
+ var idx = i;
+ var binding = EventBindings[idx];
+
+
+ }
+
+ @if (!string.IsNullOrWhiteSpace(_argumentError))
+ {
+
+
+
+
+
+
+
+
+
+
+ @if (RegisteredCommands.Count > 0)
+ {
+
+ }
+ else
+ {
+
+ }
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ @_argumentError
+ }
+
+
+
+ @if (Rules.Count == 0)
+ {
+
+
+@code {
+ [Parameter, EditorRequired] public IReadOnlyListNo control rules
+ }
+
+ @for (int i = 0; i < Rules.Count; i++)
+ {
+ var ruleIndex = i;
+ var rule = Rules[ruleIndex];
+
+
+ }
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ @for (int effectIndex = 0; effectIndex < rule.Effects.Count; effectIndex++)
+ {
+ var idx = effectIndex;
+ var effect = rule.Effects[idx];
+
+
+
+ }
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
@@ -23,6 +24,7 @@
@foreach (var control in State.Controls)
{
+ if (IsNestedControl(control)) continue;
if (!State.IsVisibleAtBreakpoint(control)) continue;
var isSelected = State.SelectedIds.Contains(control.ControlId);
var c = control; // capture for lambda
@@ -32,7 +34,7 @@
@onpointerdown="e => OnItemPointerDown(e, c)"
@onpointerdown:stopPropagation="true">
- @if (State.ShowTabOrder && c.Binding is not null)
+ @if (State.ShowTabOrder && IsTabOrderControl(c))
{
var tabIdx = GetTabIndex(c);
@if (tabIdx > 0)
@@ -42,8 +44,15 @@
}
- @switch (c.ControlType)
+ @if (TryGetDesignerPreviewComponent(c, out Type? designerPreviewComponent))
{
+ _activeDesignerTabs = new(StringComparer.Ordinal);
// Marquee selection state
private bool _isMarquee;
@@ -216,6 +357,183 @@
return [];
}
+ private static int GetIntProp(ControlDefinition c, string key, int fallback)
+ {
+ if (!c.Props.Values.TryGetValue(key, out var value) || value is null)
+ return fallback;
+
+ if (value is int i) return i;
+ if (value is long l) return (int)l;
+ if (value is double d) return (int)d;
+ if (value is System.Text.Json.JsonElement je && je.TryGetInt32(out var ji)) return ji;
+ return int.TryParse(value.ToString(), out var parsed) ? parsed : fallback;
+ }
+
+ private static bool IsNestedControl(ControlDefinition c)
+ => c.Props.Values.TryGetValue("parentControlId", out var value)
+ && !string.IsNullOrWhiteSpace(value?.ToString());
+
+ private static List<(string Id, string Label)> GetTabPages(ControlDefinition c)
+ {
+ if (!c.Props.Values.TryGetValue("tabs", out var value) || value is null)
+ return [];
+
+ if (value is System.Text.Json.JsonElement json && json.ValueKind == System.Text.Json.JsonValueKind.Array)
+ {
+ return json.EnumerateArray()
+ .Select(element => ReadTabPage(element))
+ .Where(tab => tab is not null)
+ .Select(tab => tab!.Value)
+ .ToList();
+ }
+
+ if (value is IEnumerable items)
+ {
+ return items
+ .Select(item => ReadTabPage(item))
+ .Where(tab => tab is not null)
+ .Select(tab => tab!.Value)
+ .ToList();
+ }
+
+ return [];
+ }
+
+ private static (string Id, string Label)? ReadTabPage(object? value)
+ {
+ if (value is System.Text.Json.JsonElement json)
+ {
+ if (json.ValueKind != System.Text.Json.JsonValueKind.Object)
+ return null;
+
+ var id = json.TryGetProperty("id", out var idValue) ? idValue.ToString() : "";
+ var label = json.TryGetProperty("label", out var labelValue) ? labelValue.ToString() : id;
+ return string.IsNullOrWhiteSpace(id) ? null : (id, string.IsNullOrWhiteSpace(label) ? id : label);
+ }
+
+ if (value is IReadOnlyDictionary readOnly)
+ {
+ var id = readOnly.TryGetValue("id", out var idValue) ? idValue?.ToString() ?? "" : "";
+ var label = readOnly.TryGetValue("label", out var labelValue) ? labelValue?.ToString() ?? id : id;
+ return string.IsNullOrWhiteSpace(id) ? null : (id, string.IsNullOrWhiteSpace(label) ? id : label);
+ }
+
+ if (value is IDictionary dictionary)
+ {
+ var id = dictionary.TryGetValue("id", out var idValue) ? idValue?.ToString() ?? "" : "";
+ var label = dictionary.TryGetValue("label", out var labelValue) ? labelValue?.ToString() ?? id : id;
+ return string.IsNullOrWhiteSpace(id) ? null : (id, string.IsNullOrWhiteSpace(label) ? id : label);
+ }
+
+ return null;
+ }
+
+ private (string Id, string Label) GetActiveDesignerTab(ControlDefinition control, IReadOnlyList<(string Id, string Label)> tabs)
+ {
+ if (tabs.Count == 0)
+ return ("tab1", "Page 1");
+
+ if (_activeDesignerTabs.TryGetValue(control.ControlId, out string? activeId))
+ {
+ var active = tabs.FirstOrDefault(tab => string.Equals(tab.Id, activeId, StringComparison.Ordinal));
+ if (!string.IsNullOrWhiteSpace(active.Id))
+ return active;
+ }
+
+ _activeDesignerTabs[control.ControlId] = tabs[0].Id;
+ return tabs[0];
+ }
+
+ private void SetActiveDesignerTab(string controlId, string tabId)
+ {
+ _activeDesignerTabs[controlId] = tabId;
+ StateHasChanged();
+ }
+
+ private static string GetPreviewTabClass(string activeTabId, string tabId)
+ => string.Equals(activeTabId, tabId, StringComparison.Ordinal)
+ ? "preview-childtabs-tab active"
+ : "preview-childtabs-tab";
+
+ private IReadOnlyList GetTabChildControls(string parentControlId, string tabId)
+ => State.Controls
+ .Where(control => State.IsVisibleAtBreakpoint(control) && IsTabChildControl(control, parentControlId, tabId))
+ .ToList();
+
+ private static bool IsTabChildControl(ControlDefinition control, string parentControlId, string tabId)
+ => TryGetStringProp(control, "parentControlId", out string configuredParentId)
+ && string.Equals(configuredParentId, parentControlId, StringComparison.Ordinal)
+ && TryGetStringProp(control, "parentTabId", out string configuredTabId)
+ && string.Equals(configuredTabId, tabId, StringComparison.Ordinal);
+
+ private static bool TryGetStringProp(ControlDefinition control, string key, out string value)
+ {
+ value = string.Empty;
+ if (!control.Props.Values.TryGetValue(key, out object? raw) || raw is null)
+ return false;
+
+ if (raw is System.Text.Json.JsonElement json)
+ raw = json.ValueKind == System.Text.Json.JsonValueKind.String ? json.GetString() : json.ToString();
+
+ value = raw?.ToString() ?? string.Empty;
+ return !string.IsNullOrWhiteSpace(value);
+ }
+
+ private string GetTabChildStyle(ControlDefinition control)
+ {
+ var rect = State.GetEffectiveRect(control);
+ return FormattableString.Invariant($"left: {rect.X}px; top: {rect.Y}px; width: {rect.Width}px; height: {rect.Height}px;");
+ }
+
+ private string GetDesignControlTitle(ControlDefinition control)
+ {
+ var fieldName = control.Binding?.FieldName;
+ return control.ControlType switch
+ {
+ "label" => GetProp(control, "text", "Label"),
+ "checkbox" => GetProp(control, "text", fieldName ?? "Checkbox"),
+ "commandButton" => GetProp(control, "text", "Button"),
+ "toggleButton" => GetProp(control, "text", fieldName ?? "Toggle"),
+ "datagrid" => GetProp(control, "childTable", "DataGrid"),
+ "subform" => GetProp(control, "formId", "Subform"),
+ _ when !string.IsNullOrWhiteSpace(fieldName) => $"{GetControlDisplayName(control.ControlType)}: {fieldName}",
+ _ => GetControlDisplayName(control.ControlType)
+ };
+ }
+
+ private FormControlDescriptor? GetControlDescriptor(string controlType)
+ => ControlRegistry.TryGetControl(controlType, out FormControlDescriptor descriptor) ? descriptor : null;
+
+ private string GetControlDisplayName(string controlType)
+ => GetControlDescriptor(controlType)?.DisplayName ?? controlType;
+
+ private bool TryGetDesignerPreviewComponent(ControlDefinition control, out Type componentType)
+ {
+ componentType = default!;
+ FormControlDescriptor? descriptor = GetControlDescriptor(control.ControlType);
+ if (descriptor?.DesignerPreviewComponentType is null)
+ return false;
+
+ componentType = descriptor.DesignerPreviewComponentType;
+ return true;
+ }
+
+ private Dictionary GetDesignerPreviewParameters(ControlDefinition control, bool isSelected, Rect effectiveRect)
+ {
+ FormControlDescriptor descriptor = GetControlDescriptor(control.ControlType)
+ ?? new FormControlDescriptor
+ {
+ ControlType = control.ControlType,
+ DisplayName = control.ControlType,
+ ShowInToolbox = false,
+ };
+
+ return new Dictionary
+ {
+ ["Context"] = new FormControlDesignContext(control, State, isSelected, effectiveRect, descriptor),
+ };
+ }
+
private void OnCanvasPointerDown(PointerEventArgs e)
{
if (e.Button != 0) return;
@@ -244,55 +562,17 @@
var y = State.Snap(e.OffsetY);
var controlType = State.ActiveTool!;
- var (width, height) = controlType switch
- {
- "label" => (180.0, 34.0),
- "checkbox" => (200.0, 34.0),
- "textarea" => (320.0, 80.0),
- "radio" => (200.0, 80.0),
- "datagrid" => (560.0, 200.0),
- "childtabs" => (600.0, 280.0),
- _ => (320.0, 34.0)
- };
-
- var props = new Dictionary();
- if (controlType == "label")
- props["text"] = "Label";
- if (controlType == "checkbox")
- props["text"] = "Checkbox";
- if (controlType == "datagrid")
- {
- props["childTable"] = "";
- props["foreignKeyField"] = "";
- props["parentKeyField"] = "";
- props["foreignKeyName"] = "";
- props["visibleColumns"] = Array.Empty();
- props["allowAdd"] = true;
- props["allowDelete"] = true;
- props["allowEdit"] = true;
- }
- if (controlType == "childtabs")
- {
- props["tabs"] = Array.Empty();
- }
- if (controlType == "lookup")
- {
- props["lookupTable"] = "";
- props["displayField"] = "";
- props["valueField"] = "";
- props["placeholder"] = "-- Select --";
- }
- if (controlType == "computed")
- {
- props["formula"] = "";
- props["format"] = "";
- }
+ FormControlDescriptor? descriptor = GetControlDescriptor(controlType);
+ var (width, height) = descriptor is null
+ ? (320.0, 34.0)
+ : (descriptor.DefaultWidth, descriptor.DefaultHeight);
+ Dictionary props = descriptor?.CreateDefaultProps() ?? [];
var control = new ControlDefinition(
ControlId: Guid.NewGuid().ToString("N"),
ControlType: controlType,
Rect: new Rect(x, y, width, height),
- Binding: (controlType is "label" or "datagrid" or "childtabs") ? null : new BindingDefinition("", "TwoWay"),
+ Binding: (descriptor?.SupportsBinding ?? true) ? new BindingDefinition("", "TwoWay") : null,
Props: new PropertyBag(props),
ValidationOverride: null);
@@ -412,6 +692,10 @@
return 0;
}
+ private bool IsTabOrderControl(ControlDefinition c)
+ => GetControlDescriptor(c.ControlType)?.ParticipatesInTabOrder
+ ?? (c.ControlType is not ("label" or "datagrid" or "childtabs" or "tabControl" or "subform"));
+
private void ApplyResize(PointerEventArgs e)
{
var o = State.ResizeOriginRect!;
diff --git a/src/CSharpDB.Admin.Forms/Components/Designer/DesignerState.cs b/src/CSharpDB.Admin.Forms/Components/Designer/DesignerState.cs
index 77eef41a..8f432972 100644
--- a/src/CSharpDB.Admin.Forms/Components/Designer/DesignerState.cs
+++ b/src/CSharpDB.Admin.Forms/Components/Designer/DesignerState.cs
@@ -1,10 +1,15 @@
using CSharpDB.Admin.Forms.Models;
+using CSharpDB.Primitives;
namespace CSharpDB.Admin.Forms.Components.Designer;
public class DesignerState
{
private readonly List _controls = [];
+ private readonly List _eventBindings = [];
+ private readonly List _actionSequences = [];
+ private readonly List _rules = [];
+ private readonly List _validationRules = [];
private readonly Stack> _undoStack = new();
private readonly Stack> _redoStack = new();
@@ -16,6 +21,10 @@ public class DesignerState
public LayoutDefinition Layout { get; private set; } = new("absolute", 8, true, [new Breakpoint("md", 0, null)]);
public IReadOnlyList Controls => _controls;
+ public IReadOnlyList EventBindings => _eventBindings;
+ public IReadOnlyList ActionSequences => _actionSequences;
+ public IReadOnlyList Rules => _rules;
+ public IReadOnlyList ValidationRules => _validationRules;
public HashSet SelectedIds { get; } = [];
// Active tool from toolbox (null = select mode)
@@ -48,6 +57,28 @@ public class DesignerState
public double GridSize => Layout.GridSize;
public bool SnapToGrid => Layout.SnapToGrid;
+ public void SetLayoutMode(string layoutMode)
+ {
+ if (string.IsNullOrWhiteSpace(layoutMode) || string.Equals(Layout.LayoutMode, layoutMode, StringComparison.OrdinalIgnoreCase))
+ return;
+
+ Layout = Layout with { LayoutMode = layoutMode };
+ NotifyChanged();
+ }
+
+ public void SetFormName(string? formName)
+ {
+ string normalized = string.IsNullOrWhiteSpace(formName)
+ ? "Untitled Form"
+ : formName.Trim();
+
+ if (string.Equals(FormName, normalized, StringComparison.Ordinal))
+ return;
+
+ FormName = normalized;
+ NotifyChanged();
+ }
+
public double Snap(double v)
{
if (!SnapToGrid) return v;
@@ -58,6 +89,14 @@ public void LoadForm(FormDefinition form)
{
_controls.Clear();
_controls.AddRange(form.Controls);
+ _eventBindings.Clear();
+ _eventBindings.AddRange(form.EventBindings ?? []);
+ _actionSequences.Clear();
+ _actionSequences.AddRange(form.ActionSequences ?? []);
+ _rules.Clear();
+ _rules.AddRange(form.Rules ?? []);
+ _validationRules.Clear();
+ _validationRules.AddRange(form.ValidationRules ?? []);
_undoStack.Clear();
_redoStack.Clear();
SelectedIds.Clear();
@@ -82,7 +121,53 @@ public FormDefinition ToFormDefinition()
{
return new FormDefinition(
FormId, FormName, TableName, DefinitionVersion, SourceSchemaSignature,
- Layout, _controls.ToList());
+ Layout, _controls.ToList(), EventBindings: _eventBindings.ToList(), ActionSequences: _actionSequences.ToList(), Rules: _rules.ToList(), ValidationRules: _validationRules.ToList());
+ }
+
+ public void UpdateEventBindings(IReadOnlyList bindings)
+ {
+ _eventBindings.Clear();
+ _eventBindings.AddRange(bindings);
+ NotifyChanged();
+ }
+
+ public void UpdateActionSequences(IReadOnlyList sequences)
+ {
+ _actionSequences.Clear();
+ _actionSequences.AddRange(sequences);
+ NotifyChanged();
+ }
+
+ public void UpdateRules(IReadOnlyList rules)
+ {
+ _rules.Clear();
+ _rules.AddRange(rules);
+ NotifyChanged();
+ }
+
+ public void UpdateValidationRules(IReadOnlyList rules)
+ {
+ _validationRules.Clear();
+ _validationRules.AddRange(rules);
+ NotifyChanged();
+ }
+
+ public void UpdateControlValidationOverride(string controlId, ValidationOverride? validationOverride)
+ {
+ var idx = _controls.FindIndex(c => c.ControlId == controlId);
+ if (idx < 0) return;
+ PushUndo();
+ _controls[idx] = _controls[idx] with { ValidationOverride = validationOverride };
+ NotifyChanged();
+ }
+
+ public void UpdateControlEventBindings(string controlId, IReadOnlyList bindings)
+ {
+ var idx = _controls.FindIndex(c => c.ControlId == controlId);
+ if (idx < 0) return;
+ PushUndo();
+ _controls[idx] = _controls[idx] with { EventBindings = bindings.ToList() };
+ NotifyChanged();
}
public void PushUndo()
@@ -146,7 +231,23 @@ public void DeleteSelected()
{
if (SelectedIds.Count == 0) return;
PushUndo();
- _controls.RemoveAll(c => SelectedIds.Contains(c.ControlId));
+ var idsToDelete = new HashSet(SelectedIds, StringComparer.Ordinal);
+ bool added;
+ do
+ {
+ added = false;
+ foreach (var child in _controls)
+ {
+ if (TryGetParentControlId(child, out string parentControlId) &&
+ idsToDelete.Contains(parentControlId) &&
+ idsToDelete.Add(child.ControlId))
+ {
+ added = true;
+ }
+ }
+ } while (added);
+
+ _controls.RemoveAll(c => idsToDelete.Contains(c.ControlId));
SelectedIds.Clear();
NotifyChanged();
}
@@ -177,6 +278,22 @@ public void UpdateControlProp(string controlId, string key, object? value)
NotifyChanged();
}
+ public void UpdateControlProps(string controlId, IReadOnlyDictionary values)
+ {
+ if (values.Count == 0) return;
+ var idx = _controls.FindIndex(c => c.ControlId == controlId);
+ if (idx < 0) return;
+ PushUndo();
+ var c = _controls[idx];
+ var newValues = new Dictionary(c.Props.Values);
+
+ foreach (var (key, value) in values)
+ newValues[key] = value;
+
+ _controls[idx] = c with { Props = new PropertyBag(newValues) };
+ NotifyChanged();
+ }
+
public void UpdateControlType(string controlId, string newType)
{
var idx = _controls.FindIndex(c => c.ControlId == controlId);
@@ -261,8 +378,24 @@ public void MoveToIndex(string controlId, int newIndex)
public void CopySelected()
{
+ var idsToCopy = new HashSet(SelectedIds, StringComparer.Ordinal);
+ bool added;
+ do
+ {
+ added = false;
+ foreach (var child in _controls)
+ {
+ if (TryGetParentControlId(child, out string parentControlId) &&
+ idsToCopy.Contains(parentControlId) &&
+ idsToCopy.Add(child.ControlId))
+ {
+ added = true;
+ }
+ }
+ } while (added);
+
_clipboard = _controls
- .Where(c => SelectedIds.Contains(c.ControlId))
+ .Where(c => idsToCopy.Contains(c.ControlId))
.ToList();
}
@@ -272,12 +405,25 @@ public void PasteClipboard()
PushUndo();
SelectedIds.Clear();
+ var idMap = _clipboard.ToDictionary(
+ control => control.ControlId,
+ _ => Guid.NewGuid().ToString("N"),
+ StringComparer.Ordinal);
+
foreach (var original in _clipboard)
{
+ var props = new Dictionary(original.Props.Values);
+ if (TryGetParentControlId(original, out string parentControlId) &&
+ idMap.TryGetValue(parentControlId, out string? pastedParentId))
+ {
+ props["parentControlId"] = pastedParentId;
+ }
+
var pasted = original with
{
- ControlId = Guid.NewGuid().ToString("N"),
- Rect = original.Rect with { X = original.Rect.X + 16, Y = original.Rect.Y + 16 }
+ ControlId = idMap[original.ControlId],
+ Rect = original.Rect with { X = original.Rect.X + 16, Y = original.Rect.Y + 16 },
+ Props = new PropertyBag(props)
};
_controls.Add(pasted);
SelectedIds.Add(pasted.ControlId);
@@ -371,6 +517,19 @@ private void MoveControlInternal(string controlId, double x, double y)
_controls[idx] = c with { Rect = c.Rect with { X = x, Y = y } };
}
+ private static bool TryGetParentControlId(ControlDefinition control, out string parentControlId)
+ {
+ parentControlId = string.Empty;
+ if (!control.Props.Values.TryGetValue("parentControlId", out object? value) || value is null)
+ return false;
+
+ if (value is System.Text.Json.JsonElement json)
+ value = json.ValueKind == System.Text.Json.JsonValueKind.String ? json.GetString() : json.ToString();
+
+ parentControlId = value?.ToString() ?? string.Empty;
+ return !string.IsNullOrWhiteSpace(parentControlId);
+ }
+
// ===== Responsive Breakpoints =====
public double GetCanvasWidth()
diff --git a/src/CSharpDB.Admin.Forms/Components/Designer/FormActionSequencesEditor.razor b/src/CSharpDB.Admin.Forms/Components/Designer/FormActionSequencesEditor.razor
new file mode 100644
index 00000000..8b87ace5
--- /dev/null
+++ b/src/CSharpDB.Admin.Forms/Components/Designer/FormActionSequencesEditor.razor
@@ -0,0 +1,65 @@
+@using CSharpDB.Primitives
+
+ ActionSequences { get; set; } = [];
+ [Parameter] public EventCallback> ActionSequencesChanged { get; set; }
+
+ private async Task AddSequence()
+ {
+ var updated = ActionSequences
+ .Append(new DbActionSequence([], Name: NextSequenceName()))
+ .ToList();
+ await ActionSequencesChanged.InvokeAsync(updated);
+ }
+
+ private async Task UpdateSequence(int index, DbActionSequence? sequence)
+ {
+ var updated = ActionSequences.ToList();
+ if (index < 0 || index >= updated.Count)
+ return;
+
+ if (sequence is null)
+ updated.RemoveAt(index);
+ else
+ updated[index] = sequence;
+
+ await ActionSequencesChanged.InvokeAsync(updated);
+ }
+
+ private string NextSequenceName()
+ {
+ const string prefix = "Sequence";
+ HashSet existing = ActionSequences
+ .Select(sequence => sequence.Name)
+ .Where(name => !string.IsNullOrWhiteSpace(name))
+ .Select(name => name!)
+ .ToHashSet(StringComparer.OrdinalIgnoreCase);
+
+ for (int i = 1; ; i++)
+ {
+ string candidate = $"{prefix}{i}";
+ if (!existing.Contains(candidate))
+ return candidate;
+ }
+ }
+}
diff --git a/src/CSharpDB.Admin.Forms/Components/Designer/FormEventBindingsEditor.razor b/src/CSharpDB.Admin.Forms/Components/Designer/FormEventBindingsEditor.razor
new file mode 100644
index 00000000..c1f14137
--- /dev/null
+++ b/src/CSharpDB.Admin.Forms/Components/Designer/FormEventBindingsEditor.razor
@@ -0,0 +1,205 @@
+@using System.Text.Json
+@using CSharpDB.Admin.Forms.Serialization
+@using CSharpDB.Primitives
+@inject DbCommandRegistry CommandRegistry
+
+ EventBindings { get; set; } = [];
+ [Parameter] public IReadOnlyList ActionSequences { get; set; } = [];
+ [Parameter] public EventCallback> EventBindingsChanged { get; set; }
+
+ private readonly Dictionary _argumentText = [];
+ private string? _argumentError;
+
+ private static readonly FormEventKind[] EventKinds = Enum.GetValues();
+
+ private IReadOnlyList RegisteredCommands => CommandRegistry.Commands.ToList();
+
+ protected override void OnParametersSet()
+ {
+ for (int i = 0; i < EventBindings.Count; i++)
+ _argumentText.TryAdd(i, FormatArguments(EventBindings[i].Arguments));
+
+ foreach (int staleIndex in _argumentText.Keys.Where(index => index >= EventBindings.Count).ToList())
+ _argumentText.Remove(staleIndex);
+ }
+
+ private async Task AddBinding()
+ {
+ string commandName = RegisteredCommands.Count > 0 ? RegisteredCommands[0].Name : string.Empty;
+ var updated = EventBindings
+ .Append(new FormEventBinding(FormEventKind.OnLoad, commandName))
+ .ToList();
+ _argumentText[updated.Count - 1] = string.Empty;
+ await EventBindingsChanged.InvokeAsync(updated);
+ }
+
+ private async Task RemoveBinding(int index)
+ {
+ var updated = EventBindings.ToList();
+ if (index < 0 || index >= updated.Count)
+ return;
+
+ updated.RemoveAt(index);
+ RebuildArgumentText(updated);
+ await EventBindingsChanged.InvokeAsync(updated);
+ }
+
+ private Task UpdateEvent(int index, FormEventBinding binding, string? value)
+ {
+ if (!Enum.TryParse(value, ignoreCase: true, out FormEventKind eventKind))
+ return Task.CompletedTask;
+
+ return ReplaceBinding(index, binding with { Event = eventKind });
+ }
+
+ private Task UpdateCommand(int index, FormEventBinding binding, string commandName)
+ => ReplaceBinding(index, binding with { CommandName = commandName.Trim() });
+
+ private Task UpdateStopOnFailure(int index, FormEventBinding binding, bool stopOnFailure)
+ => ReplaceBinding(index, binding with { StopOnFailure = stopOnFailure });
+
+ private async Task UpdateArguments(int index, FormEventBinding binding, string text)
+ {
+ _argumentText[index] = text;
+ _argumentError = null;
+
+ if (string.IsNullOrWhiteSpace(text))
+ {
+ await ReplaceBinding(index, binding with { Arguments = null });
+ return;
+ }
+
+ try
+ {
+ IReadOnlyDictionary? arguments =
+ JsonSerializer.Deserialize>(text, JsonDefaults.Options);
+ await ReplaceBinding(index, binding with { Arguments = arguments });
+ }
+ catch (JsonException ex)
+ {
+ _argumentError = $"Invalid arguments JSON: {ex.Message}";
+ }
+ }
+
+ private Task UpdateActionSequence(int index, FormEventBinding binding, DbActionSequence? actionSequence)
+ => ReplaceBinding(index, binding with { ActionSequence = actionSequence });
+
+ private async Task ReplaceBinding(int index, FormEventBinding binding)
+ {
+ var updated = EventBindings.ToList();
+ if (index < 0 || index >= updated.Count)
+ return;
+
+ updated[index] = binding;
+ await EventBindingsChanged.InvokeAsync(updated);
+ }
+
+ private string GetArgumentsText(int index, FormEventBinding binding)
+ {
+ if (_argumentText.TryGetValue(index, out string? text))
+ return text;
+
+ text = FormatArguments(binding.Arguments);
+ _argumentText[index] = text;
+ return text;
+ }
+
+ private void RebuildArgumentText(IReadOnlyList updated)
+ {
+ _argumentText.Clear();
+ for (int i = 0; i < updated.Count; i++)
+ _argumentText[i] = FormatArguments(updated[i].Arguments);
+ }
+
+ private bool ShouldRenderMissingCommand(string commandName)
+ => !string.IsNullOrWhiteSpace(commandName)
+ && RegisteredCommands.All(command => !string.Equals(command.Name, commandName, StringComparison.OrdinalIgnoreCase));
+
+ private static string FormatArguments(IReadOnlyDictionary? arguments)
+ => arguments is null || arguments.Count == 0
+ ? string.Empty
+ : JsonSerializer.Serialize(arguments, new JsonSerializerOptions(JsonDefaults.Options) { WriteIndented = true });
+}
diff --git a/src/CSharpDB.Admin.Forms/Components/Designer/FormRenderer.razor b/src/CSharpDB.Admin.Forms/Components/Designer/FormRenderer.razor
index 1d75773b..64c761da 100644
--- a/src/CSharpDB.Admin.Forms/Components/Designer/FormRenderer.razor
+++ b/src/CSharpDB.Admin.Forms/Components/Designer/FormRenderer.razor
@@ -1,7 +1,15 @@
+@using System.Globalization
+@using System.Text.Json
+@using CSharpDB.Admin.Forms.Contracts
@using CSharpDB.Admin.Forms.Models
+@using CSharpDB.Admin.Forms.Pages
+@using CSharpDB.Admin.Forms.Services
+@using CSharpDB.Primitives
+@inject DbCommandRegistry Commands
+@inject DbExtensionPolicy? CallbackPolicy
-
+ ○ Option 1
+ ○ Option 2
+
+ break;
+ case "toggleButton":
+
+ break;
case "computed":
var formula = GetProp(c, "formula", "");
break;
+ case "commandButton":
+
+ break;
case "textarea":
break;
@@ -87,11 +118,17 @@
break;
case "datagrid":
var childTbl = GetProp(c, "childTable", "");
+ var dataGridMode = GetProp(c, "dataGridMode", "related");
+ var dataGridLabel = string.IsNullOrEmpty(childTbl)
+ ? "DataGrid (not configured)"
+ : string.Equals(dataGridMode, "standalone", StringComparison.OrdinalIgnoreCase)
+ ? $"Table Grid: {childTbl}"
+ : $"Related Grid: {childTbl}";
var dgCols = GetListProp(c, "visibleColumns");
- @(string.IsNullOrEmpty(childTbl) ? "DataGrid (not configured)" : $"DataGrid: {childTbl}")
+ @dataGridLabel
@@ -155,9 +192,111 @@
}
break;
- default:
- [@c.ControlType]
+ case "tabControl":
+ var tabPages = GetTabPages(c);
+ var visibleTabPages = tabPages.Count > 0
+ ? tabPages
+ : new List<(string Id, string Label)> { ("tab1", "Page 1") };
+ var activeTabPage = GetActiveDesignerTab(c, visibleTabPages);
+ var tabChildControls = GetTabChildControls(c.ControlId, activeTabPage.Id);
+
+
+ break;
+ case "subform":
+ var formId = GetProp(c, "formId", "");
+
+
+ @(tabPages.Count == 0 ? "Tab Control (no pages)" : "Tab Control")
+
+
+
+ @if (tabChildControls.Count == 0)
+ {
+
+ Assign child controls in the property inspector
+ }
+ else
+ {
+ @foreach (var child in tabChildControls)
+ {
+ var tabChild = child;
+ var childSelected = State.SelectedIds.Contains(tabChild.ControlId);
+
+ @if (State.ShowTabOrder && IsTabOrderControl(tabChild))
+ {
+ var tabIdx = GetTabIndex(tabChild);
+ @if (tabIdx > 0)
+ {
+
+ }
+ }
+ @tabIdx
+ }
+ }
+
+
+ @if (TryGetDesignerPreviewComponent(tabChild, out Type? tabChildDesignerPreviewComponent))
+ {
+
+
+ @if (childSelected)
+ {
+ @foreach (var h in _handles)
+ {
+ var handle = h;
+
+ }
+ }
+
+
+ break;
+ case "attachment":
+
break;
+ case "image":
+
+
+ @(string.IsNullOrWhiteSpace(formId) ? "Subform (not configured)" : $"Subform: {formId}")
+
+ Embedded form
+
+ Image preview
+
+ break;
+ default:
+ [@c.ControlType]
+ break;
+ }
}
+ @if (ActionSequences.Count == 0)
+ {
+
+
+@code {
+ [Parameter, EditorRequired] public IReadOnlyListNo reusable action sequences
+ }
+
+ @for (int i = 0; i < ActionSequences.Count; i++)
+ {
+ var idx = i;
+ var sequence = ActionSequences[idx];
+
+
+ }
+
+
+
+ @if (EventBindings.Count == 0)
+ {
+
+
+@code {
+ [Parameter, EditorRequired] public IReadOnlyListNo form events
+ }
+
+ @for (int i = 0; i < EventBindings.Count; i++)
+ {
+ var idx = i;
+ var binding = EventBindings[idx];
+
+
+ }
+
+ @if (!string.IsNullOrWhiteSpace(_argumentError))
+ {
+
+
+
+
+
+
+
+
+
+
+ @if (RegisteredCommands.Count > 0)
+ {
+
+ }
+ else
+ {
+
+ }
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ @_argumentError
+ }
+
+
+
- @foreach (var control in Form.Controls)
+
-
+ @foreach (var control in GetControlsToRender())
{
var c = control;
var fieldName = c.Binding?.FieldName;
@@ -9,74 +17,135 @@
var hasError = fieldName is not null && ValidationErrors?.ContainsKey(fieldName) == true;
var errorMsg = hasError ? ValidationErrors![fieldName!] : null;
var inputClass = hasError ? "fr-input fr-field-error" : "fr-input";
-
+
}
+
}
@@ -203,19 +414,135 @@
- @switch (c.ControlType)
+
}
- @if (_selected.ControlType is "text" or "textarea" or "number" or "select" or "lookup")
+ @if (_selected.ControlType is "text" or "textarea" or "number" or "select" or "lookup" or "comboBox" or "listBox")
{
}
+ @if (_selected.ControlType is "select" or "comboBox" or "listBox" or "optionGroup")
+ {
+
+
+ @if (TryGetRuntimeComponent(c, out Type? runtimeComponent))
{
+ ? ValidationErrors { get; set; }
[Parameter] public IReadOnlyDictionary? ChildFormTableDefinitions { get; set; }
[Parameter] public EventCallback OnChildRowsChanged { get; set; }
+ [Parameter] public EventCallback OnCommandError { get; set; }
+ [Parameter] public Func>? OnBuiltInAction { get; set; }
+ [Parameter] public IFormActionRuntime? ActionRuntime { get; set; }
+ [Parameter] public IReadOnlyDictionary>? ControlPropertyOverrides { get; set; }
+ [Parameter] public IReadOnlyDictionary? ControlFilters { get; set; }
+ [Parameter] public bool RenderAllControls { get; set; }
+ [Parameter] public double AnchorCanvasWidth { get; set; } = DesktopCanvasWidth;
+ [Parameter] public double? AnchorCanvasHeight { get; set; }
+ [Inject] public IFormControlRegistry ControlRegistry { get; set; } = DefaultFormControlRegistry.Instance;
+
+ private readonly HashSet _executingCommandButtons = [];
+ private readonly Dictionary _activeTabs = new(StringComparer.Ordinal);
+ private const string LayoutModeElastic = "elastic";
+ private const double DesktopCanvasWidth = 1200;
+ private const double TabletCanvasWidth = 768;
+ private const long DefaultMaxUploadBytes = 10 * 1024 * 1024;
+ private DbExtensionPolicy EffectiveCallbackPolicy => CallbackPolicy ?? DbExtensionPolicies.DefaultHostCallbackPolicy;
+
+ private bool TryGetRuntimeComponent(ControlDefinition control, out Type componentType)
+ {
+ componentType = default!;
+ if (!ControlRegistry.TryGetControl(control.ControlType, out FormControlDescriptor descriptor) ||
+ descriptor.RuntimeComponentType is null)
+ {
+ return false;
+ }
+
+ if (descriptor.IsBuiltIn && !descriptor.ReplaceBuiltInRuntime)
+ return false;
+
+ componentType = descriptor.RuntimeComponentType;
+ return true;
+ }
+
+ private Dictionary GetRuntimeComponentParameters(
+ ControlDefinition control,
+ string? fieldName,
+ string? validationError,
+ int tabIndex)
+ {
+ FormControlDescriptor descriptor = ControlRegistry.TryGetControl(control.ControlType, out FormControlDescriptor registered)
+ ? registered
+ : new FormControlDescriptor
+ {
+ ControlType = control.ControlType,
+ DisplayName = control.ControlType,
+ ShowInToolbox = false,
+ };
+
+ return new Dictionary
+ {
+ ["Context"] = new FormControlRuntimeContext(
+ Form,
+ control,
+ descriptor,
+ TableDefinition,
+ Record,
+ fieldName,
+ GetFieldObjectValue(fieldName),
+ GetControlChoices(control, fieldName),
+ IsControlEnabled(control),
+ IsControlReadOnly(control),
+ validationError,
+ tabIndex,
+ value => SetFieldValueAsync(control, fieldName, value),
+ (eventKind, arguments) => InvokeControlEventsAsync(control, eventKind, arguments)),
+ };
+ }
+
+ private bool IsElasticLayout
+ => string.Equals(Form.Layout.LayoutMode, LayoutModeElastic, StringComparison.OrdinalIgnoreCase);
+
+ private IEnumerable GetControlsToRender()
+ => RenderAllControls
+ ? Form.Controls
+ : Form.Controls.Where(IsTopLevelControl);
+
+ private static bool IsTopLevelControl(ControlDefinition control)
+ => !FormChoiceResolver.TryGetString(control.Props.Values, "parentControlId", out _);
+
+ private string GetRendererClass()
+ => IsElasticLayout
+ ? "form-renderer form-renderer-elastic"
+ : "form-renderer form-renderer-fixed";
+
+ private string GetRendererStyle()
+ => FormattableString.Invariant($"--fr-canvas-height: {GetCanvasHeight()}px;");
+
+ private string GetControlClass(ControlDefinition c)
+ {
+ List classes = ["fr-control", $"fr-control-{c.ControlType}"];
+
+ if (!IsVisibleAtBreakpoint(c, "mobile"))
+ classes.Add("fr-hidden-mobile");
+ if (!IsVisibleAtBreakpoint(c, "tablet"))
+ classes.Add("fr-hidden-tablet");
+
+ return string.Join(" ", classes);
+ }
+
+ private string GetControlStyle(ControlDefinition c)
+ {
+ Rect desktop = c.Rect;
+ Rect tablet = GetEffectiveRect(c, "tablet");
+ int desktopSpan = GetGridSpan(desktop, 12, DesktopCanvasWidth);
+ int tabletSpan = GetGridSpan(tablet, 8, TabletCanvasWidth);
+
+ ControlAnchors anchors = GetControlAnchors(c);
+ double canvasWidth = GetAnchorCanvasWidth();
+ double canvasHeight = GetAnchorCanvasHeight();
+
+ string resizeMode = GetProp(c, "resizeMode", "anchor");
+ string left;
+ string right;
+ string width;
+ string top;
+ string bottom;
+ string height;
+
+ if (string.Equals(resizeMode, "scale", StringComparison.OrdinalIgnoreCase))
+ {
+ left = ToCssPercent(desktop.X, canvasWidth);
+ right = "auto";
+ width = ToCssPercent(desktop.Width, canvasWidth);
+ top = ToCssPercent(desktop.Y, canvasHeight);
+ bottom = "auto";
+ height = ToCssPercent(desktop.Height, canvasHeight);
+ }
+ else
+ {
+ left = anchors.Left || !anchors.Right ? ToCssPx(desktop.X) : "auto";
+ right = anchors.Right ? ToCssPx(Math.Max(0, canvasWidth - desktop.X - desktop.Width)) : "auto";
+ width = anchors.Left && anchors.Right ? "auto" : ToCssPx(desktop.Width);
+
+ top = anchors.Top || !anchors.Bottom ? ToCssPx(desktop.Y) : "auto";
+ bottom = anchors.Bottom ? ToCssPx(Math.Max(0, canvasHeight - desktop.Y - desktop.Height)) : "auto";
+ height = anchors.Top && anchors.Bottom ? "auto" : ToCssPx(desktop.Height);
+ }
+
+ double minWidth = Math.Max(0, GetDoubleProp(c, "minWidth", 24));
+ double minHeight = Math.Max(0, GetDoubleProp(c, "minHeight", 16));
+ double elasticMinHeight = anchors.Top && anchors.Bottom ? minHeight : Math.Max(minHeight, desktop.Height);
+ string visibilityStyle = IsControlVisible(c) ? string.Empty : " display: none;";
+ return FormattableString.Invariant(
+ $"--fr-left: {left}; --fr-top: {top}; --fr-right: {right}; --fr-bottom: {bottom}; --fr-width: {width}; --fr-height: {height}; --fr-min-width: {minWidth}px; --fr-min-height: {minHeight}px; --fr-elastic-min-height: {elasticMinHeight}px; --fr-stack-order: {GetStackOrder(c)}; --fr-grid-span: {desktopSpan}; --fr-tablet-span: {tabletSpan};{visibilityStyle}");
+ }
+
+ private readonly record struct ControlAnchors(bool Left, bool Top, bool Right, bool Bottom);
+
+ private ControlAnchors GetControlAnchors(ControlDefinition c)
+ {
+ bool left = GetBoolProp(c, "anchorLeft", fallback: true);
+ bool top = GetBoolProp(c, "anchorTop", fallback: true);
+ bool right = GetBoolProp(c, "anchorRight", fallback: false);
+ bool bottom = GetBoolProp(c, "anchorBottom", fallback: false);
+
+ if (!left && !right)
+ left = true;
+ if (!top && !bottom)
+ top = true;
+
+ return new ControlAnchors(left, top, right, bottom);
+ }
+
+ private double GetAnchorCanvasWidth()
+ => AnchorCanvasWidth > 0 ? AnchorCanvasWidth : DesktopCanvasWidth;
+
+ private double GetAnchorCanvasHeight()
+ => AnchorCanvasHeight is > 0 ? AnchorCanvasHeight.Value : GetCanvasHeight();
+
+ private static string ToCssPx(double value)
+ => FormattableString.Invariant($"{value}px");
+
+ private static string ToCssPercent(double value, double total)
+ {
+ if (total <= 0)
+ return "0%";
+
+ return FormattableString.Invariant($"{value / total * 100}%");
+ }
+
+ private double GetCanvasHeight()
+ {
+ ControlDefinition[] controls = GetControlsToRender().ToArray();
+ double bottom = controls.Length == 0
+ ? 500
+ : controls.Max(control => control.Rect.Y + control.Rect.Height) + 24;
+ return Math.Max(500, bottom);
+ }
+
+ private int GetStackOrder(ControlDefinition c)
+ {
+ var ordered = GetControlsToRender()
+ .Select((control, index) => new
+ {
+ Control = control,
+ Index = index,
+ Rect = GetEffectiveRect(control, "mobile"),
+ })
+ .OrderBy(item => item.Rect.Y)
+ .ThenBy(item => item.Rect.X)
+ .ThenBy(item => item.Index)
+ .ToList();
+
+ int order = ordered.FindIndex(item => string.Equals(item.Control.ControlId, c.ControlId, StringComparison.Ordinal));
+ return order < 0 ? 0 : order;
+ }
+
+ private static int GetGridSpan(Rect rect, int columns, double canvasWidth)
+ {
+ if (canvasWidth <= 0)
+ return columns;
+
+ int span = (int)Math.Ceiling(Math.Max(1, rect.Width) / canvasWidth * columns);
+ return Math.Clamp(span, 1, columns);
+ }
+
+ private static Rect GetEffectiveRect(ControlDefinition c, string breakpoint)
+ {
+ if (string.Equals(breakpoint, "desktop", StringComparison.OrdinalIgnoreCase) || c.RendererHints is null)
+ return c.Rect;
+
+ string key = $"bp:{breakpoint}";
+ if (!c.RendererHints.TryGetValue(key, out object? hintObj) || hintObj is null)
+ return c.Rect;
+
+ if (hintObj is JsonElement json && json.ValueKind == JsonValueKind.Object)
+ {
+ double x = GetJsonDouble(json, "x", c.Rect.X);
+ double y = GetJsonDouble(json, "y", c.Rect.Y);
+ double width = GetJsonDouble(json, "width", c.Rect.Width);
+ double height = GetJsonDouble(json, "height", c.Rect.Height);
+ return new Rect(x, y, width, height);
+ }
+
+ if (hintObj is IReadOnlyDictionary dict)
+ {
+ double x = GetDictionaryDouble(dict, "x", c.Rect.X);
+ double y = GetDictionaryDouble(dict, "y", c.Rect.Y);
+ double width = GetDictionaryDouble(dict, "width", c.Rect.Width);
+ double height = GetDictionaryDouble(dict, "height", c.Rect.Height);
+ return new Rect(x, y, width, height);
+ }
+
+ return c.Rect;
+ }
+
+ private static bool IsVisibleAtBreakpoint(ControlDefinition c, string breakpoint)
+ {
+ if (string.Equals(breakpoint, "desktop", StringComparison.OrdinalIgnoreCase) || c.RendererHints is null)
+ return true;
+
+ string key = $"bp:{breakpoint}";
+ if (!c.RendererHints.TryGetValue(key, out object? hintObj) || hintObj is null)
+ return true;
+
+ if (hintObj is JsonElement json && json.ValueKind == JsonValueKind.Object)
+ return !json.TryGetProperty("visible", out JsonElement visible) || visible.GetBoolean();
+
+ if (hintObj is IReadOnlyDictionary dict && dict.TryGetValue("visible", out object? value))
+ return ReadBoolean(value, fallback: true);
+
+ return true;
+ }
+
+ private static double GetJsonDouble(JsonElement json, string propertyName, double fallback)
+ => json.TryGetProperty(propertyName, out JsonElement property) && property.ValueKind == JsonValueKind.Number && property.TryGetDouble(out double value)
+ ? value
+ : fallback;
+
+ private static double GetDictionaryDouble(IReadOnlyDictionary dict, string key, double fallback)
+ {
+ if (!dict.TryGetValue(key, out object? value) || value is null)
+ return fallback;
+
+ return value switch
+ {
+ double d => d,
+ float f => f,
+ decimal m => (double)m,
+ int i => i,
+ long l => l,
+ JsonElement json when json.ValueKind == JsonValueKind.Number && json.TryGetDouble(out double d) => d,
+ _ when double.TryParse(value.ToString(), NumberStyles.Float, CultureInfo.InvariantCulture, out double parsed) => parsed,
+ _ => fallback,
+ };
+ }
+
+ private static bool ReadBoolean(object? value, bool fallback)
+ {
+ return value switch
+ {
+ bool b => b,
+ JsonElement json when json.ValueKind is JsonValueKind.True or JsonValueKind.False => json.GetBoolean(),
+ _ when bool.TryParse(value?.ToString(), out bool parsed) => parsed,
+ _ => fallback,
+ };
+ }
private string GetFieldValue(string? fieldName)
{
@@ -228,25 +797,827 @@
private bool IsRadioChoiceSelected(string? fieldName, string? choiceValue)
=> FormControlValueConverter.ChoiceMatchesValue(GetFieldObjectValue(fieldName), choiceValue, GetFieldDefinition(fieldName));
- private void SetCheckboxFieldValue(string? fieldName, bool isChecked)
- => SetFieldValue(fieldName, FormControlValueConverter.ConvertCheckboxValue(isChecked, GetFieldDefinition(fieldName)));
+ private IReadOnlyList GetControlChoices(ControlDefinition control, string? fieldName)
+ => FormChoiceResolver.ResolveChoices(control, fieldName, Choices, GetFieldDefinition(fieldName));
+
+ private string GetSelectedChoiceValue(string? fieldName, IReadOnlyList choices)
+ {
+ object? value = GetFieldObjectValue(fieldName);
+ if (value is null)
+ return string.Empty;
+
+ EnumChoice? selected = choices.FirstOrDefault(choice =>
+ FormControlValueConverter.ChoiceMatchesValue(value, choice.Value, GetFieldDefinition(fieldName)));
+ return selected?.Value ?? Convert.ToString(value, CultureInfo.InvariantCulture) ?? string.Empty;
+ }
+
+ private string GetComboDisplayValue(string? fieldName, IReadOnlyList choices)
+ {
+ string selectedValue = GetSelectedChoiceValue(fieldName, choices);
+ if (string.IsNullOrWhiteSpace(selectedValue))
+ return GetFieldValue(fieldName);
+
+ return choices.FirstOrDefault(choice => string.Equals(choice.Value, selectedValue, StringComparison.OrdinalIgnoreCase))?.Label
+ ?? selectedValue;
+ }
+
+ private Task SetCheckboxFieldValueAsync(ControlDefinition control, string? fieldName, bool isChecked)
+ => SetFieldValueAsync(control, fieldName, FormControlValueConverter.ConvertCheckboxValue(isChecked, GetFieldDefinition(fieldName)));
+
+ private Task SetRadioFieldValueAsync(ControlDefinition control, string? fieldName, string? choiceValue)
+ => SetFieldValueAsync(control, fieldName, FormControlValueConverter.ConvertChoiceValue(choiceValue, GetFieldDefinition(fieldName)));
+
+ private Task SetChoiceFieldValueAsync(ControlDefinition control, string? fieldName, object? choiceValue)
+ => SetFieldValueAsync(control, fieldName, FormControlValueConverter.ConvertChoiceValue(choiceValue?.ToString(), GetFieldDefinition(fieldName)));
- private void SetRadioFieldValue(string? fieldName, string? choiceValue)
- => SetFieldValue(fieldName, FormControlValueConverter.ConvertChoiceValue(choiceValue, GetFieldDefinition(fieldName)));
+ private bool IsListBoxMultiSelect(ControlDefinition control)
+ => GetBoolProp(control, "multiSelect");
- private void SetFieldValue(string? fieldName, object? value)
+ private bool IsListBoxChoiceSelected(ControlDefinition control, string? fieldName, string? choiceValue, IReadOnlyList choices)
+ {
+ if (!IsListBoxMultiSelect(control))
+ return FormControlValueConverter.ChoiceMatchesValue(GetFieldObjectValue(fieldName), choiceValue, GetFieldDefinition(fieldName));
+
+ FormFieldDefinition? field = GetFieldDefinition(fieldName);
+ return GetSelectedListBoxValues(control, fieldName, choices)
+ .Any(selected => FormControlValueConverter.ChoiceMatchesValue(selected, choiceValue, field));
+ }
+
+ private Task SetListBoxValueAsync(ControlDefinition control, string? fieldName, object? rawValue, IReadOnlyList choices)
+ {
+ if (!IsListBoxMultiSelect(control))
+ return SetChoiceFieldValueAsync(control, fieldName, rawValue);
+
+ IReadOnlyList selectedValues = ReadSelectedListBoxValues(rawValue);
+ object? storedValue = selectedValues.Count == 0
+ ? null
+ : string.Join(GetListBoxValueDelimiter(control), selectedValues);
+
+ return SetFieldValueAsync(control, fieldName, storedValue);
+ }
+
+ private IReadOnlyList GetSelectedListBoxValues(ControlDefinition control, string? fieldName, IReadOnlyList choices)
+ {
+ object? value = GetFieldObjectValue(fieldName);
+ if (value is null)
+ return [];
+
+ if (value is JsonElement json)
+ {
+ if (json.ValueKind == JsonValueKind.Array)
+ {
+ return json.EnumerateArray()
+ .Select(item => item.ValueKind == JsonValueKind.String ? item.GetString() : item.ToString())
+ .Where(item => !string.IsNullOrWhiteSpace(item))
+ .Select(item => item!)
+ .ToArray();
+ }
+
+ if (json.ValueKind == JsonValueKind.String)
+ value = json.GetString();
+ }
+
+ if (value is string text)
+ {
+ string delimiter = GetListBoxValueDelimiter(control);
+ return text
+ .Split([delimiter], StringSplitOptions.RemoveEmptyEntries | StringSplitOptions.TrimEntries)
+ .ToArray();
+ }
+
+ if (value is System.Collections.IEnumerable values && value is not byte[])
+ {
+ return values
+ .Cast()
+ .Select(item => Convert.ToString(item, CultureInfo.InvariantCulture))
+ .Where(item => !string.IsNullOrWhiteSpace(item))
+ .Select(item => item!)
+ .ToArray();
+ }
+
+ string selectedValue = GetSelectedChoiceValue(fieldName, choices);
+ return string.IsNullOrWhiteSpace(selectedValue) ? [] : [selectedValue];
+ }
+
+ private static IReadOnlyList ReadSelectedListBoxValues(object? rawValue)
+ {
+ if (rawValue is null)
+ return [];
+
+ if (rawValue is string text)
+ return string.IsNullOrWhiteSpace(text) ? [] : [text];
+
+ if (rawValue is string[] textValues)
+ return textValues.Where(value => !string.IsNullOrWhiteSpace(value)).ToArray();
+
+ if (rawValue is IEnumerable enumerableTextValues)
+ return enumerableTextValues.Where(value => !string.IsNullOrWhiteSpace(value)).ToArray();
+
+ if (rawValue is System.Collections.IEnumerable enumerable)
+ {
+ return enumerable
+ .Cast()
+ .Select(item => Convert.ToString(item, CultureInfo.InvariantCulture))
+ .Where(item => !string.IsNullOrWhiteSpace(item))
+ .Select(item => item!)
+ .ToArray();
+ }
+
+ string converted = Convert.ToString(rawValue, CultureInfo.InvariantCulture) ?? string.Empty;
+ return string.IsNullOrWhiteSpace(converted) ? [] : [converted];
+ }
+
+ private string GetListBoxValueDelimiter(ControlDefinition control)
+ {
+ string delimiter = GetProp(control, "multiValueDelimiter", ";");
+ return string.IsNullOrEmpty(delimiter) ? ";" : delimiter;
+ }
+
+ private Task SetComboBoxValueAsync(ControlDefinition control, string? fieldName, object? inputValue, IReadOnlyList choices)
+ {
+ string raw = inputValue?.ToString() ?? string.Empty;
+ if (string.IsNullOrWhiteSpace(raw))
+ return SetFieldValueAsync(control, fieldName, null);
+
+ EnumChoice? choice = choices.FirstOrDefault(candidate =>
+ string.Equals(candidate.Label, raw, StringComparison.OrdinalIgnoreCase) ||
+ string.Equals(candidate.Value, raw, StringComparison.OrdinalIgnoreCase));
+
+ if (choice is not null)
+ return SetChoiceFieldValueAsync(control, fieldName, choice.Value);
+
+ bool allowCustomValue = GetBoolProp(control, "allowCustomValue");
+ return allowCustomValue
+ ? SetChoiceFieldValueAsync(control, fieldName, raw)
+ : Task.CompletedTask;
+ }
+
+ private static string GetOptionGroupClass(string orientation, bool buttonStyle)
+ {
+ List classes = ["fr-option-group"];
+ classes.Add(string.Equals(orientation, "horizontal", StringComparison.OrdinalIgnoreCase)
+ ? "fr-option-horizontal"
+ : "fr-option-vertical");
+ if (buttonStyle)
+ classes.Add("fr-option-buttons");
+ return string.Join(" ", classes);
+ }
+
+ private bool IsToggleButtonOn(ControlDefinition control, string? fieldName)
+ {
+ object? value = GetFieldObjectValue(fieldName);
+ object? trueValue = GetConfiguredToggleValue(control, "trueValue", true);
+ return ValuesMatch(value, trueValue, GetFieldDefinition(fieldName));
+ }
+
+ private string GetToggleButtonClass(bool isOn)
+ => isOn ? "fr-toggle-button active" : "fr-toggle-button";
+
+ private string GetToggleButtonText(ControlDefinition control, string? fieldName, bool isOn)
+ {
+ string explicitText = GetProp(control, "text", string.Empty);
+ if (!string.IsNullOrWhiteSpace(explicitText))
+ return explicitText;
+
+ return isOn
+ ? GetProp(control, "onText", fieldName ?? "On")
+ : GetProp(control, "offText", fieldName ?? "Off");
+ }
+
+ private Task ToggleButtonValueAsync(ControlDefinition control, string? fieldName)
+ {
+ bool isOn = IsToggleButtonOn(control, fieldName);
+ object? next = GetConfiguredToggleValue(control, isOn ? "falseValue" : "trueValue", isOn ? false : true);
+ FormFieldDefinition? field = GetFieldDefinition(fieldName);
+ object? converted = field?.DataType == FieldDataType.Boolean
+ ? FormControlValueConverter.ConvertCheckboxValue(FormControlValueConverter.ToBoolean(next), field)
+ : FormControlValueConverter.ConvertChoiceValue(next?.ToString(), field);
+ return SetFieldValueAsync(control, fieldName, converted);
+ }
+
+ private static object? GetConfiguredToggleValue(ControlDefinition control, string key, object fallback)
+ {
+ if (!control.Props.Values.TryGetValue(key, out object? value) || value is null)
+ return fallback;
+
+ if (value is JsonElement json)
+ return json.ValueKind switch
+ {
+ JsonValueKind.Null => null,
+ JsonValueKind.True => true,
+ JsonValueKind.False => false,
+ JsonValueKind.String => json.GetString(),
+ JsonValueKind.Number when json.TryGetInt64(out long integer) => integer,
+ JsonValueKind.Number => json.GetDouble(),
+ _ => json.ToString(),
+ };
+
+ return value;
+ }
+
+ private static bool ValuesMatch(object? value, object? configuredValue, FormFieldDefinition? field)
+ {
+ if (configuredValue is bool boolValue)
+ return FormControlValueConverter.ToBoolean(value) == boolValue;
+
+ return FormControlValueConverter.ChoiceMatchesValue(value, configuredValue?.ToString(), field);
+ }
+
+ private async Task SetFieldValueAsync(ControlDefinition control, string? fieldName, object? value)
{
if (fieldName is null) return;
- BeforeFieldChanged.InvokeAsync(fieldName);
+ object? oldValue = GetFieldObjectValue(fieldName);
+ await BeforeFieldChanged.InvokeAsync(fieldName);
+ Record[fieldName] = value;
+ await InvokeControlEventsAsync(
+ control,
+ ControlEventKind.OnChange,
+ BuildFieldEventArguments(control, ControlEventKind.OnChange, fieldName, value, oldValue));
+ await OnFieldChanged.InvokeAsync(fieldName);
+ }
+
+ private async Task OnBlobFileChangedAsync(ControlDefinition control, string? fieldName, InputFileChangeEventArgs args)
+ {
+ if ((!IsAttachmentTableMode(control) && string.IsNullOrWhiteSpace(fieldName)) || !IsControlEnabled(control) || IsControlReadOnly(control))
+ return;
+
+ IBrowserFile file = args.File;
+ long maxBytes = GetLongProp(control, "maxFileBytes", DefaultMaxUploadBytes);
+ await using Stream stream = file.OpenReadStream(maxBytes);
+ using var memory = new MemoryStream();
+ await stream.CopyToAsync(memory);
+ string eventFieldName = fieldName ?? FormAttachmentValue.GetRecordKey(control.ControlId);
+
+ object? oldValue = IsAttachmentTableMode(control)
+ ? GetPendingAttachmentValue(control)
+ : GetFieldObjectValue(fieldName);
+ await BeforeFieldChanged.InvokeAsync(eventFieldName);
+
+ if (IsAttachmentTableMode(control))
+ {
+ Record[FormAttachmentValue.GetRecordKey(control.ControlId)] = FormAttachmentValue.FromFile(
+ memory.ToArray(),
+ file.Name,
+ file.ContentType,
+ file.Size);
+ }
+ else
+ {
+ Record[fieldName!] = memory.ToArray();
+ await SetRelatedFieldValueAsync(control, "fileNameField", file.Name);
+ await SetRelatedFieldValueAsync(control, "contentTypeField", file.ContentType);
+ await SetRelatedFieldValueAsync(control, "fileSizeField", file.Size);
+ }
+
+ object? newValue = IsAttachmentTableMode(control)
+ ? GetPendingAttachmentValue(control)
+ : Record[fieldName!];
+ var runtimeArguments = BuildFieldEventArguments(control, ControlEventKind.OnChange, eventFieldName, newValue, oldValue);
+ runtimeArguments["fileName"] = file.Name;
+ runtimeArguments["contentType"] = file.ContentType;
+ runtimeArguments["fileSize"] = file.Size;
+
+ await InvokeControlEventsAsync(control, ControlEventKind.OnChange, runtimeArguments);
+ await OnFieldChanged.InvokeAsync(eventFieldName);
+ }
+
+ private async Task ClearBlobFieldAsync(ControlDefinition control, string? fieldName)
+ {
+ if ((!IsAttachmentTableMode(control) && string.IsNullOrWhiteSpace(fieldName)) || !CanClearBlob(control, fieldName))
+ return;
+
+ string eventFieldName = fieldName ?? FormAttachmentValue.GetRecordKey(control.ControlId);
+ object? oldValue = IsAttachmentTableMode(control)
+ ? GetPendingAttachmentValue(control)
+ : GetFieldObjectValue(fieldName);
+ await BeforeFieldChanged.InvokeAsync(eventFieldName);
+
+ if (IsAttachmentTableMode(control))
+ {
+ Record[FormAttachmentValue.GetRecordKey(control.ControlId)] = FormAttachmentValue.Clear();
+ }
+ else
+ {
+ Record[fieldName!] = null;
+ await SetRelatedFieldValueAsync(control, "fileNameField", null);
+ await SetRelatedFieldValueAsync(control, "contentTypeField", null);
+ await SetRelatedFieldValueAsync(control, "fileSizeField", null);
+ }
+
+ await InvokeControlEventsAsync(
+ control,
+ ControlEventKind.OnChange,
+ BuildFieldEventArguments(control, ControlEventKind.OnChange, eventFieldName, IsAttachmentTableMode(control) ? GetPendingAttachmentValue(control) : null, oldValue));
+ await OnFieldChanged.InvokeAsync(eventFieldName);
+ }
+
+ private Task SetRelatedFieldValueAsync(ControlDefinition control, string metadataProperty, object? value)
+ {
+ string fieldName = GetProp(control, metadataProperty, string.Empty);
+ if (string.IsNullOrWhiteSpace(fieldName))
+ return Task.CompletedTask;
+
Record[fieldName] = value;
- OnFieldChanged.InvokeAsync(fieldName);
+ return OnFieldChanged.InvokeAsync(fieldName);
+ }
+
+ private bool CanClearBlob(ControlDefinition control, string? fieldName)
+ => IsControlEnabled(control) &&
+ !IsControlReadOnly(control) &&
+ (IsAttachmentTableMode(control) || GetBlobBytes(fieldName) is { Length: > 0 });
+
+ private string GetBlobSummary(ControlDefinition control, string? fieldName)
+ {
+ if (IsAttachmentTableMode(control))
+ {
+ FormAttachmentValue? pending = GetPendingAttachmentValue(control);
+ if (pending?.ClearExisting == true)
+ return "Attachment will be cleared";
+ if (pending?.Bytes is { Length: > 0 } pendingBytes)
+ {
+ string pendingSize = FormatByteSize(pendingBytes.LongLength);
+ return string.IsNullOrWhiteSpace(pending.FileName)
+ ? $"Pending upload ({pendingSize})"
+ : $"Pending upload: {pending.FileName} ({pendingSize})";
+ }
+
+ return "Attachment table";
+ }
+
+ byte[]? bytes = GetBlobBytes(fieldName);
+ if (bytes is null || bytes.Length == 0)
+ return "No file";
+
+ string fileNameField = GetProp(control, "fileNameField", string.Empty);
+ string fileName = string.IsNullOrWhiteSpace(fileNameField) ? string.Empty : GetFieldValue(fileNameField);
+ string size = FormatByteSize(bytes.LongLength);
+ return string.IsNullOrWhiteSpace(fileName)
+ ? size
+ : $"{fileName} ({size})";
+ }
+
+ private byte[]? GetBlobBytes(string? fieldName)
+ {
+ object? value = GetFieldObjectValue(fieldName);
+ return value switch
+ {
+ byte[] bytes => bytes,
+ JsonElement json when json.ValueKind == JsonValueKind.String && TryReadBase64(json.GetString(), out byte[]? bytes) => bytes,
+ string text when TryReadBase64(text, out byte[]? bytes) => bytes,
+ _ => null,
+ };
+ }
+
+ private string? GetImageDataUrl(ControlDefinition control, string? fieldName)
+ {
+ if (IsAttachmentTableMode(control) && GetPendingAttachmentValue(control)?.Bytes is { Length: > 0 } pendingBytes)
+ {
+ string pendingContentType = GetPendingAttachmentValue(control)?.ContentType ?? "image/png";
+ if (string.IsNullOrWhiteSpace(pendingContentType))
+ pendingContentType = "image/png";
+
+ return $"data:{pendingContentType};base64,{Convert.ToBase64String(pendingBytes)}";
+ }
+
+ byte[]? bytes = GetBlobBytes(fieldName);
+ if (bytes is null || bytes.Length == 0)
+ return null;
+
+ string contentTypeField = GetProp(control, "contentTypeField", string.Empty);
+ string contentType = string.IsNullOrWhiteSpace(contentTypeField) ? string.Empty : GetFieldValue(contentTypeField);
+ if (string.IsNullOrWhiteSpace(contentType))
+ contentType = "image/png";
+
+ return $"data:{contentType};base64,{Convert.ToBase64String(bytes)}";
+ }
+
+ private bool IsAttachmentTableMode(ControlDefinition control)
+ => string.Equals(GetProp(control, "storageMode", "blobField"), "attachmentTable", StringComparison.OrdinalIgnoreCase);
+
+ private FormAttachmentValue? GetPendingAttachmentValue(ControlDefinition control)
+ => Record.TryGetValue(FormAttachmentValue.GetRecordKey(control.ControlId), out object? value) && value is FormAttachmentValue attachment
+ ? attachment
+ : null;
+
+ private static bool TryReadBase64(string? value, out byte[]? bytes)
+ {
+ bytes = null;
+ if (string.IsNullOrWhiteSpace(value))
+ return false;
+
+ try
+ {
+ bytes = Convert.FromBase64String(value);
+ return true;
+ }
+ catch (FormatException)
+ {
+ return false;
+ }
+ }
+
+ private static string FormatByteSize(long bytes)
+ {
+ string[] units = ["B", "KB", "MB", "GB"];
+ double size = bytes;
+ int unit = 0;
+ while (size >= 1024 && unit < units.Length - 1)
+ {
+ size /= 1024;
+ unit++;
+ }
+
+ return unit == 0
+ ? $"{bytes} {units[unit]}"
+ : $"{size:0.#} {units[unit]}";
+ }
+
+ private string GetImageStyle(ControlDefinition control)
+ {
+ string fit = GetProp(control, "fit", "contain");
+ if (fit is not ("contain" or "cover" or "fill" or "scale-down"))
+ fit = "contain";
+
+ return $"object-fit: {fit};";
+ }
+
+ private async Task InvokeCommandButtonAsync(ControlDefinition control)
+ {
+ string commandName = GetProp(control, "commandName", string.Empty);
+ if (string.IsNullOrWhiteSpace(commandName) && !HasControlEventBindings(control, ControlEventKind.OnClick))
+ {
+ await ReportCommandErrorAsync("Command button has no command name.");
+ return;
+ }
+
+ DbCommandDefinition? definition = null;
+ if (!string.IsNullOrWhiteSpace(commandName) && !Commands.TryGetCommand(commandName, out definition))
+ {
+ Dictionary metadata = FormCommandInvocation.BuildControlMetadata(Form, control, "Click");
+ string message = $"Unknown form command '{commandName}'.";
+ DbCallbackDiagnostics.WriteMissingCommandInvocation(commandName, metadata, message);
+ await ReportCommandErrorAsync(message);
+ return;
+ }
+
+ _executingCommandButtons.Add(control.ControlId);
+ await RefreshCommandButtonStateAsync();
+ try
+ {
+ if (!string.IsNullOrWhiteSpace(commandName))
+ {
+ if (definition is null)
+ throw new InvalidOperationException($"Form command '{commandName}' was not resolved.");
+
+ control.Props.Values.TryGetValue("commandArguments", out object? configuredArguments);
+ Dictionary arguments = FormCommandInvocation.BuildArguments(
+ Record,
+ FormCommandInvocation.ReadArgumentsProperty(configuredArguments));
+ Dictionary metadata = FormCommandInvocation.BuildControlMetadata(Form, control, "Click");
+
+ DbCommandResult result = await definition.InvokeAsync(
+ arguments,
+ metadata,
+ EffectiveCallbackPolicy,
+ DbExtensionHostMode.Embedded);
+ if (!result.Succeeded)
+ {
+ string message = string.IsNullOrWhiteSpace(result.Message)
+ ? $"Form command '{definition.Name}' failed."
+ : result.Message;
+ await ReportCommandErrorAsync(message);
+ return;
+ }
+ }
+
+ await InvokeControlEventsAsync(control, ControlEventKind.OnClick);
+ }
+ catch (Exception ex)
+ {
+ string subject = string.IsNullOrWhiteSpace(commandName)
+ ? "Control click command"
+ : $"Form command '{commandName}'";
+ await ReportCommandErrorAsync($"{subject} failed: {ex.Message}");
+ }
+ finally
+ {
+ _executingCommandButtons.Remove(control.ControlId);
+ await RefreshCommandButtonStateAsync();
+ }
+ }
+
+ private async Task RefreshCommandButtonStateAsync()
+ {
+ try
+ {
+ await InvokeAsync(StateHasChanged);
+ }
+ catch (InvalidOperationException ex) when (ex.Message.Contains("render handle", StringComparison.OrdinalIgnoreCase))
+ {
+ // Private unit-test invocations can run before Blazor assigns a render handle.
+ }
+ }
+
+ private Task InvokeFieldControlEventAsync(ControlDefinition control, ControlEventKind eventKind, string? fieldName)
+ => InvokeControlEventsAsync(
+ control,
+ eventKind,
+ BuildFieldEventArguments(control, eventKind, fieldName, GetFieldObjectValue(fieldName), oldValue: null));
+
+ private async Task InvokeControlEventsAsync(
+ ControlDefinition control,
+ ControlEventKind eventKind,
+ IReadOnlyDictionary? runtimeArguments = null)
+ {
+ IReadOnlyList bindings = control.EventBindings ?? [];
+ foreach (ControlEventBinding binding in bindings.Where(binding => binding.Event == eventKind))
+ {
+ Dictionary metadata = FormCommandInvocation.BuildControlMetadata(Form, control, eventKind.ToString());
+
+ if (!string.IsNullOrWhiteSpace(binding.CommandName))
+ {
+ if (!Commands.TryGetCommand(binding.CommandName, out DbCommandDefinition definition))
+ {
+ string message = $"Unknown form command '{binding.CommandName}' for control event '{eventKind}'.";
+ DbCallbackDiagnostics.WriteMissingCommandInvocation(binding.CommandName, metadata, message);
+ await ReportCommandErrorAsync(message);
+ return;
+ }
+
+ Dictionary arguments = FormCommandInvocation.BuildArguments(
+ Record,
+ runtimeArguments,
+ binding.Arguments);
+
+ bool commandFailed = false;
+ string? commandFailureMessage = null;
+ try
+ {
+ DbCommandResult result = await definition.InvokeAsync(
+ arguments,
+ metadata,
+ EffectiveCallbackPolicy,
+ DbExtensionHostMode.Embedded);
+ if (!result.Succeeded)
+ {
+ commandFailed = true;
+ commandFailureMessage = string.IsNullOrWhiteSpace(result.Message)
+ ? $"Control event '{eventKind}' command '{definition.Name}' failed."
+ : result.Message;
+ }
+ }
+ catch (Exception ex)
+ {
+ commandFailed = true;
+ commandFailureMessage = $"Control event '{eventKind}' command '{definition.Name}' failed: {ex.Message}";
+ }
+
+ if (commandFailed)
+ {
+ if (binding.StopOnFailure)
+ {
+ await ReportCommandErrorAsync(commandFailureMessage!);
+ return;
+ }
+
+ if (binding.ActionSequence is null)
+ continue;
+ }
+ }
+ else if (binding.ActionSequence is null)
+ {
+ await ReportCommandErrorAsync($"Control event '{eventKind}' has no command or action sequence.");
+ return;
+ }
+
+ if (binding.ActionSequence is not null)
+ {
+ FormEventDispatchResult actionResult = await FormActionSequenceExecutor.ExecuteAsync(
+ binding.ActionSequence,
+ Commands,
+ Record,
+ binding.Arguments,
+ runtimeArguments,
+ metadata,
+ reusableSequences: Form.ActionSequences,
+ setFieldValue: SetActionFieldValueAsync,
+ showMessage: ReportCommandErrorAsync,
+ executeBuiltInFormAction: OnBuiltInAction,
+ actionRuntime: ActionRuntime,
+ callbackPolicy: EffectiveCallbackPolicy);
+
+ if (!actionResult.Succeeded && binding.StopOnFailure)
+ {
+ await ReportCommandErrorAsync(actionResult.Message ?? $"Control event '{eventKind}' action sequence failed.");
+ return;
+ }
+ }
+ }
+ }
+
+ private static bool HasControlEventBindings(ControlDefinition control, ControlEventKind eventKind)
+ => control.EventBindings?.Any(binding => binding.Event == eventKind) == true;
+
+ private static Dictionary BuildFieldEventArguments(
+ ControlDefinition control,
+ ControlEventKind eventKind,
+ string? fieldName,
+ object? value,
+ object? oldValue)
+ {
+ var arguments = new Dictionary(StringComparer.OrdinalIgnoreCase)
+ {
+ ["controlId"] = control.ControlId,
+ ["controlType"] = control.ControlType,
+ ["event"] = eventKind.ToString(),
+ };
+
+ if (!string.IsNullOrWhiteSpace(fieldName))
+ arguments["fieldName"] = fieldName;
+
+ if (value is not null)
+ arguments["value"] = value;
+
+ if (oldValue is not null)
+ arguments["oldValue"] = oldValue;
+
+ return arguments;
+ }
+
+ private Task ReportCommandErrorAsync(string message)
+ => OnCommandError.HasDelegate ? OnCommandError.InvokeAsync(message) : Task.CompletedTask;
+
+ private async Task SetActionFieldValueAsync(string fieldName, object? value)
+ {
+ if (string.IsNullOrWhiteSpace(fieldName))
+ return;
+
+ string key = Record.Keys.FirstOrDefault(candidate => string.Equals(candidate, fieldName, StringComparison.OrdinalIgnoreCase))
+ ?? fieldName;
+ await BeforeFieldChanged.InvokeAsync(key);
+ Record[key] = value;
+ await OnFieldChanged.InvokeAsync(key);
+ }
+
+ private IReadOnlyList GetTabPages(ControlDefinition control)
+ {
+ if (!control.Props.Values.TryGetValue("tabs", out object? value) || value is null)
+ return [];
+
+ if (value is JsonElement json && json.ValueKind == JsonValueKind.Array)
+ {
+ return json.EnumerateArray()
+ .Select(element => ReadTabPage(element))
+ .Where(tab => tab is not null)
+ .Select(tab => tab!)
+ .ToArray();
+ }
+
+ if (value is IEnumerable items)
+ {
+ return items
+ .Select(item => ReadTabPage(item))
+ .Where(tab => tab is not null)
+ .Select(tab => tab!)
+ .ToArray();
+ }
+
+ return [];
+ }
+
+ private static TabPageInfo? ReadTabPage(object? value)
+ {
+ if (value is null)
+ return null;
+
+ if (value is JsonElement json)
+ {
+ if (json.ValueKind != JsonValueKind.Object)
+ return null;
+
+ string id = json.TryGetProperty("id", out JsonElement idElement) ? ReadJsonText(idElement) : string.Empty;
+ string label = json.TryGetProperty("label", out JsonElement labelElement) ? ReadJsonText(labelElement) : id;
+ return string.IsNullOrWhiteSpace(id) ? null : new TabPageInfo(id, string.IsNullOrWhiteSpace(label) ? id : label);
+ }
+
+ if (value is IReadOnlyDictionary readOnly)
+ return ReadTabPage(readOnly);
+
+ if (value is IDictionary dictionary)
+ return ReadTabPage(dictionary);
+
+ return null;
+ }
+
+ private static TabPageInfo? ReadTabPage(IReadOnlyDictionary dictionary)
+ {
+ string id = ReadDictionaryText(dictionary, "id");
+ if (string.IsNullOrWhiteSpace(id))
+ return null;
+
+ string label = ReadDictionaryText(dictionary, "label");
+ return new TabPageInfo(id, string.IsNullOrWhiteSpace(label) ? id : label);
+ }
+
+ private TabPageInfo GetActiveTabPage(ControlDefinition control, IReadOnlyList tabs)
+ {
+ if (_activeTabs.TryGetValue(control.ControlId, out string? activeId))
+ {
+ TabPageInfo? active = tabs.FirstOrDefault(tab => string.Equals(tab.Id, activeId, StringComparison.Ordinal));
+ if (active is not null)
+ return active;
+ }
+
+ _activeTabs[control.ControlId] = tabs[0].Id;
+ return tabs[0];
+ }
+
+ private void SetActiveTab(string controlId, string tabId)
+ => _activeTabs[controlId] = tabId;
+
+ private string GetTabButtonClass(string activeTabId, string tabId)
+ => string.Equals(activeTabId, tabId, StringComparison.Ordinal)
+ ? "fr-tab-button active"
+ : "fr-tab-button";
+
+ private FormDefinition BuildTabChildForm(ControlDefinition tabControl, string tabId)
+ {
+ var childControls = Form.Controls
+ .Where(control => IsTabChildControl(control, tabControl.ControlId, tabId))
+ .ToArray();
+
+ return Form with { Controls = childControls };
}
+ private static double GetTabChildCanvasWidth(ControlDefinition tabControl)
+ => Math.Max(24, tabControl.Rect.Width - 24);
+
+ private double GetTabChildCanvasHeight(ControlDefinition tabControl, string tabId)
+ {
+ double designHeight = Form.Controls
+ .Where(control => IsTabChildControl(control, tabControl.ControlId, tabId))
+ .Select(control => control.Rect.Y + control.Rect.Height + 24)
+ .DefaultIfEmpty(0)
+ .Max();
+ double tabPageHeight = Math.Max(16, tabControl.Rect.Height - 56);
+
+ return Math.Max(designHeight, tabPageHeight);
+ }
+
+ private static bool IsTabChildControl(ControlDefinition control, string parentControlId, string tabId)
+ => TryGetControlProp(control, "parentControlId", out string configuredParentId)
+ && string.Equals(configuredParentId, parentControlId, StringComparison.Ordinal)
+ && TryGetControlProp(control, "parentTabId", out string configuredTabId)
+ && string.Equals(configuredTabId, tabId, StringComparison.Ordinal);
+
+ private static bool TryGetControlProp(ControlDefinition control, string key, out string value)
+ {
+ value = string.Empty;
+ if (!control.Props.Values.TryGetValue(key, out object? raw) || raw is null)
+ return false;
+
+ if (raw is JsonElement json)
+ raw = json.ValueKind == JsonValueKind.String ? json.GetString() : json.ToString();
+
+ value = raw?.ToString() ?? string.Empty;
+ return !string.IsNullOrWhiteSpace(value);
+ }
+
+ private static string ReadDictionaryText(IReadOnlyDictionary dictionary, string key)
+ {
+ if (!dictionary.TryGetValue(key, out object? value) || value is null)
+ return string.Empty;
+
+ if (value is JsonElement json)
+ return ReadJsonText(json);
+
+ return value.ToString() ?? string.Empty;
+ }
+
+ private static string ReadJsonText(JsonElement value)
+ => value.ValueKind == JsonValueKind.String
+ ? value.GetString() ?? string.Empty
+ : value.ToString();
+
+ private string BuildSubformKey(ControlDefinition control, object? parentValue)
+ => $"{control.ControlId}:{parentValue}";
+
+ private static string BuildSubformFilterExpression(string foreignKeyField)
+ => $"[{foreignKeyField}] = @parentValue";
+
+ private static IReadOnlyDictionary BuildSubformFilterParameters(object? parentValue)
+ => new Dictionary(StringComparer.OrdinalIgnoreCase)
+ {
+ ["parentValue"] = parentValue,
+ };
+
private FormFieldDefinition? GetFieldDefinition(string? fieldName)
=> fieldName is null
? null
: TableDefinition?.Fields.FirstOrDefault(field => string.Equals(field.Name, fieldName, StringComparison.OrdinalIgnoreCase));
+ private sealed record TabPageInfo(string Id, string Label);
+
private static int GetTabIndex(ControlDefinition c)
{
if (c.Props.Values.TryGetValue("tabIndex", out var val))
@@ -260,10 +1631,12 @@
return 0;
}
- private static string GetProp(ControlDefinition c, string key, string fallback)
+ private string GetProp(ControlDefinition c, string key, string fallback)
{
- if (c.Props.Values.TryGetValue(key, out var val) && val is string s)
+ if (TryGetEffectiveProperty(c, key, out object? val) && val is string s)
return s;
+ if (val is not null && key is "text" or "placeholder")
+ return val.ToString() ?? fallback;
return fallback;
}
@@ -279,11 +1652,127 @@
return [];
}
- private static bool GetBoolProp(ControlDefinition c, string key)
+ private static List GetDataGridVisibleColumns(ControlDefinition control, FormTableDefinition? tableDefinition)
{
- if (c.Props.Values.TryGetValue(key, out var val) && val is bool b)
- return b;
- return false;
+ List configuredColumns = GetListProp(control, "visibleColumns");
+ if (configuredColumns.Count > 0 || tableDefinition is null)
+ return configuredColumns;
+
+ return tableDefinition.Fields
+ .Select(field => field.Name)
+ .ToList();
+ }
+
+ private ControlFilterState? GetControlFilter(string controlId)
+ => ControlFilters?.TryGetValue(controlId, out ControlFilterState? filter) == true
+ ? filter
+ : null;
+
+ private bool IsControlVisible(ControlDefinition c)
+ => GetBoolProp(c, "visible", fallback: true);
+
+ private bool IsControlEnabled(ControlDefinition c)
+ => GetBoolProp(c, "enabled", fallback: true);
+
+ private bool IsControlReadOnly(ControlDefinition c)
+ => GetBoolProp(c, "readOnly", fallback: false);
+
+ private bool GetBoolProp(ControlDefinition c, string key, bool fallback = false)
+ => TryGetEffectiveProperty(c, key, out object? value)
+ ? ReadBoolean(value, fallback)
+ : fallback;
+
+ private int GetIntProp(ControlDefinition c, string key, int fallback)
+ => TryGetEffectiveProperty(c, key, out object? value)
+ ? ReadInteger(value, fallback)
+ : fallback;
+
+ private double GetDoubleProp(ControlDefinition c, string key, double fallback)
+ => TryGetEffectiveProperty(c, key, out object? value)
+ ? ReadDouble(value, fallback)
+ : fallback;
+
+ private long GetLongProp(ControlDefinition c, string key, long fallback)
+ => TryGetEffectiveProperty(c, key, out object? value)
+ ? ReadLong(value, fallback)
+ : fallback;
+
+ private static int ReadInteger(object? value, int fallback)
+ {
+ long parsed = ReadLong(value, fallback);
+ return parsed > int.MaxValue || parsed < int.MinValue
+ ? fallback
+ : (int)parsed;
+ }
+
+ private static long ReadLong(object? value, long fallback)
+ {
+ return value switch
+ {
+ int i => i,
+ long l => l,
+ double d => (long)d,
+ decimal m => (long)m,
+ JsonElement json when json.ValueKind == JsonValueKind.Number && json.TryGetInt64(out long l) => l,
+ _ when long.TryParse(value?.ToString(), NumberStyles.Integer, CultureInfo.InvariantCulture, out long parsed) => parsed,
+ _ => fallback,
+ };
+ }
+
+ private static double ReadDouble(object? value, double fallback)
+ {
+ return value switch
+ {
+ int i => i,
+ long l => l,
+ float f => f,
+ double d => d,
+ decimal m => (double)m,
+ JsonElement json when json.ValueKind == JsonValueKind.Number && json.TryGetDouble(out double d) => d,
+ JsonElement json when json.ValueKind == JsonValueKind.String && double.TryParse(json.GetString(), NumberStyles.Float, CultureInfo.InvariantCulture, out double parsed) => parsed,
+ _ when double.TryParse(value?.ToString(), NumberStyles.Float, CultureInfo.InvariantCulture, out double parsed) => parsed,
+ _ => fallback,
+ };
+ }
+
+ private bool TryGetEffectiveProperty(ControlDefinition control, string key, out object? value)
+ {
+ bool found = control.Props.Values.TryGetValue(key, out value);
+
+ foreach (ControlRuleDefinition rule in Form.Rules ?? [])
+ {
+ if (!FormActionConditionEvaluator.TryEvaluate(
+ rule.Condition,
+ Record,
+ bindingArguments: null,
+ runtimeArguments: null,
+ stepArguments: null,
+ out bool shouldApply,
+ out _) ||
+ !shouldApply)
+ {
+ continue;
+ }
+
+ foreach (ControlRuleEffect effect in rule.Effects)
+ {
+ if (string.Equals(effect.ControlId, control.ControlId, StringComparison.OrdinalIgnoreCase) &&
+ string.Equals(effect.Property, key, StringComparison.OrdinalIgnoreCase))
+ {
+ value = effect.Value;
+ found = true;
+ }
+ }
+ }
+
+ if (ControlPropertyOverrides?.TryGetValue(control.ControlId, out IReadOnlyDictionary? overrides) == true &&
+ overrides.TryGetValue(key, out object? overrideValue))
+ {
+ value = overrideValue;
+ found = true;
+ }
+
+ return found;
}
private static object? ParseNumber(object? value)
diff --git a/src/CSharpDB.Admin.Forms/Components/Designer/LayersPanel.razor b/src/CSharpDB.Admin.Forms/Components/Designer/LayersPanel.razor
index d3e57a54..09cb5ece 100644
--- a/src/CSharpDB.Admin.Forms/Components/Designer/LayersPanel.razor
+++ b/src/CSharpDB.Admin.Forms/Components/Designer/LayersPanel.razor
@@ -1,4 +1,6 @@
@using CSharpDB.Admin.Forms.Components.Designer
+@using CSharpDB.Admin.Forms.Contracts
+@using CSharpDB.Admin.Forms.Models
@implements IDisposable
+
- @if (_selected.ControlType is "label" or "checkbox")
+ @if (_selected.ControlType is "label" or "checkbox" or "toggleButton")
{
@foreach (var ch in radioChoices)
@@ -100,14 +173,53 @@
name="@($"radio_{c.ControlId}")"
value="@val"
checked="@IsRadioChoiceSelected(fieldName, val)"
+ disabled="@(!IsControlEnabled(c) || IsControlReadOnly(c))"
tabindex="@tabIdx"
- @onchange="@(e => SetRadioFieldValue(fieldName, val))" />
+ @onfocus="@(() => InvokeFieldControlEventAsync(c, ControlEventKind.OnGotFocus, fieldName))"
+ @onblur="@(() => InvokeFieldControlEventAsync(c, ControlEventKind.OnLostFocus, fieldName))"
+ @onchange="@(e => SetRadioFieldValueAsync(c, fieldName, val))" />
@ch.Label
}
}
break;
+ case "optionGroup":
+ var optionChoices = GetControlChoices(c, fieldName);
+ var orientation = GetProp(c, "orientation", "vertical");
+ var buttonStyle = GetBoolProp(c, "buttonStyle") || string.Equals(GetProp(c, "buttonStyle", ""), "buttons", StringComparison.OrdinalIgnoreCase);
+
+ break;
+ case "toggleButton":
+ var toggleOn = IsToggleButtonOn(c, fieldName);
+
+ break;
case "computed":
var computedValue = GetFieldValue(fieldName);
var computedFormat = GetProp(c, "format", "");
@@ -120,31 +232,189 @@
class="fr-input fr-computed"
value="@displayValue"
readonly
- tabindex="@tabIdx" />
+ tabindex="@tabIdx"
+ @onfocus="@(() => InvokeFieldControlEventAsync(c, ControlEventKind.OnGotFocus, fieldName))"
+ @onblur="@(() => InvokeFieldControlEventAsync(c, ControlEventKind.OnLostFocus, fieldName))" />
+ break;
+ case "commandButton":
+ var isExecuting = _executingCommandButtons.Contains(c.ControlId);
+
+ break;
+ case "tabControl":
+ var tabPages = GetTabPages(c);
+ @if (tabPages.Count == 0)
+ {
+ Tab control has no pages.
+ }
+ else
+ {
+ var activeTab = GetActiveTabPage(c, tabPages);
+ var childForm = BuildTabChildForm(c, activeTab.Id);
+
+
+
+ }
+ break;
+ case "subform":
+ var subformId = GetProp(c, "formId", "");
+ var subformParentField = GetProp(c, "parentKeyField", "");
+ var subformForeignField = GetProp(c, "foreignKeyField", "");
+ var subformParentValue = GetFieldObjectValue(subformParentField);
+ @if (string.IsNullOrWhiteSpace(subformId) ||
+ string.IsNullOrWhiteSpace(subformParentField) ||
+ string.IsNullOrWhiteSpace(subformForeignField))
+ {
+
+ @if (childForm.Controls.Count == 0)
+ {
+
+ No controls on this tab.
+ }
+ else
+ {
+ Subform not configured.
+ }
+ else if (subformParentValue is null || string.IsNullOrWhiteSpace(subformParentValue.ToString()))
+ {
+ Save the parent record first to see child records.
+ }
+ else
+ {
+
+
+ }
+ break;
+ case "attachment":
+
+ break;
+ case "image":
+ var imageSrc = GetImageDataUrl(c, fieldName);
+
+ @if (!string.IsNullOrWhiteSpace(imageSrc))
+ {
+ 
+ }
+ else
+ {
+
break;
case "datagrid":
+ var dgMode = GetProp(c, "dataGridMode", "related");
+ var dgIsStandalone = string.Equals(dgMode, "standalone", StringComparison.OrdinalIgnoreCase);
var dgChildTable = GetProp(c, "childTable", "");
var dgFkField = GetProp(c, "foreignKeyField", "");
var dgPkField = GetProp(c, "parentKeyField", "");
- var dgColumns = GetListProp(c, "visibleColumns");
+ var dgTableDefinition = ChildFormTableDefinitions?.GetValueOrDefault(dgChildTable);
+ var dgColumns = GetDataGridVisibleColumns(c, dgTableDefinition);
var dgAllowAdd = GetBoolProp(c, "allowAdd");
var dgAllowEdit = GetBoolProp(c, "allowEdit");
var dgAllowDelete = GetBoolProp(c, "allowDelete");
var parentPkValue = GetFieldObjectValue(dgPkField);
+ var dgFilter = GetControlFilter(c.ControlId);
- @if (!string.IsNullOrEmpty(dgChildTable) && !string.IsNullOrEmpty(dgFkField) && parentPkValue is not null)
+ @if (!string.IsNullOrEmpty(dgChildTable) && dgIsStandalone)
+ {
+ No image
+ }
+
+
+ Save the parent record first to see child records.
}
@@ -169,9 +439,10 @@
Child Tabs not configured.
}
break;
- default:
- [@c.ControlType]
- break;
+ default:
+ [@c.ControlType]
+ break;
+ }
}
@if (errorMsg is not null)
{
@@ -191,6 +462,304 @@
[Parameter] public Dictionary
@@ -36,6 +38,7 @@
@code {
[CascadingParameter] public DesignerState State { get; set; } = default!;
+ [Inject] public IFormControlRegistry ControlRegistry { get; set; } = DefaultFormControlRegistry.Instance;
private int _dragStartIndex = -1;
private int _dragOverIndex = -1;
@@ -76,32 +79,27 @@
State.SelectControl(controlId, e.ShiftKey);
}
- private static string GetLabel(CSharpDB.Admin.Forms.Models.ControlDefinition c)
+ private string GetLabel(ControlDefinition c)
{
// Prefer binding field name, then text prop, then control type
if (c.Binding?.FieldName is { Length: > 0 } fieldName)
return fieldName;
if (c.Props.Values.TryGetValue("text", out var textVal) && textVal is string s && s.Length > 0)
return s;
- return c.ControlType;
+ return GetControlDisplayName(c.ControlType);
}
- private static string GetTypeIcon(string controlType) => controlType switch
+ private string GetTypeIcon(string controlType)
{
- "label" => "A",
- "text" => "\u2328",
- "textarea" => "\u2263",
- "number" => "#",
- "date" => "\U0001F4C5",
- "checkbox" => "\u2611",
- "radio" => "\u25C9",
- "select" => "\u25BE",
- "lookup" => "\U0001F50D",
- "datagrid" => "\u2637",
- "childtabs" => "\u2630",
- "computed" => "\u03A3",
- _ => "?"
- };
+ return ControlRegistry.TryGetControl(controlType, out FormControlDescriptor descriptor)
+ ? descriptor.IconText
+ : "?";
+ }
+
+ private string GetControlDisplayName(string controlType)
+ => ControlRegistry.TryGetControl(controlType, out FormControlDescriptor descriptor)
+ ? descriptor.DisplayName
+ : controlType;
private static string LayerRowClass(bool selected, bool dragOver)
{
diff --git a/src/CSharpDB.Admin.Forms/Components/Designer/MacroValidationPanel.razor b/src/CSharpDB.Admin.Forms/Components/Designer/MacroValidationPanel.razor
new file mode 100644
index 00000000..bc2ed172
--- /dev/null
+++ b/src/CSharpDB.Admin.Forms/Components/Designer/MacroValidationPanel.razor
@@ -0,0 +1,45 @@
+@using CSharpDB.Admin.Forms.Contracts
+@using CSharpDB.Admin.Forms.Models
+@using CSharpDB.Admin.Forms.Services
+
+@if (_issues.Count > 0)
+{
+ _issues = [];
+
+ protected override void OnParametersSet()
+ {
+ FormActionValidationResult result = FormActionManifestValidator.Validate(
+ Form,
+ new FormActionValidationOptions(
+ RuntimeCapabilities: FormActionRuntimeCapabilities.RenderedForm,
+ Schema: Schema));
+ _issues = result.Issues;
+ }
+
+ private string GetSummaryText()
+ {
+ int errors = _issues.Count(issue => issue.Severity == FormActionValidationSeverity.Error);
+ int warnings = _issues.Count - errors;
+ if (errors > 0 && warnings > 0)
+ return $"{errors} macro error(s), {warnings} warning(s)";
+
+ return errors > 0
+ ? $"{errors} macro error(s)"
+ : $"{warnings} macro warning(s)";
+ }
+}
diff --git a/src/CSharpDB.Admin.Forms/Components/Designer/PropertyInspector.razor b/src/CSharpDB.Admin.Forms/Components/Designer/PropertyInspector.razor
index 63540d7b..ee78c33d 100644
--- a/src/CSharpDB.Admin.Forms/Components/Designer/PropertyInspector.razor
+++ b/src/CSharpDB.Admin.Forms/Components/Designer/PropertyInspector.razor
@@ -1,7 +1,13 @@
+@using System.Globalization
+@using System.Text.Json
@using CSharpDB.Admin.Forms.Models
@using CSharpDB.Admin.Forms.Components.Designer
@using CSharpDB.Admin.Forms.Contracts
+@using CSharpDB.Admin.Forms.Serialization
+@using CSharpDB.Primitives
@inject ISchemaProvider SchemaProvider
+@inject DbCommandRegistry CommandRegistry
+@inject IFormRepository FormRepository
@implements IDisposable
+
+ @GetSummaryText()
+
+}
+
+@code {
+ [Parameter, EditorRequired] public FormDefinition Form { get; set; } = default!;
+ [Parameter] public FormTableDefinition? Schema { get; set; }
+
+ private IReadOnlyList-
+ @foreach (FormActionValidationIssue issue in _issues.Take(6))
+ {
+
- @issue.Message + } +
@@ -16,9 +22,48 @@
}
else
{
-
+ @if (State.SelectedIds.Count <= 1)
+ {
+ Select a control to edit its properties
+Form properties
}
+
+ }
+ Form
+
+
+
+
+
+
+
+ @(string.IsNullOrWhiteSpace(State.TableName) ? "No source selected" : State.TableName)
+
+
+ Events
+
+
+ Reusable Actions
+
+
+ Rules
+
+
}
else
{
@@ -27,18 +72,14 @@
Validation
+
@@ -47,6 +88,13 @@
+
+
Events
+ Position & Size
@@ -73,9 +121,66 @@
@onchange="@(e => OnRectChanged(e, RectPart.H))" />
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ Text
@@ -87,7 +192,7 @@
Input
@@ -112,6 +217,85 @@
+
+ }
+
+ @if (_selected.ControlType == "toggleButton")
+ {
+ Choices
+
+
+
+ @if (!string.IsNullOrWhiteSpace(_optionsError))
+ {
+
+ @if (_selected.ControlType == "comboBox")
+ {
+ @_optionsError
+ }
+
+
+
+
+ }
+ @if (_selected.ControlType == "listBox")
+ {
+
+
+
+
+ @if (GetBoolProp(PropMultiSelect))
+ {
+
+
+
+
+ }
+
+
+
+
+ }
+ @if (_selected.ControlType == "optionGroup")
+ {
+
+
+
+
+
+
+
+
+ }
+
+
+ }
+
@if (_selected.Binding is not null)
{
Toggle Values
+
+
+
+
+
+
+
+
+
@@ -152,9 +336,25 @@
@onchange="@(e => OnPropChanged(PropTabIndex, ParseLong(e.Value)))" />
+
+ }
+ else if (IsTabOrderControl(_selected))
+ {
+ Validation
+
+
}
- @if (_selected.ControlType == "lookup")
+ @if (_selected.ControlType is "lookup" or "comboBox" or "listBox" or "optionGroup")
{
Keyboard
+
+
+
+
+ Lookup Configuration
@@ -183,6 +383,12 @@
}
+
+
+
+
+
+
Formula Configuration
-
+
+ @if (_showFormulaHelper)
+ {
+
+
+
+
+
+ @if (_sourceTableDef?.Fields.Count > 0)
+ {
+
+ }
+ @foreach (FormFieldDefinition field in _sourceTableDef.Fields.Where(static field => field.DataType != FieldDataType.Blob).Take(12))
+ {
+
+ }
+
+ }
+ @foreach (FormulaFunctionGroup group in GetFormulaFunctionGroups())
+ {
+
+
+ }
+ @if (GetFormulaFunctionGroups().Count == 0)
+ {
+ @group.Category
+ @foreach (FormulaFunctionDescriptor function in group.Functions)
+ {
+
+
+
+
+ }
+ No matching functions.
+ }
+
- Field:
- Aggregate:
+ }
+
+ @if (_selected.ControlType == "commandButton")
+ {
+ =A * B + C- Aggregate:
=SUM(Table.Field)
+
+ Examples:
+
+ =Nz(Quantity, 0) * Nz(UnitPrice, 0)+
=DateDiff('d', OrderDate, Date())
+
+
}
@@ -223,11 +550,18 @@
@if (_selected.ControlType == "datagrid")
{
Command Button
+
+
+
+
+
+
+ @if (RegisteredCommands.Count > 0)
+ {
+
+ }
+ else
+ {
+
+ }
+
+
+
+
+ @if (!string.IsNullOrWhiteSpace(_commandArgumentError))
+ {
+
+ @_commandArgumentError
+ }
+
+
+
-
+
+@code {
+ [CascadingParameter] public DesignerState State { get; set; } = default!;
+ [Inject] public IFormControlRegistry ControlRegistry { get; set; } = DefaultFormControlRegistry.Instance;
+
+ private ControlDefinition? _selected;
+
+ // Property name constants to avoid string literals in Razor attributes
+ private const string PropText = "text";
+ private const string PropPlaceholder = "placeholder";
+ private const string PropMaxLength = "maxLength";
+ private const string PropReadOnly = "readOnly";
+ private const string PropTabIndex = "tabIndex";
+ private const string PropAnchorLeft = "anchorLeft";
+ private const string PropAnchorTop = "anchorTop";
+ private const string PropAnchorRight = "anchorRight";
+ private const string PropAnchorBottom = "anchorBottom";
+ private const string PropMinWidth = "minWidth";
+ private const string PropMinHeight = "minHeight";
+ private const string PropResizeMode = "resizeMode";
+ private const string PropDataGridMode = "dataGridMode";
+ private const string PropChildTable = "childTable";
+ private const string PropForeignKeyName = "foreignKeyName";
+ private const string PropForeignKeyField = "foreignKeyField";
+ private const string PropParentKeyField = "parentKeyField";
+ private const string PropVisibleColumns = "visibleColumns";
+ private const string PropAllowAdd = "allowAdd";
+ private const string PropAllowEdit = "allowEdit";
+ private const string PropAllowDelete = "allowDelete";
+ private const string PropLookupTable = "lookupTable";
+ private const string PropDisplayField = "displayField";
+ private const string PropValueField = "valueField";
+ private const string PropDisplayFields = "displayFields";
+ private const string PropRowLimit = "rowLimit";
+ private const string PropOptions = "options";
+ private const string PropAllowCustomValue = "allowCustomValue";
+ private const string PropVisibleRows = "visibleRows";
+ private const string PropMultiSelect = "multiSelect";
+ private const string PropMultiValueDelimiter = "multiValueDelimiter";
+ private const string PropOrientation = "orientation";
+ private const string PropButtonStyle = "buttonStyle";
+ private const string PropTrueValue = "trueValue";
+ private const string PropFalseValue = "falseValue";
+ private const string PropTabs = "tabs";
+ private const string PropParentControlId = "parentControlId";
+ private const string PropParentTabId = "parentTabId";
+ private const string PropFormId = "formId";
+ private const string PropShowToolbar = "showToolbar";
+ private const string PropShowRecordList = "showRecordList";
+ private const string PropFileNameField = "fileNameField";
+ private const string PropContentTypeField = "contentTypeField";
+ private const string PropFileSizeField = "fileSizeField";
+ private const string PropStorageMode = "storageMode";
+ private const string PropAttachmentTable = "attachmentTable";
+ private const string PropAttachmentForeignKeyField = "attachmentForeignKeyField";
+ private const string PropAttachmentBlobField = "attachmentBlobField";
+ private const string PropAttachmentFileNameField = "attachmentFileNameField";
+ private const string PropAttachmentContentTypeField = "attachmentContentTypeField";
+ private const string PropAttachmentFileSizeField = "attachmentFileSizeField";
+ private const string PropAttachmentControlIdField = "attachmentControlIdField";
+ private const string PropAccept = "accept";
+ private const string PropMaxFileBytes = "maxFileBytes";
+ private const string PropAlt = "alt";
+ private const string PropFit = "fit";
+ private const string PropFormula = "formula";
+ private const string PropFormat = "format";
+ private const string PropCommandName = "commandName";
+ private const string PropCommandArguments = "commandArguments";
private enum RectPart { X, Y, W, H }
+ private sealed record FormulaFunctionGroup(string Category, IReadOnlyList Functions);
+
// DataGrid configuration state
private IReadOnlyList? _availableTables;
+ private IReadOnlyList? _availableForms;
private string? _loadedSourceTableName;
private FormTableDefinition? _sourceTableDef;
private FormTableDefinition? _childTableDef;
@@ -400,11 +1034,26 @@
// ChildTabs configuration state
private List _currentTabs = [];
+ private string? _loadedCommandArgumentControlId;
+ private string _commandArgumentText = string.Empty;
+ private string? _commandArgumentError;
+ private string? _loadedOptionsControlId;
+ private string _optionsText = string.Empty;
+ private string? _optionsError;
+ private string? _loadedTabPagesControlId;
+ private string _tabPagesText = string.Empty;
+ private string? _tabPagesError;
+ private bool _showFormulaHelper;
+ private string _formulaFunctionQuery = string.Empty;
+ private string _formulaFunctionCategory = string.Empty;
+
+ private IReadOnlyList RegisteredCommands => CommandRegistry.Commands.ToList();
protected override async Task OnInitializedAsync()
{
State.OnChange += OnStateChanged;
_availableTables = await SchemaProvider.ListTableNamesAsync();
+ _availableForms = await FormRepository.ListAsync();
await RefreshSourceTableDefinitionAsync();
}
@@ -439,8 +1088,8 @@
await InvokeAsync(StateHasChanged);
}
- // Load lookup table def when a lookup control is selected
- if (_selected?.ControlType == "lookup" && _selected != prev)
+ // Load lookup table def when a lookup-backed choice control is selected
+ if (_selected != prev && IsLookupChoiceControl(_selected?.ControlType))
{
var lookupTable = GetProp(PropLookupTable, "");
if (!string.IsNullOrEmpty(lookupTable))
@@ -460,9 +1109,37 @@
if (_selected?.ControlType != "childtabs")
_currentTabs = [];
- if (_selected?.ControlType != "lookup")
+ if (_selected?.ControlType is not ("lookup" or "comboBox" or "listBox" or "optionGroup"))
_lookupTableDef = null;
+ if (_selected?.ControlType != "commandButton")
+ {
+ _loadedCommandArgumentControlId = null;
+ _commandArgumentText = string.Empty;
+ _commandArgumentError = null;
+ }
+
+ if (_selected?.ControlType is not ("select" or "comboBox" or "listBox" or "optionGroup"))
+ {
+ _loadedOptionsControlId = null;
+ _optionsText = string.Empty;
+ _optionsError = null;
+ }
+
+ if (_selected?.ControlType != "tabControl")
+ {
+ _loadedTabPagesControlId = null;
+ _tabPagesText = string.Empty;
+ _tabPagesError = null;
+ }
+
+ if (_selected?.ControlType != "computed")
+ {
+ _showFormulaHelper = false;
+ _formulaFunctionQuery = string.Empty;
+ _formulaFunctionCategory = string.Empty;
+ }
+
await InvokeAsync(StateHasChanged);
}
@@ -475,21 +1152,288 @@
private bool GetBoolProp(string key)
{
- if (_selected?.Props.Values.TryGetValue(key, out var val) == true && val is bool b)
- return b;
+ if (_selected?.Props.Values.TryGetValue(key, out var val) == true)
+ return ReadBool(val, false);
return false;
}
+ private FormControlDescriptor? GetSelectedDescriptor()
+ => _selected is not null && ControlRegistry.TryGetControl(_selected.ControlType, out FormControlDescriptor descriptor)
+ ? descriptor
+ : null;
+
+ private IReadOnlyList GetTypeDropdownControls()
+ => ControlRegistry.Controls;
+
+ private bool IsRegisteredControlType(string controlType)
+ => ControlRegistry.TryGetControl(controlType, out _);
+
+ private bool IsTabOrderControl(ControlDefinition control)
+ => ControlRegistry.TryGetControl(control.ControlType, out FormControlDescriptor descriptor)
+ ? descriptor.ParticipatesInTabOrder
+ : control.ControlType is not ("label" or "datagrid" or "childtabs" or "tabControl" or "subform");
+
+ private string GetRegisteredPropertyValue(FormControlPropertyDescriptor property)
+ {
+ if (_selected?.Props.Values.TryGetValue(property.Name, out object? value) == true && value is not null)
+ return value.ToString() ?? string.Empty;
+
+ return property.DefaultValue?.ToString() ?? string.Empty;
+ }
+
+ private bool GetRegisteredBoolPropertyValue(FormControlPropertyDescriptor property)
+ {
+ if (_selected?.Props.Values.TryGetValue(property.Name, out object? value) == true)
+ return ReadBool(value, ReadBool(property.DefaultValue, false));
+
+ return ReadBool(property.DefaultValue, false);
+ }
+
+ private void OnRegisteredPropertyChanged(FormControlPropertyDescriptor property, object? rawValue)
+ {
+ object? value = property.Editor switch
+ {
+ FormControlPropertyEditor.Checkbox => rawValue is bool b && b,
+ FormControlPropertyEditor.Number => ParseScalar(rawValue),
+ _ => rawValue?.ToString(),
+ };
+
+ OnPropChanged(property.Name, value);
+ }
+
+ private Dictionary GetPropertyEditorParameters(FormControlDescriptor descriptor)
+ => new()
+ {
+ ["Context"] = new FormControlPropertyContext(
+ _selected!,
+ descriptor,
+ _sourceTableDef,
+ _availableTables,
+ _availableForms,
+ (key, value) =>
+ {
+ OnPropChanged(key, value);
+ return Task.CompletedTask;
+ }),
+ };
+
+ private bool IsAttachmentTableMode()
+ => string.Equals(GetProp(PropStorageMode, "blobField"), "attachmentTable", StringComparison.OrdinalIgnoreCase);
+
+ private bool GetAnchorProp(string key, bool fallback)
+ {
+ if (_selected?.Props.Values.TryGetValue(key, out var val) == true)
+ return ReadBool(val, fallback);
+ return fallback;
+ }
+
private void OnPropChanged(string key, object? value)
{
if (_selected is null) return;
State.UpdateControlProp(_selected.ControlId, key, value);
}
+ private void ToggleFormulaHelper()
+ {
+ _showFormulaHelper = !_showFormulaHelper;
+ }
+
+ private void OnFormulaCategoryChanged(ChangeEventArgs e)
+ {
+ _formulaFunctionCategory = e.Value?.ToString() ?? string.Empty;
+ }
+
+ private void OnFormulaQueryChanged(ChangeEventArgs e)
+ {
+ _formulaFunctionQuery = e.Value?.ToString() ?? string.Empty;
+ }
+
+ private IReadOnlyList GetFormulaFunctionGroups()
+ {
+ IEnumerable functions = FormulaFunctionCatalog.AllFunctions;
+ if (!string.IsNullOrWhiteSpace(_formulaFunctionCategory))
+ {
+ functions = functions.Where(function =>
+ string.Equals(function.Category, _formulaFunctionCategory, StringComparison.OrdinalIgnoreCase));
+ }
+
+ if (!string.IsNullOrWhiteSpace(_formulaFunctionQuery))
+ {
+ string query = _formulaFunctionQuery.Trim();
+ functions = functions.Where(function => FormulaFunctionMatches(function, query));
+ }
+
+ return functions
+ .GroupBy(static function => function.Category, StringComparer.OrdinalIgnoreCase)
+ .Select(static group => new FormulaFunctionGroup(group.Key, group.ToArray()))
+ .ToArray();
+ }
+
+ private static bool FormulaFunctionMatches(FormulaFunctionDescriptor function, string query)
+ => function.Name.Contains(query, StringComparison.OrdinalIgnoreCase)
+ || function.Signature.Contains(query, StringComparison.OrdinalIgnoreCase)
+ || function.Description.Contains(query, StringComparison.OrdinalIgnoreCase)
+ || function.Example.Contains(query, StringComparison.OrdinalIgnoreCase);
+
+ private void InsertFormulaFunction(FormulaFunctionDescriptor function)
+ {
+ AppendFormulaText(function.InsertText);
+ }
+
+ private void UseFormulaExample(FormulaFunctionDescriptor function)
+ {
+ OnPropChanged(PropFormula, function.Example);
+ }
+
+ private void InsertFormulaField(string fieldName)
+ {
+ if (string.IsNullOrWhiteSpace(fieldName))
+ return;
+
+ AppendFormulaText($"[{fieldName}]");
+ }
+
+ private void AppendFormulaText(string text)
+ {
+ if (_selected is null || string.IsNullOrWhiteSpace(text))
+ return;
+
+ string current = GetProp(PropFormula, string.Empty).TrimEnd();
+ string updated = current switch
+ {
+ "" => $"={text}",
+ "=" => $"={text}",
+ _ when current.StartsWith('=') => $"{current} {text}",
+ _ => $"={current} {text}",
+ };
+
+ OnPropChanged(PropFormula, updated);
+ }
+
+ private string GetAnchorPreset()
+ {
+ var anchors = GetCurrentAnchors();
+
+ return anchors switch
+ {
+ (true, true, false, false) => "topLeft",
+ (false, true, true, false) => "topRight",
+ (true, false, false, true) => "bottomLeft",
+ (false, false, true, true) => "bottomRight",
+ (true, true, true, false) => "stretchAcross",
+ (true, true, false, true) => "stretchDown",
+ (true, true, true, true) => "stretchBoth",
+ _ => "custom",
+ };
+ }
+
+ private void OnAnchorPresetChanged(ChangeEventArgs e)
+ {
+ if (_selected is null) return;
+
+ string preset = e.Value?.ToString() ?? string.Empty;
+ if (preset == "custom")
+ return;
+
+ var anchors = preset switch
+ {
+ "topLeft" => (Left: true, Top: true, Right: false, Bottom: false),
+ "topRight" => (Left: false, Top: true, Right: true, Bottom: false),
+ "bottomLeft" => (Left: true, Top: false, Right: false, Bottom: true),
+ "bottomRight" => (Left: false, Top: false, Right: true, Bottom: true),
+ "stretchAcross" => (Left: true, Top: true, Right: true, Bottom: false),
+ "stretchDown" => (Left: true, Top: true, Right: false, Bottom: true),
+ "stretchBoth" => (Left: true, Top: true, Right: true, Bottom: true),
+ _ => GetCurrentAnchors(),
+ };
+
+ UpdateAnchorProps(anchors);
+ }
+
+ private void OnAnchorChanged(string key, object? value)
+ {
+ if (_selected is null) return;
+
+ var anchors = GetCurrentAnchors();
+ bool left = anchors.Left;
+ bool top = anchors.Top;
+ bool right = anchors.Right;
+ bool bottom = anchors.Bottom;
+ bool isChecked = value is bool b && b;
+
+ switch (key)
+ {
+ case PropAnchorLeft:
+ left = isChecked;
+ break;
+ case PropAnchorTop:
+ top = isChecked;
+ break;
+ case PropAnchorRight:
+ right = isChecked;
+ break;
+ case PropAnchorBottom:
+ bottom = isChecked;
+ break;
+ }
+
+ if (!left && !right)
+ {
+ if (key == PropAnchorLeft)
+ right = true;
+ else
+ left = true;
+ }
+
+ if (!top && !bottom)
+ {
+ if (key == PropAnchorTop)
+ bottom = true;
+ else
+ top = true;
+ }
+
+ UpdateAnchorProps((left, top, right, bottom));
+ }
+
+ private (bool Left, bool Top, bool Right, bool Bottom) GetCurrentAnchors()
+ => (
+ GetAnchorProp(PropAnchorLeft, true),
+ GetAnchorProp(PropAnchorTop, true),
+ GetAnchorProp(PropAnchorRight, false),
+ GetAnchorProp(PropAnchorBottom, false));
+
+ private void UpdateAnchorProps((bool Left, bool Top, bool Right, bool Bottom) anchors)
+ {
+ if (_selected is null) return;
+
+ State.UpdateControlProps(
+ _selected.ControlId,
+ new Dictionary
+ {
+ [PropAnchorLeft] = anchors.Left,
+ [PropAnchorTop] = anchors.Top,
+ [PropAnchorRight] = anchors.Right,
+ [PropAnchorBottom] = anchors.Bottom,
+ });
+ }
+
+ private void OnFormNameChanged(ChangeEventArgs e)
+ {
+ State.SetFormName(e.Value?.ToString());
+ }
+
private void OnTypeChanged(ChangeEventArgs e)
{
if (_selected is null || e.Value is not string newType) return;
State.UpdateControlType(_selected.ControlId, newType);
+ if (ControlRegistry.TryGetControl(newType, out FormControlDescriptor descriptor))
+ {
+ if (!descriptor.SupportsBinding && _selected.Binding is not null)
+ State.UpdateControlBinding(_selected.ControlId, null);
+ else if (descriptor.SupportsBinding && _selected.Binding is null)
+ State.UpdateControlBinding(_selected.ControlId, new BindingDefinition("", "TwoWay"));
+ }
}
private void OnRectChanged(ChangeEventArgs e, RectPart part)
@@ -540,8 +1484,61 @@
return long.TryParse(s, out var l) ? l : null;
}
+ private static object? ParseNonNegativeDouble(object? value)
+ {
+ if (value is null) return null;
+ var s = value.ToString();
+ if (string.IsNullOrWhiteSpace(s)) return null;
+ return double.TryParse(s, NumberStyles.Float, CultureInfo.InvariantCulture, out double parsed)
+ ? Math.Max(0, parsed)
+ : null;
+ }
+
+ private static bool ReadBool(object? value, bool fallback)
+ {
+ return value switch
+ {
+ bool b => b,
+ JsonElement json when json.ValueKind == JsonValueKind.True => true,
+ JsonElement json when json.ValueKind == JsonValueKind.False => false,
+ JsonElement json when json.ValueKind == JsonValueKind.String && bool.TryParse(json.GetString(), out bool parsed) => parsed,
+ _ when bool.TryParse(value?.ToString(), out bool parsed) => parsed,
+ _ => fallback,
+ };
+ }
+
// ===== DataGrid Configuration Methods =====
+ private async Task OnDataGridModeChanged(ChangeEventArgs e)
+ {
+ if (_selected is null || e.Value is not string mode)
+ return;
+
+ mode = string.Equals(mode, "standalone", StringComparison.OrdinalIgnoreCase)
+ ? "standalone"
+ : "related";
+ OnPropChanged(PropDataGridMode, mode);
+
+ if (string.Equals(mode, "standalone", StringComparison.OrdinalIgnoreCase))
+ {
+ OnPropChanged(PropForeignKeyField, "");
+ OnPropChanged(PropParentKeyField, "");
+ OnPropChanged(PropForeignKeyName, "");
+ return;
+ }
+
+ if (_childTableDef is not null)
+ {
+ var matchingFks = _childTableDef.ForeignKeys
+ .Where(fk => string.Equals(fk.ReferencedTable, State.TableName, StringComparison.OrdinalIgnoreCase))
+ .ToList();
+ if (matchingFks.Count == 1)
+ AutoSelectForeignKey(matchingFks[0]);
+ }
+
+ await Task.CompletedTask;
+ }
+
private async Task OnChildTableChanged(ChangeEventArgs e)
{
if (_selected is null || e.Value is not string tableName) return;
@@ -558,18 +1555,21 @@
if (_childTableDef is not null)
{
- // Auto-select FK if exactly one references the parent table
- var matchingFks = _childTableDef.ForeignKeys
- .Where(fk => string.Equals(fk.ReferencedTable, State.TableName, StringComparison.OrdinalIgnoreCase))
- .ToList();
- if (matchingFks.Count == 1)
+ if (!IsStandaloneDataGrid())
{
- AutoSelectForeignKey(matchingFks[0]);
+ // Auto-select FK if exactly one references the parent table
+ var matchingFks = _childTableDef.ForeignKeys
+ .Where(fk => string.Equals(fk.ReferencedTable, State.TableName, StringComparison.OrdinalIgnoreCase))
+ .ToList();
+ if (matchingFks.Count == 1)
+ {
+ AutoSelectForeignKey(matchingFks[0]);
+ }
}
- // Auto-select all non-PK columns as visible
+ // Related grids keep PKs hidden by default; standalone grids show the mapped table as-is.
var allCols = _childTableDef.Fields
- .Where(f => !_childTableDef.PrimaryKey.Contains(f.Name))
+ .Where(f => IsStandaloneDataGrid() || !_childTableDef.PrimaryKey.Contains(f.Name))
.Select(f => (object?)f.Name)
.ToArray();
OnPropChanged(PropVisibleColumns, allCols);
@@ -674,6 +1674,247 @@
}
}
+ private string GetOptionsText()
+ {
+ if (_selected is null)
+ return string.Empty;
+
+ if (string.Equals(_loadedOptionsControlId, _selected.ControlId, StringComparison.Ordinal))
+ return _optionsText;
+
+ _loadedOptionsControlId = _selected.ControlId;
+ _optionsError = null;
+ IReadOnlyList options = _selected.Props.Values.TryGetValue(PropOptions, out object? value)
+ ? FormChoiceResolver.ReadOptions(value)
+ : [];
+ _optionsText = string.Join(Environment.NewLine, options.Select(option => $"{option.Value}|{option.Label}"));
+ return _optionsText;
+ }
+
+ private void OnOptionsChanged(string text)
+ {
+ _optionsText = text;
+ _optionsError = null;
+
+ if (string.IsNullOrWhiteSpace(text))
+ {
+ OnPropChanged(PropOptions, Array.Empty());
+ return;
+ }
+
+ var options = new List();
+ foreach (string line in text.Split(["\r\n", "\n"], StringSplitOptions.None))
+ {
+ if (string.IsNullOrWhiteSpace(line))
+ continue;
+
+ string[] parts = line.Split('|', 2);
+ string value = parts[0].Trim();
+ if (string.IsNullOrWhiteSpace(value))
+ {
+ _optionsError = "Each option needs a value before the pipe.";
+ return;
+ }
+
+ string label = parts.Length > 1 && !string.IsNullOrWhiteSpace(parts[1])
+ ? parts[1].Trim()
+ : value;
+ options.Add(new Dictionary
+ {
+ ["value"] = value,
+ ["label"] = label,
+ });
+ }
+
+ OnPropChanged(PropOptions, options.ToArray());
+ }
+
+ private string GetDisplayFieldsText()
+ {
+ if (_selected?.Props.Values.TryGetValue(PropDisplayFields, out object? value) == true)
+ return string.Join(", ", FormChoiceResolver.ReadStringList(value));
+
+ return string.Empty;
+ }
+
+ private void OnDisplayFieldsChanged(string text)
+ {
+ object?[] fields = text
+ .Split(',', StringSplitOptions.TrimEntries | StringSplitOptions.RemoveEmptyEntries)
+ .Select(field => (object?)field)
+ .ToArray();
+ OnPropChanged(PropDisplayFields, fields);
+ }
+
+ private static object? ParseScalar(object? value)
+ {
+ string text = value?.ToString()?.Trim() ?? string.Empty;
+ if (text.Length == 0)
+ return null;
+
+ if (bool.TryParse(text, out bool boolValue))
+ return boolValue;
+ if (long.TryParse(text, out long longValue))
+ return longValue;
+ if (double.TryParse(text, out double doubleValue))
+ return doubleValue;
+
+ return text;
+ }
+
+ private string GetTabPagesText()
+ {
+ if (_selected is null)
+ return string.Empty;
+
+ if (string.Equals(_loadedTabPagesControlId, _selected.ControlId, StringComparison.Ordinal))
+ return _tabPagesText;
+
+ _loadedTabPagesControlId = _selected.ControlId;
+ _tabPagesError = null;
+ _tabPagesText = string.Join(Environment.NewLine, ReadTabPages(_selected).Select(tab => $"{tab.Id}|{tab.Label}"));
+ return _tabPagesText;
+ }
+
+ private void OnTabPagesChanged(string text)
+ {
+ _tabPagesText = text;
+ _tabPagesError = null;
+
+ var tabs = new List();
+ foreach (string line in text.Split(["\r\n", "\n"], StringSplitOptions.None))
+ {
+ if (string.IsNullOrWhiteSpace(line))
+ continue;
+
+ string[] parts = line.Split('|', 2);
+ string id = parts[0].Trim();
+ if (string.IsNullOrWhiteSpace(id))
+ {
+ _tabPagesError = "Each tab page needs an id before the pipe.";
+ return;
+ }
+
+ string label = parts.Length > 1 && !string.IsNullOrWhiteSpace(parts[1])
+ ? parts[1].Trim()
+ : id;
+ tabs.Add(new Dictionary
+ {
+ ["id"] = id,
+ ["label"] = label,
+ });
+ }
+
+ OnPropChanged(PropTabs, tabs.ToArray());
+ }
+
+ private IReadOnlyList<(string Id, string Label)> ReadTabPages(ControlDefinition control)
+ {
+ if (!control.Props.Values.TryGetValue(PropTabs, out object? value) || value is null)
+ return [];
+
+ if (value is JsonElement json && json.ValueKind == JsonValueKind.Array)
+ {
+ return json.EnumerateArray()
+ .Select(element => ReadTabPage(element))
+ .Where(tab => tab is not null)
+ .Select(tab => tab!.Value)
+ .ToArray();
+ }
+
+ if (value is IEnumerable items)
+ {
+ return items
+ .Select(item => ReadTabPage(item))
+ .Where(tab => tab is not null)
+ .Select(tab => tab!.Value)
+ .ToArray();
+ }
+
+ return [];
+ }
+
+ private static (string Id, string Label)? ReadTabPage(object? value)
+ {
+ if (value is JsonElement json)
+ {
+ if (json.ValueKind != JsonValueKind.Object)
+ return null;
+
+ string id = json.TryGetProperty("id", out JsonElement idValue) ? idValue.ToString() : string.Empty;
+ string label = json.TryGetProperty("label", out JsonElement labelValue) ? labelValue.ToString() : id;
+ return string.IsNullOrWhiteSpace(id) ? null : (id, string.IsNullOrWhiteSpace(label) ? id : label);
+ }
+
+ if (value is IReadOnlyDictionary readOnly)
+ return ReadTabPage(readOnly);
+
+ if (value is IDictionary dictionary)
+ return ReadTabPage(dictionary);
+
+ return null;
+ }
+
+ private static (string Id, string Label)? ReadTabPage(IReadOnlyDictionary dictionary)
+ {
+ string id = dictionary.TryGetValue("id", out object? idValue) ? idValue?.ToString() ?? string.Empty : string.Empty;
+ if (string.IsNullOrWhiteSpace(id))
+ return null;
+
+ string label = dictionary.TryGetValue("label", out object? labelValue) ? labelValue?.ToString() ?? id : id;
+ return (id, string.IsNullOrWhiteSpace(label) ? id : label);
+ }
+
+ private List GetTabControls()
+ => State.Controls
+ .Where(control => control.ControlType == "tabControl" && !string.Equals(control.ControlId, _selected?.ControlId, StringComparison.Ordinal))
+ .ToList();
+
+ private ControlDefinition? GetSelectedParentTabControl()
+ {
+ string parentControlId = GetProp(PropParentControlId, string.Empty);
+ return string.IsNullOrWhiteSpace(parentControlId)
+ ? null
+ : State.Controls.FirstOrDefault(control => string.Equals(control.ControlId, parentControlId, StringComparison.Ordinal));
+ }
+
+ private void OnParentTabControlChanged(ChangeEventArgs e)
+ {
+ if (_selected is null)
+ return;
+
+ string parentControlId = e.Value?.ToString() ?? string.Empty;
+ OnPropChanged(PropParentControlId, parentControlId);
+ if (string.IsNullOrWhiteSpace(parentControlId))
+ {
+ OnPropChanged(PropParentTabId, string.Empty);
+ return;
+ }
+
+ ControlDefinition? parent = State.Controls.FirstOrDefault(control => string.Equals(control.ControlId, parentControlId, StringComparison.Ordinal));
+ string firstTabId = parent is null ? string.Empty : ReadTabPages(parent).FirstOrDefault().Id ?? string.Empty;
+ OnPropChanged(PropParentTabId, firstTabId);
+ }
+
+ private static string GetControlDisplayName(ControlDefinition control)
+ => control.Props.Values.TryGetValue(PropText, out object? text) && !string.IsNullOrWhiteSpace(text?.ToString())
+ ? $"{text} ({control.ControlId[..Math.Min(8, control.ControlId.Length)]})"
+ : $"{control.ControlType} ({control.ControlId[..Math.Min(8, control.ControlId.Length)]})";
+
+ private RenderFragment RenderFieldSelect(string propName, FormTableDefinition? table, string emptyText) => @;
+
+ private static bool IsLookupChoiceControl(string? controlType)
+ => controlType is "lookup" or "comboBox" or "listBox" or "optionGroup";
+
// ===== ChildTabs Configuration Methods =====
private void OnTabsChanged(List tabs)
@@ -682,6 +1923,105 @@
OnPropChanged("tabs", ChildTabConfigMapper.ToPropertyBag(tabs));
}
+ private string GetCommandArgumentsText()
+ {
+ if (_selected is null)
+ return string.Empty;
+
+ if (string.Equals(_loadedCommandArgumentControlId, _selected.ControlId, StringComparison.Ordinal))
+ return _commandArgumentText;
+
+ _loadedCommandArgumentControlId = _selected.ControlId;
+ _commandArgumentError = null;
+ _commandArgumentText = _selected.Props.Values.TryGetValue(PropCommandArguments, out object? value)
+ ? FormatArguments(FormCommandInvocation.ReadArgumentsProperty(value))
+ : string.Empty;
+ return _commandArgumentText;
+ }
+
+ private void OnCommandArgumentsChanged(string text)
+ {
+ _commandArgumentText = text;
+ _commandArgumentError = null;
+
+ if (string.IsNullOrWhiteSpace(text))
+ {
+ OnPropChanged(PropCommandArguments, null);
+ return;
+ }
+
+ try
+ {
+ IReadOnlyDictionary? arguments =
+ JsonSerializer.Deserialize>(text, JsonDefaults.Options);
+ OnPropChanged(PropCommandArguments, arguments);
+ }
+ catch (JsonException ex)
+ {
+ _commandArgumentError = $"Invalid arguments JSON: {ex.Message}";
+ }
+ }
+
+ private bool IsStandaloneDataGrid()
+ => string.Equals(GetProp(PropDataGridMode, "related"), "standalone", StringComparison.OrdinalIgnoreCase);
+
+ private bool ShouldRenderMissingCommand(string commandName)
+ => !string.IsNullOrWhiteSpace(commandName)
+ && RegisteredCommands.All(command => !string.Equals(command.Name, commandName, StringComparison.OrdinalIgnoreCase));
+
+ private static string FormatArguments(IReadOnlyDictionary? arguments)
+ => arguments is null || arguments.Count == 0
+ ? string.Empty
+ : JsonSerializer.Serialize(arguments, new JsonSerializerOptions(JsonDefaults.Options) { WriteIndented = true });
+
+ private Task OnEventBindingsChanged(IReadOnlyList bindings)
+ {
+ State.UpdateEventBindings(bindings);
+ return Task.CompletedTask;
+ }
+
+ private Task OnActionSequencesChanged(IReadOnlyList sequences)
+ {
+ State.UpdateActionSequences(sequences);
+ return Task.CompletedTask;
+ }
+
+ private Task OnRulesChanged(IReadOnlyList rules)
+ {
+ State.UpdateRules(rules);
+ return Task.CompletedTask;
+ }
+
+ private Task OnFormValidationRulesChanged(IReadOnlyList rules)
+ {
+ State.UpdateValidationRules(rules);
+ return Task.CompletedTask;
+ }
+
+ private Task OnControlValidationRulesChanged(IReadOnlyList rules)
+ {
+ if (_selected is null)
+ return Task.CompletedTask;
+
+ ValidationOverride? existing = _selected.ValidationOverride;
+ bool disableInferredRules = existing?.DisableInferredRules ?? false;
+ IReadOnlyList disableRuleIds = existing?.DisableRuleIds ?? [];
+ ValidationOverride? updated = rules.Count == 0 && !disableInferredRules && disableRuleIds.Count == 0
+ ? null
+ : new ValidationOverride(disableInferredRules, rules.ToList(), disableRuleIds);
+
+ State.UpdateControlValidationOverride(_selected.ControlId, updated);
+ return Task.CompletedTask;
+ }
+
+ private Task OnControlEventBindingsChanged(IReadOnlyList bindings)
+ {
+ if (_selected is not null)
+ State.UpdateControlEventBindings(_selected.ControlId, bindings);
+
+ return Task.CompletedTask;
+ }
+
private async Task LoadTableDefinitionAsync(string? tableName)
{
if (string.IsNullOrWhiteSpace(tableName))
diff --git a/src/CSharpDB.Admin.Forms/Components/Designer/Toolbox.razor b/src/CSharpDB.Admin.Forms/Components/Designer/Toolbox.razor
index 839aabd2..0a85f943 100644
--- a/src/CSharpDB.Admin.Forms/Components/Designer/Toolbox.razor
+++ b/src/CSharpDB.Admin.Forms/Components/Designer/Toolbox.razor
@@ -1,4 +1,6 @@
@using CSharpDB.Admin.Forms.Components.Designer
+@using CSharpDB.Admin.Forms.Contracts
+@using CSharpDB.Admin.Forms.Models
@implements IDisposable
Controls)> GetToolboxGroups()
+ => ControlRegistry.GetToolboxControls()
+ .GroupBy(control => control.ToolboxGroup)
+ .Select(group => (
+ Name: group.Key,
+ Controls: (IReadOnlyList)group.ToArray()))
+ .ToArray();
+
private string ToolClass(string? tool) =>
"toolbox-item" + (State.ActiveTool == tool ? " active" : "");
diff --git a/src/CSharpDB.Admin.Forms/Components/Designer/ValidationRulesEditor.razor b/src/CSharpDB.Admin.Forms/Components/Designer/ValidationRulesEditor.razor
new file mode 100644
index 00000000..534d5883
--- /dev/null
+++ b/src/CSharpDB.Admin.Forms/Components/Designer/ValidationRulesEditor.razor
@@ -0,0 +1,198 @@
+@using System.Text.Json
+@using CSharpDB.Admin.Forms.Models
+@using CSharpDB.Admin.Forms.Serialization
+@using CSharpDB.Primitives
+@inject DbValidationRuleRegistry ValidationRuleRegistry
+
+ Rules { get; set; } = [];
+ [Parameter] public EventCallback> RulesChanged { get; set; }
+
+ private readonly Dictionary _parameterErrors = [];
+
+ private IReadOnlyList RegisteredRules
+ => ValidationRuleRegistry.Rules
+ .OrderBy(static rule => rule.Name, StringComparer.OrdinalIgnoreCase)
+ .ToArray();
+
+ private async Task AddRule()
+ {
+ var updated = Rules
+ .Append(new ValidationRule(NextRuleName(), string.Empty, new Dictionary(StringComparer.OrdinalIgnoreCase)))
+ .ToList();
+ await RulesChanged.InvokeAsync(updated);
+ }
+
+ private async Task RemoveRule(int index)
+ {
+ var updated = Rules.ToList();
+ if (index < 0 || index >= updated.Count)
+ return;
+
+ updated.RemoveAt(index);
+ _parameterErrors.Remove(index);
+ await RulesChanged.InvokeAsync(updated);
+ }
+
+ private Task UpdateRuleFromDropdown(int index, ValidationRule rule, string value)
+ => string.IsNullOrWhiteSpace(value)
+ ? Task.CompletedTask
+ : ReplaceRule(index, rule with { RuleId = value.Trim() });
+
+ private Task UpdateRuleId(int index, ValidationRule rule, string value)
+ => ReplaceRule(index, rule with { RuleId = value.Trim() });
+
+ private Task UpdateMessage(int index, ValidationRule rule, string value)
+ => ReplaceRule(index, rule with { Message = value.Trim() });
+
+ private async Task UpdateParameters(int index, ValidationRule rule, string text)
+ {
+ try
+ {
+ IReadOnlyDictionary parameters = ParseParameters(text);
+ _parameterErrors.Remove(index);
+ await ReplaceRule(index, rule with { Parameters = parameters });
+ }
+ catch (JsonException ex)
+ {
+ _parameterErrors[index] = $"Invalid JSON: {ex.Message}";
+ }
+ catch (InvalidOperationException ex)
+ {
+ _parameterErrors[index] = ex.Message;
+ }
+ }
+
+ private async Task ReplaceRule(int index, ValidationRule rule)
+ {
+ var updated = Rules.ToList();
+ if (index < 0 || index >= updated.Count)
+ return;
+
+ updated[index] = rule;
+ await RulesChanged.InvokeAsync(updated);
+ }
+
+ private string GetRuleSelectValue(ValidationRule rule)
+ => RegisteredRules.Any(definition => string.Equals(definition.Name, rule.RuleId, StringComparison.OrdinalIgnoreCase))
+ ? rule.RuleId
+ : string.Empty;
+
+ private string NextRuleName()
+ {
+ HashSet existing = Rules
+ .Select(static rule => rule.RuleId)
+ .Where(static ruleId => !string.IsNullOrWhiteSpace(ruleId))
+ .ToHashSet(StringComparer.OrdinalIgnoreCase);
+
+ foreach (DbValidationRuleDefinition definition in RegisteredRules)
+ {
+ if (!existing.Contains(definition.Name))
+ return definition.Name;
+ }
+
+ for (int i = 1; ; i++)
+ {
+ string candidate = $"Rule{i}";
+ if (!existing.Contains(candidate))
+ return candidate;
+ }
+ }
+
+ private static string FormatParameters(IReadOnlyDictionary parameters)
+ => parameters.Count == 0
+ ? "{ }"
+ : JsonSerializer.Serialize(parameters, new JsonSerializerOptions(JsonDefaults.Options) { WriteIndented = true });
+
+ private static IReadOnlyDictionary ParseParameters(string text)
+ {
+ if (string.IsNullOrWhiteSpace(text))
+ return new Dictionary(StringComparer.OrdinalIgnoreCase);
+
+ using JsonDocument document = JsonDocument.Parse(text);
+ if (document.RootElement.ValueKind != JsonValueKind.Object)
+ throw new InvalidOperationException("Parameters must be a JSON object.");
+
+ return document.RootElement
+ .EnumerateObject()
+ .ToDictionary(
+ static property => property.Name,
+ static property => ReadJsonValue(property.Value),
+ StringComparer.OrdinalIgnoreCase);
+ }
+
+ private static object? ReadJsonValue(JsonElement value)
+ => value.ValueKind switch
+ {
+ JsonValueKind.Null => null,
+ JsonValueKind.True => true,
+ JsonValueKind.False => false,
+ JsonValueKind.String => value.GetString(),
+ JsonValueKind.Number => value.TryGetInt64(out long integer) ? integer : value.GetDouble(),
+ JsonValueKind.Object => value.EnumerateObject().ToDictionary(
+ static property => property.Name,
+ static property => ReadJsonValue(property.Value),
+ StringComparer.OrdinalIgnoreCase),
+ JsonValueKind.Array => value.EnumerateArray().Select(ReadJsonValue).ToArray(),
+ _ => value.ToString(),
+ };
+}
diff --git a/src/CSharpDB.Admin.Forms/Contracts/ControlFilterState.cs b/src/CSharpDB.Admin.Forms/Contracts/ControlFilterState.cs
new file mode 100644
index 00000000..68be9154
--- /dev/null
+++ b/src/CSharpDB.Admin.Forms/Contracts/ControlFilterState.cs
@@ -0,0 +1,5 @@
+namespace CSharpDB.Admin.Forms.Contracts;
+
+public sealed record ControlFilterState(
+ string FilterExpression,
+ IReadOnlyDictionary Parameters);
diff --git a/src/CSharpDB.Admin.Forms/Contracts/FormActionDiagnostics.cs b/src/CSharpDB.Admin.Forms/Contracts/FormActionDiagnostics.cs
new file mode 100644
index 00000000..a504eef9
--- /dev/null
+++ b/src/CSharpDB.Admin.Forms/Contracts/FormActionDiagnostics.cs
@@ -0,0 +1,139 @@
+using System.Diagnostics;
+using System.Diagnostics.CodeAnalysis;
+using CSharpDB.Primitives;
+
+namespace CSharpDB.Admin.Forms.Contracts;
+
+public sealed record FormActionInvocationDiagnostic(
+ DbActionKind ActionKind,
+ string? Target,
+ string? FormId,
+ string? FormName,
+ string? TableName,
+ string? EventName,
+ string? ActionSequenceName,
+ int StepIndex,
+ string? Location,
+ TimeSpan Elapsed,
+ bool Succeeded,
+ bool Canceled,
+ string? ResultMessage,
+ string? ExceptionMessage,
+ IReadOnlyDictionary Metadata);
+
+public static class FormActionDiagnostics
+{
+ public const string ListenerName = "CSharpDB.Admin.Forms.Actions";
+ public const string InvocationEventName = "CSharpDB.Admin.Forms.Actions.Invocation";
+
+ public static DiagnosticListener Listener { get; } = new(ListenerName);
+
+ public static bool IsInvocationEnabled
+ => Listener.IsEnabled(InvocationEventName);
+
+ internal static long GetTimestamp()
+ => Stopwatch.GetTimestamp();
+
+ internal static TimeSpan GetElapsedTime(long startingTimestamp)
+ => Stopwatch.GetElapsedTime(startingTimestamp);
+
+ [UnconditionalSuppressMessage(
+ "Trimming",
+ "IL2026",
+ Justification = "Form action diagnostics are emitted only for subscribed hosts; the strongly typed event payload is part of the public diagnostics contract.")]
+ internal static void WriteInvocation(
+ DbActionKind actionKind,
+ string? target,
+ IReadOnlyDictionary? metadata,
+ TimeSpan elapsed,
+ bool succeeded,
+ bool canceled,
+ string? resultMessage,
+ string? exceptionMessage)
+ {
+ if (!IsInvocationEnabled)
+ return;
+
+ IReadOnlyDictionary metadataSnapshot = CopyMetadata(metadata);
+ Listener.Write(
+ InvocationEventName,
+ new FormActionInvocationDiagnostic(
+ actionKind,
+ string.IsNullOrWhiteSpace(target) ? null : target,
+ ReadMetadata(metadataSnapshot, "formId"),
+ ReadMetadata(metadataSnapshot, "formName"),
+ ReadMetadata(metadataSnapshot, "tableName"),
+ ReadMetadata(metadataSnapshot, "event"),
+ ReadMetadata(metadataSnapshot, "actionSequence"),
+ ReadStepIndex(metadataSnapshot),
+ BuildLocation(metadataSnapshot),
+ elapsed,
+ succeeded,
+ canceled,
+ resultMessage,
+ exceptionMessage,
+ metadataSnapshot));
+ }
+
+ private static IReadOnlyDictionary CopyMetadata(
+ IReadOnlyDictionary? metadata)
+ {
+ if (metadata is null || metadata.Count == 0)
+ return EmptyStringDictionary.Instance;
+
+ return new Dictionary(metadata, StringComparer.OrdinalIgnoreCase);
+ }
+
+ private static string? BuildLocation(IReadOnlyDictionary metadata)
+ {
+ if (TryReadMetadata(metadata, "location", out string? location))
+ return location;
+
+ string? eventName = ReadMetadata(metadata, "event");
+ string? actionSequence = ReadMetadata(metadata, "actionSequence");
+ string? actionStep = ReadMetadata(metadata, "actionStep");
+ if (!string.IsNullOrWhiteSpace(actionSequence) && !string.IsNullOrWhiteSpace(actionStep))
+ return $"actionSequences.{actionSequence}.steps[{actionStep}]";
+
+ string? controlId = ReadMetadata(metadata, "controlId");
+ if (!string.IsNullOrWhiteSpace(controlId) && !string.IsNullOrWhiteSpace(eventName))
+ return $"controls.{controlId}.events.{eventName}";
+
+ if (!string.IsNullOrWhiteSpace(eventName) && !string.IsNullOrWhiteSpace(actionStep))
+ return $"events.{eventName}.actionSequence.steps[{actionStep}]";
+
+ if (!string.IsNullOrWhiteSpace(actionStep))
+ return $"action.steps[{actionStep}]";
+
+ return null;
+ }
+
+ private static int ReadStepIndex(IReadOnlyDictionary metadata)
+ => int.TryParse(ReadMetadata(metadata, "actionStep"), out int stepIndex)
+ ? stepIndex
+ : -1;
+
+ private static string? ReadMetadata(IReadOnlyDictionary metadata, string key)
+ => TryReadMetadata(metadata, key, out string? value) ? value : null;
+
+ private static bool TryReadMetadata(
+ IReadOnlyDictionary metadata,
+ string key,
+ out string? value)
+ {
+ if (metadata.TryGetValue(key, out string? raw) && !string.IsNullOrWhiteSpace(raw))
+ {
+ value = raw;
+ return true;
+ }
+
+ value = null;
+ return false;
+ }
+
+ private static class EmptyStringDictionary
+ {
+ public static readonly IReadOnlyDictionary Instance =
+ new Dictionary(StringComparer.OrdinalIgnoreCase);
+ }
+}
diff --git a/src/CSharpDB.Admin.Forms/Contracts/FormActionRequests.cs b/src/CSharpDB.Admin.Forms/Contracts/FormActionRequests.cs
new file mode 100644
index 00000000..8fbc17e9
--- /dev/null
+++ b/src/CSharpDB.Admin.Forms/Contracts/FormActionRequests.cs
@@ -0,0 +1,13 @@
+namespace CSharpDB.Admin.Forms.Contracts;
+
+public sealed record FormOpenRequest(
+ string FormId,
+ string FormName,
+ IReadOnlyDictionary Arguments,
+ string? Mode = null,
+ object? RecordId = null,
+ string? FilterExpression = null);
+
+public sealed record FormCloseRequest(
+ string? FormId,
+ string? FormName);
diff --git a/src/CSharpDB.Admin.Forms/Contracts/FormActionRuntimeContext.cs b/src/CSharpDB.Admin.Forms/Contracts/FormActionRuntimeContext.cs
new file mode 100644
index 00000000..7896ccd0
--- /dev/null
+++ b/src/CSharpDB.Admin.Forms/Contracts/FormActionRuntimeContext.cs
@@ -0,0 +1,14 @@
+namespace CSharpDB.Admin.Forms.Contracts;
+
+public sealed record FormActionRuntimeContext(
+ string? FormId,
+ string? FormName,
+ string? TableName,
+ string? EventName,
+ string? ActionSequenceName,
+ int StepIndex,
+ IReadOnlyDictionary? Record,
+ IReadOnlyDictionary? BindingArguments,
+ IReadOnlyDictionary? RuntimeArguments,
+ IReadOnlyDictionary? StepArguments,
+ IReadOnlyDictionary Metadata);
diff --git a/src/CSharpDB.Admin.Forms/Contracts/FormActionValidationModels.cs b/src/CSharpDB.Admin.Forms/Contracts/FormActionValidationModels.cs
new file mode 100644
index 00000000..420a33f7
--- /dev/null
+++ b/src/CSharpDB.Admin.Forms/Contracts/FormActionValidationModels.cs
@@ -0,0 +1,52 @@
+using CSharpDB.Primitives;
+using CSharpDB.Admin.Forms.Models;
+
+namespace CSharpDB.Admin.Forms.Contracts;
+
+public sealed record FormActionValidationResult(
+ bool Succeeded,
+ IReadOnlyList Issues);
+
+public sealed record FormActionValidationIssue(
+ FormActionValidationSeverity Severity,
+ DbActionKind ActionKind,
+ string Surface,
+ string Location,
+ string Message,
+ string? Target = null,
+ string? EventName = null,
+ string? ActionSequence = null,
+ int? StepIndex = null);
+
+public enum FormActionValidationSeverity
+{
+ Warning,
+ Error,
+}
+
+public sealed record FormActionRuntimeCapabilities(
+ bool RecordActions = false,
+ bool OpenForm = false,
+ bool CloseForm = false,
+ bool ApplyFilter = false,
+ bool ClearFilter = false,
+ bool RunSql = false,
+ bool RunProcedure = false,
+ bool SetControlProperty = false)
+{
+ public static FormActionRuntimeCapabilities None { get; } = new();
+
+ public static FormActionRuntimeCapabilities RenderedForm { get; } = new(
+ RecordActions: true,
+ OpenForm: true,
+ CloseForm: true,
+ ApplyFilter: true,
+ ClearFilter: true,
+ SetControlProperty: true);
+}
+
+public sealed record FormActionValidationOptions(
+ FormActionRuntimeCapabilities? RuntimeCapabilities = null,
+ IReadOnlyCollection? AvailableForms = null,
+ IReadOnlyCollection? AvailableProcedures = null,
+ FormTableDefinition? Schema = null);
diff --git a/src/CSharpDB.Admin.Forms/Contracts/FormEventDispatchResult.cs b/src/CSharpDB.Admin.Forms/Contracts/FormEventDispatchResult.cs
new file mode 100644
index 00000000..2279994d
--- /dev/null
+++ b/src/CSharpDB.Admin.Forms/Contracts/FormEventDispatchResult.cs
@@ -0,0 +1,12 @@
+namespace CSharpDB.Admin.Forms.Contracts;
+
+public sealed record FormEventDispatchResult(bool Succeeded, string? Message = null)
+{
+ public static FormEventDispatchResult Success(string? message = null) => new(true, message);
+
+ public static FormEventDispatchResult Failure(string message)
+ {
+ ArgumentException.ThrowIfNullOrWhiteSpace(message);
+ return new(false, message);
+ }
+}
diff --git a/src/CSharpDB.Admin.Forms/Contracts/IFormActionRuntime.cs b/src/CSharpDB.Admin.Forms/Contracts/IFormActionRuntime.cs
new file mode 100644
index 00000000..0193e082
--- /dev/null
+++ b/src/CSharpDB.Admin.Forms/Contracts/IFormActionRuntime.cs
@@ -0,0 +1,53 @@
+using CSharpDB.Primitives;
+
+namespace CSharpDB.Admin.Forms.Contracts;
+
+public interface IFormActionRuntime
+{
+ Task ExecuteRecordActionAsync(
+ FormActionRuntimeContext context,
+ DbActionStep step,
+ CancellationToken ct);
+
+ Task OpenFormAsync(
+ FormActionRuntimeContext context,
+ string formName,
+ IReadOnlyDictionary arguments,
+ CancellationToken ct);
+
+ Task CloseFormAsync(
+ FormActionRuntimeContext context,
+ string? formName,
+ CancellationToken ct);
+
+ Task ApplyFilterAsync(
+ FormActionRuntimeContext context,
+ string target,
+ string filter,
+ IReadOnlyDictionary arguments,
+ CancellationToken ct);
+
+ Task ClearFilterAsync(
+ FormActionRuntimeContext context,
+ string target,
+ CancellationToken ct);
+
+ Task RunSqlAsync(
+ FormActionRuntimeContext context,
+ string sqlOrName,
+ IReadOnlyDictionary arguments,
+ CancellationToken ct);
+
+ Task RunProcedureAsync(
+ FormActionRuntimeContext context,
+ string procedureName,
+ IReadOnlyDictionary arguments,
+ CancellationToken ct);
+
+ Task SetControlPropertyAsync(
+ FormActionRuntimeContext context,
+ string controlId,
+ string propertyName,
+ object? value,
+ CancellationToken ct);
+}
diff --git a/src/CSharpDB.Admin.Forms/Contracts/IFormControlRegistry.cs b/src/CSharpDB.Admin.Forms/Contracts/IFormControlRegistry.cs
new file mode 100644
index 00000000..f91bd82e
--- /dev/null
+++ b/src/CSharpDB.Admin.Forms/Contracts/IFormControlRegistry.cs
@@ -0,0 +1,12 @@
+using CSharpDB.Admin.Forms.Models;
+
+namespace CSharpDB.Admin.Forms.Contracts;
+
+public interface IFormControlRegistry
+{
+ IReadOnlyList Controls { get; }
+
+ bool TryGetControl(string controlType, out FormControlDescriptor descriptor);
+
+ IReadOnlyList GetToolboxControls();
+}
diff --git a/src/CSharpDB.Admin.Forms/Contracts/IFormEventDispatcher.cs b/src/CSharpDB.Admin.Forms/Contracts/IFormEventDispatcher.cs
new file mode 100644
index 00000000..7a03829a
--- /dev/null
+++ b/src/CSharpDB.Admin.Forms/Contracts/IFormEventDispatcher.cs
@@ -0,0 +1,12 @@
+using CSharpDB.Admin.Forms.Models;
+
+namespace CSharpDB.Admin.Forms.Contracts;
+
+public interface IFormEventDispatcher
+{
+ Task DispatchAsync(
+ FormDefinition form,
+ FormEventKind eventKind,
+ IReadOnlyDictionary? record = null,
+ CancellationToken ct = default);
+}
diff --git a/src/CSharpDB.Admin.Forms/Contracts/IFormRecordService.cs b/src/CSharpDB.Admin.Forms/Contracts/IFormRecordService.cs
index c78ce407..9c9801f1 100644
--- a/src/CSharpDB.Admin.Forms/Contracts/IFormRecordService.cs
+++ b/src/CSharpDB.Admin.Forms/Contracts/IFormRecordService.cs
@@ -16,5 +16,6 @@ public interface IFormRecordService
Task>> ListFilteredRecordsAsync(FormTableDefinition table, string filterField, object? filterValue, CancellationToken ct = default);
Task> CreateRecordAsync(FormTableDefinition table, Dictionary values, CancellationToken ct = default);
Task> UpdateRecordAsync(FormTableDefinition table, object pkValue, Dictionary values, CancellationToken ct = default);
+ Task SaveAttachmentAsync(FormAttachmentTableBinding binding, object parentValue, FormAttachmentValue attachment, CancellationToken ct = default);
Task DeleteRecordAsync(FormTableDefinition table, object pkValue, CancellationToken ct = default);
}
diff --git a/src/CSharpDB.Admin.Forms/Contracts/IValidationInferenceService.cs b/src/CSharpDB.Admin.Forms/Contracts/IValidationInferenceService.cs
index e40b91c1..335bf04b 100644
--- a/src/CSharpDB.Admin.Forms/Contracts/IValidationInferenceService.cs
+++ b/src/CSharpDB.Admin.Forms/Contracts/IValidationInferenceService.cs
@@ -6,4 +6,8 @@ public interface IValidationInferenceService
{
IReadOnlyList InferRules(FormFieldDefinition field);
IReadOnlyList Evaluate(FormDefinition form, IDictionary record);
+ Task> EvaluateAsync(
+ FormDefinition form,
+ IDictionary record,
+ CancellationToken ct = default);
}
diff --git a/src/CSharpDB.Admin.Forms/Evaluation/FormulaEvaluator.cs b/src/CSharpDB.Admin.Forms/Evaluation/FormulaEvaluator.cs
index 46df04c1..bb94c79e 100644
--- a/src/CSharpDB.Admin.Forms/Evaluation/FormulaEvaluator.cs
+++ b/src/CSharpDB.Admin.Forms/Evaluation/FormulaEvaluator.cs
@@ -1,39 +1,100 @@
+using System.Globalization;
+using System.Text.Json;
+using CSharpDB.Primitives;
+
namespace CSharpDB.Admin.Forms.Evaluation;
+public sealed record FormulaDomainFunctionRequest(
+ string FunctionName,
+ string Expression,
+ string Domain,
+ string? Criteria);
+
+public delegate object? FormulaDomainFunctionResolver(FormulaDomainFunctionRequest request);
+
///
-/// Evaluates formulas for computed fields.
-///
-/// Field formulas start with '=' and support arithmetic (+, -, *, /), parentheses,
-/// numeric literals, and field references (e.g., =Quantity * UnitPrice).
+/// Evaluates Admin Forms formulas.
///
-/// Aggregate formulas reference child table fields: =SUM(OrderItems.LineTotal),
-/// =COUNT(OrderItems.LineTotal), =AVG(...), =MIN(...), =MAX(...)
+/// Formulas start with '=' and support arithmetic, comparisons, logical
+/// operators, field references, registered scalar callbacks, and Access-style
+/// built-in functions.
///
public static class FormulaEvaluator
{
private static readonly string[] AggregateFunctions = ["SUM", "COUNT", "AVG", "MIN", "MAX"];
+ private static readonly string[] DomainFunctionNames = ["DLOOKUP", "DCOUNT", "DSUM", "DAVG", "DMIN", "DMAX"];
+ private static readonly HashSet BuiltInFunctionNameSet =
+ new(FormulaFunctionCatalog.BuiltInFunctionNames, StringComparer.OrdinalIgnoreCase);
+
+ public static IReadOnlyCollection BuiltInFunctionNames => FormulaFunctionCatalog.BuiltInFunctionNames;
///
- /// Evaluate a field-level formula (e.g., =Quantity * UnitPrice).
- /// Returns null if any referenced field is null, formula is invalid, or division by zero.
+ /// Evaluate a field-level formula as a number.
+ /// Returns null if the formula is invalid, returns a nonnumeric value, or
+ /// hits an invalid numeric operation.
///
public static double? Evaluate(string? formula, Func fieldResolver)
+ => Evaluate(formula, fieldResolver, DbFunctionRegistry.Empty);
+
+ public static double? Evaluate(
+ string? formula,
+ Func fieldResolver,
+ DbFunctionRegistry? functions)
+ => Evaluate(formula, fieldResolver, functions, callbackPolicy: null);
+
+ public static double? Evaluate(
+ string? formula,
+ Func fieldResolver,
+ DbFunctionRegistry? functions,
+ DbExtensionPolicy? callbackPolicy)
{
- if (string.IsNullOrWhiteSpace(formula)) return null;
+ object? value = EvaluateValue(
+ formula,
+ field => fieldResolver(field),
+ functions,
+ callbackPolicy);
+
+ return TryConvertDouble(value, out double numeric) ? numeric : null;
+ }
+
+ public static object? EvaluateValue(string? formula, Func fieldResolver)
+ => EvaluateValue(formula, fieldResolver, DbFunctionRegistry.Empty);
+
+ public static object? EvaluateValue(
+ string? formula,
+ Func fieldResolver,
+ DbFunctionRegistry? functions)
+ => EvaluateValue(formula, fieldResolver, functions, callbackPolicy: null);
+
+ public static object? EvaluateValue(
+ string? formula,
+ Func fieldResolver,
+ DbFunctionRegistry? functions,
+ DbExtensionPolicy? callbackPolicy,
+ FormulaDomainFunctionResolver? domainResolver = null)
+ {
+ if (string.IsNullOrWhiteSpace(formula))
+ return null;
+
+ string expr = formula.Trim();
+ if (!expr.StartsWith('='))
+ return null;
- var expr = formula.Trim();
- if (!expr.StartsWith('=')) return null;
expr = expr[1..].Trim();
- if (expr.Length == 0) return null;
+ if (expr.Length == 0)
+ return null;
try
{
- var parser = new Parser(expr, fieldResolver);
- var result = parser.ParseExpression();
- // Ensure we consumed all input
- if (parser.Position < parser.Input.Length)
- return null;
- return result;
+ var parser = new Parser(
+ expr,
+ fieldResolver,
+ functions ?? DbFunctionRegistry.Empty,
+ callbackPolicy,
+ domainResolver);
+ object? result = parser.ParseExpression();
+ parser.SkipWhitespace();
+ return parser.Failed || parser.Position < parser.Input.Length ? null : NormalizeValue(result);
}
catch
{
@@ -41,6 +102,74 @@ public static class FormulaEvaluator
}
}
+ public static bool IsBuiltInFunctionName(string name)
+ => BuiltInFunctionNameSet.Contains(name);
+
+ public static IReadOnlyList GetDomainReferences(string? formula)
+ {
+ string? expression = GetExpressionBody(formula);
+ if (expression is null)
+ return [];
+
+ var domains = new HashSet(StringComparer.OrdinalIgnoreCase);
+ ReadOnlySpan input = expression.AsSpan();
+ for (int i = 0; i < input.Length; i++)
+ {
+ char current = input[i];
+ if (current is '\'' or '"')
+ {
+ i = SkipQuoted(input, i, current);
+ continue;
+ }
+
+ if (current == '[')
+ {
+ i = SkipBracketed(input, i);
+ continue;
+ }
+
+ if (!IsIdentifierStart(current))
+ continue;
+
+ int start = i;
+ i++;
+ while (i < input.Length && IsIdentifierPart(input[i]))
+ i++;
+
+ string name = input[start..i].ToString();
+ if (!DomainFunctionNames.Contains(name, StringComparer.OrdinalIgnoreCase))
+ {
+ i--;
+ continue;
+ }
+
+ int cursor = i;
+ while (cursor < input.Length && char.IsWhiteSpace(input[cursor]))
+ cursor++;
+
+ if (cursor >= input.Length || input[cursor] != '(')
+ {
+ i--;
+ continue;
+ }
+
+ if (TryReadFunctionArguments(input, cursor, out string argumentsText, out int closeParen))
+ {
+ string[] arguments = SplitTopLevelArguments(argumentsText);
+ if (arguments.Length >= 2 && TryReadLiteralText(arguments[1], out string? domain) && !string.IsNullOrWhiteSpace(domain))
+ domains.Add(domain);
+
+ i = closeParen;
+ }
+ else
+ {
+ i--;
+ }
+ }
+
+ return domains.OrderBy(static domain => domain, StringComparer.OrdinalIgnoreCase).ToArray();
+ }
+
///
/// Try to parse an aggregate formula like =SUM(TableName.FieldName).
/// Returns true if the formula matches the aggregate pattern.
@@ -54,7 +183,6 @@ public static bool TryParseAggregate(string? formula, out string func, out strin
if (!expr.StartsWith('=')) return false;
expr = expr[1..].Trim();
- // Match: FUNC(Table.Field)
foreach (var fn in AggregateFunctions)
{
if (!expr.StartsWith(fn, StringComparison.OrdinalIgnoreCase)) continue;
@@ -82,7 +210,7 @@ public static bool TryParseAggregate(string? formula, out string func, out strin
///
/// Evaluate an aggregate function over a set of values.
- /// Returns null if values is empty (except COUNT which returns 0).
+ /// Returns null if values is empty (except COUNT and SUM which return 0).
///
public static double? EvaluateAggregate(string func, IEnumerable values)
{
@@ -99,151 +227,1507 @@ public static bool TryParseAggregate(string? formula, out string func, out strin
};
}
+ private static string? GetExpressionBody(string? formula)
+ {
+ if (string.IsNullOrWhiteSpace(formula))
+ return null;
+
+ string expression = formula.Trim();
+ if (!expression.StartsWith('='))
+ return null;
+
+ expression = expression[1..].Trim();
+ return expression.Length == 0 ? null : expression;
+ }
+
private static bool IsValidIdentifier(string s) =>
s.Length > 0 && (char.IsLetter(s[0]) || s[0] == '_') && s.All(c => char.IsLetterOrDigit(c) || c == '_');
- ///
- /// Recursive-descent parser for arithmetic expressions with field references.
- /// Grammar:
- /// Expression = Term (('+' | '-') Term)*
- /// Term = Factor (('*' | '/') Factor)*
- /// Factor = ['-'] Atom
- /// Atom = Number | '(' Expression ')' | FieldName
- ///
private ref struct Parser
{
public ReadOnlySpan Input;
public int Position;
- private readonly Func _fieldResolver;
+ public bool Failed;
- public Parser(string input, Func fieldResolver)
+ private readonly Func _fieldResolver;
+ private readonly DbFunctionRegistry _functions;
+ private readonly DbExtensionPolicy? _callbackPolicy;
+ private readonly FormulaDomainFunctionResolver? _domainResolver;
+
+ public Parser(
+ string input,
+ Func
Child Table
+ Data Grid
+
+
+
+
@@ -13,77 +15,21 @@
-
-
-
- Layout
-
-
-
-
- Input Controls
-
-
-
-
-
-
-
-
-
-
-
+ @foreach (var group in GetToolboxGroups())
+ {
+ Data
-
-
-
+
+ }
@group.Name
+ @foreach (FormControlDescriptor control in group.Controls)
+ {
+
+ }
+ Clipboard
@@ -146,24 +92,20 @@
@code {
[CascadingParameter] public DesignerState State { get; set; } = default!;
-
- private const string ToolLabel = "label";
- private const string ToolText = "text";
- private const string ToolTextarea = "textarea";
- private const string ToolNumber = "number";
- private const string ToolDate = "date";
- private const string ToolCheckbox = "checkbox";
- private const string ToolRadio = "radio";
- private const string ToolSelect = "select";
- private const string ToolDatagrid = "datagrid";
- private const string ToolChildTabs = "childtabs";
- private const string ToolLookup = "lookup";
- private const string ToolComputed = "computed";
+ [Inject] public IFormControlRegistry ControlRegistry { get; set; } = DefaultFormControlRegistry.Instance;
protected override void OnInitialized() => State.OnChange += OnStateChanged;
public void Dispose() => State.OnChange -= OnStateChanged;
private void OnStateChanged() => InvokeAsync(StateHasChanged);
+ private IReadOnlyList<(string Name, IReadOnlyList
+ @if (Rules.Count == 0)
+ {
+
+
+@code {
+ [Parameter, EditorRequired] public IReadOnlyListNo validation rules
+ }
+
+ @for (int i = 0; i < Rules.Count; i++)
+ {
+ var ruleIndex = i;
+ var rule = Rules[ruleIndex];
+
+
+ }
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ @if (_parameterErrors.TryGetValue(ruleIndex, out string? error))
+ {
+
+ @error
+ }
+