Joseph Doherty
685 lines
30 KiB
Plaintext
685 lines
30 KiB
Plaintext
@page "/design/templates"
|
|
@using ZB.MOM.WW.ScadaBridge.Security
|
|
@using ZB.MOM.WW.ScadaBridge.Commons.Entities.Templates
|
|
@using ZB.MOM.WW.ScadaBridge.Commons.Interfaces.Repositories
|
|
@using ZB.MOM.WW.ScadaBridge.Commons.Types.Enums
|
|
@using ZB.MOM.WW.ScadaBridge.CentralUI.Components.Shared
|
|
@using ZB.MOM.WW.ScadaBridge.TemplateEngine
|
|
@using ZB.MOM.WW.ScadaBridge.TemplateEngine.Services
|
|
@attribute [Authorize(Policy = AuthorizationPolicies.RequireDesign)]
|
|
@inject ITemplateEngineRepository TemplateEngineRepository
|
|
@inject TemplateService TemplateService
|
|
@inject TemplateFolderService TemplateFolderService
|
|
@inject AuthenticationStateProvider AuthStateProvider
|
|
@inject NavigationManager NavigationManager
|
|
@inject IDialogService Dialog
|
|
|
|
<div class="container-fluid mt-3">
|
|
<ToastNotification @ref="_toast" />
|
|
|
|
@if (_loading)
|
|
{
|
|
<LoadingSpinner IsLoading="true" />
|
|
}
|
|
else if (_errorMessage != null)
|
|
{
|
|
<div class="alert alert-danger">@_errorMessage</div>
|
|
}
|
|
else
|
|
{
|
|
<div class="d-flex justify-content-between align-items-center mb-3">
|
|
<h4 class="mb-0">Templates</h4>
|
|
<div class="d-flex gap-2">
|
|
<div class="dropdown">
|
|
<button class="btn btn-outline-secondary btn-sm dropdown-toggle"
|
|
data-bs-toggle="dropdown" aria-expanded="false">
|
|
Bulk actions
|
|
</button>
|
|
<ul class="dropdown-menu dropdown-menu-end">
|
|
<li>
|
|
<button class="dropdown-item" @onclick="() => _tree.ExpandAll()">Expand all folders</button>
|
|
</li>
|
|
<li>
|
|
<button class="dropdown-item" @onclick="() => _tree.CollapseAll()">Collapse all folders</button>
|
|
</li>
|
|
</ul>
|
|
</div>
|
|
@* The Bulk actions dropdown keeps its own .dropdown wrapper, so
|
|
only the two plain create buttons are grouped. *@
|
|
<div class="btn-group btn-group-sm" role="group" aria-label="Create actions">
|
|
<button class="btn btn-outline-secondary"
|
|
title="New folder at root"
|
|
@onclick="() => OpenNewFolderDialog(null)">+ Folder</button>
|
|
<button class="btn btn-primary"
|
|
title="New template at root"
|
|
@onclick='() => NavigationManager.NavigateTo("/design/templates/create")'>+ Template</button>
|
|
</div>
|
|
</div>
|
|
</div>
|
|
|
|
<div class="mb-3" style="max-width: 320px;">
|
|
<div class="input-group input-group-sm">
|
|
<input type="text" class="form-control form-control-sm"
|
|
placeholder="Search templates..."
|
|
value="@_searchText"
|
|
@oninput="e => _searchText = e.Value?.ToString() ?? string.Empty" />
|
|
@if (!string.IsNullOrEmpty(_searchText))
|
|
{
|
|
<button class="btn btn-sm btn-outline-secondary" type="button"
|
|
title="Clear search"
|
|
@onclick="() => _searchText = string.Empty">✕</button>
|
|
}
|
|
</div>
|
|
</div>
|
|
|
|
@* The root zone fills the scroll area so a right-click on empty space
|
|
(or below the tree) opens a root-level context menu — New Folder /
|
|
New Template at root. Node-level right-clicks are handled by the
|
|
TreeView's own context menu (preventDefault'd there), so they don't
|
|
bubble to this handler. *@
|
|
<div class="tv-root-zone" style="max-height: calc(100vh - 200px); min-height: 120px; overflow-y: auto; padding: 4px;"
|
|
@oncontextmenu="OpenRootContextMenu" @oncontextmenu:preventDefault="true">
|
|
<TemplateFolderTree @ref="_tree"
|
|
Folders="_folders"
|
|
Templates="_templates"
|
|
SelectionMode="TreeViewSelectionMode.Single"
|
|
ExtraTemplateChildren="BuildCompositionLeavesFor"
|
|
Filter="@_searchText"
|
|
StorageKey="templates-tree"
|
|
OnNodeContextMenuOpened="DismissRootContextMenu">
|
|
<NodeContent Context="node">
|
|
@RenderNodeLabel(node)
|
|
</NodeContent>
|
|
<ContextMenu Context="node">
|
|
@RenderNodeContextMenu(node)
|
|
</ContextMenu>
|
|
<EmptyContent>
|
|
<span class="text-muted fst-italic">No templates yet. Use the buttons above (or right-click here) to create a folder or template.</span>
|
|
</EmptyContent>
|
|
</TemplateFolderTree>
|
|
</div>
|
|
|
|
@if (_showRootMenu)
|
|
{
|
|
<div class="tv-ctx-overlay" @onclick="DismissRootContextMenu"
|
|
style="position:fixed;top:0;left:0;width:100vw;height:100vh;z-index:1049;background:transparent;"></div>
|
|
<div class="dropdown-menu show tv-root-menu" tabindex="-1" @ref="_rootMenuRef"
|
|
@onclick="DismissRootContextMenu"
|
|
@onkeydown="OnRootMenuKeyDown"
|
|
style="position:fixed;top:@(_rootMenuY)px;left:@(_rootMenuX)px;z-index:1050;outline:none;">
|
|
<button class="dropdown-item" @onclick="() => OpenNewFolderDialog(null)">New Folder</button>
|
|
<button class="dropdown-item" @onclick='() => NavigationManager.NavigateTo("/design/templates/create")'>New Template</button>
|
|
</div>
|
|
}
|
|
}
|
|
</div>
|
|
|
|
@code {
|
|
// CentralUI-024: delegates to the shared helper so the claim type stays
|
|
// resolved through JwtTokenService rather than a duplicated magic string.
|
|
private Task<string> GetCurrentUserAsync()
|
|
=> AuthStateProvider.RequireRoleAsync(ZB.MOM.WW.ScadaBridge.Security.Roles.Designer);
|
|
|
|
private List<Template> _templates = new();
|
|
private List<TemplateFolder> _folders = new();
|
|
|
|
// Search text bound to the filter input; passed as Filter to TemplateFolderTree
|
|
// which handles substring matching and ancestor auto-expand internally.
|
|
private string _searchText = string.Empty;
|
|
|
|
private bool _loading = true;
|
|
private string? _errorMessage;
|
|
|
|
// "New Instance…" leaves the Design area for a RequireDeployment page; only offer
|
|
// it to users who hold that role so the menu never leads to a 403.
|
|
private bool _canCreateInstances;
|
|
|
|
private ToastNotification _toast = default!;
|
|
|
|
protected override async Task OnInitializedAsync()
|
|
{
|
|
var state = await AuthStateProvider.GetAuthenticationStateAsync();
|
|
_canCreateInstances = state.User.HasClaim(JwtTokenService.RoleClaimType, Roles.Deployer);
|
|
await LoadTemplatesAsync();
|
|
}
|
|
|
|
private async Task LoadTemplatesAsync()
|
|
{
|
|
_loading = true;
|
|
try
|
|
{
|
|
_templates = (await TemplateEngineRepository.GetAllTemplatesAsync()).ToList();
|
|
_folders = (await TemplateEngineRepository.GetAllFoldersAsync()).ToList();
|
|
_templatesById = _templates.ToDictionary(t => t.Id);
|
|
_compositionsById = _templates
|
|
.SelectMany(t => t.Compositions)
|
|
.GroupBy(c => c.Id)
|
|
.ToDictionary(g => g.Key, g => g.First());
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
_errorMessage = $"Failed to load templates: {ex.Message}";
|
|
}
|
|
_loading = false;
|
|
}
|
|
|
|
// ID lookups so RenderNodeLabel / RenderNodeContextMenu can resolve the
|
|
// entity behind a TemplateTreeNode (whose payload is just Id+Kind+Name).
|
|
private Dictionary<int, Template> _templatesById = new();
|
|
private Dictionary<int, TemplateComposition> _compositionsById = new();
|
|
|
|
// Composition-leaf builder for TemplateFolderTree's ExtraTemplateChildren
|
|
// hook: walks each template's compositions recursively so cascaded slots
|
|
// appear as nested children. The Transport Export wizard intentionally
|
|
// does NOT supply this hook — compositions aren't independently exportable.
|
|
//
|
|
// followup #9: a derived template inherits its ancestors' compositions (e.g.
|
|
// LeftReactorSide, derived from ReactorSide, inherits ReactorSide's LeakTest
|
|
// slot). The inherited TemplateComposition row lives on the ancestor — there is
|
|
// no IsInherited placeholder row on the child — so the recursion uses the
|
|
// EFFECTIVE composition set (own + inherited), mirroring
|
|
// TemplateResolver.ResolveAllMembers which walks the inheritance chain. Inherited
|
|
// slots are flagged so the label badges them and the menu suppresses edits.
|
|
private IReadOnlyList<TemplateTreeNode> BuildCompositionLeavesFor(Template owner)
|
|
=> BuildCompositionLeavesFor(owner, $"t:{owner.Id}", new HashSet<int>());
|
|
|
|
private IReadOnlyList<TemplateTreeNode> BuildCompositionLeavesFor(
|
|
Template owner, string parentKey, HashSet<int> compositionPath)
|
|
{
|
|
var result = new List<TemplateTreeNode>();
|
|
foreach (var (composition, inherited) in EffectiveCompositionsFor(owner)
|
|
.OrderBy(x => x.Composition.InstanceName, StringComparer.OrdinalIgnoreCase))
|
|
{
|
|
// Path-qualified key: the same inherited row can appear under multiple
|
|
// derived members, so qualify by the parent path to keep keys unique.
|
|
var key = $"{parentKey}/c:{composition.Id}";
|
|
var node = new TemplateTreeNode
|
|
{
|
|
Kind = TemplateTreeNodeKind.Composition,
|
|
Id = composition.Id,
|
|
Name = composition.InstanceName,
|
|
IsInherited = inherited,
|
|
KeyOverride = key,
|
|
};
|
|
|
|
// Cycle guard: the composition graph is acyclic by construction, but
|
|
// pulling in inherited compositions means guarding the recursion defensively.
|
|
if (_templatesById.TryGetValue(composition.ComposedTemplateId, out var composed)
|
|
&& compositionPath.Add(composition.ComposedTemplateId))
|
|
{
|
|
foreach (var nested in BuildCompositionLeavesFor(composed, key, compositionPath))
|
|
{
|
|
node.Children.Add(nested);
|
|
}
|
|
compositionPath.Remove(composition.ComposedTemplateId);
|
|
}
|
|
|
|
result.Add(node);
|
|
}
|
|
return result;
|
|
}
|
|
|
|
// The compositions visible on a template: its own rows plus those inherited from
|
|
// ancestors. Walks leaf -> root so a child's own slot wins over an inherited slot
|
|
// of the same InstanceName (child-overrides-parent, matching the resolver). The
|
|
// Inherited flag is true when the row's owning template is an ancestor, not `owner`.
|
|
private IEnumerable<(TemplateComposition Composition, bool Inherited)> EffectiveCompositionsFor(Template owner)
|
|
{
|
|
var byName = new Dictionary<string, (TemplateComposition Composition, bool Inherited)>(
|
|
StringComparer.OrdinalIgnoreCase);
|
|
var visited = new HashSet<int>();
|
|
for (Template? t = owner;
|
|
t is not null && visited.Add(t.Id);
|
|
t = t.ParentTemplateId is int pid && _templatesById.TryGetValue(pid, out var parent) ? parent : null)
|
|
{
|
|
var inherited = t.Id != owner.Id;
|
|
foreach (var c in t.Compositions)
|
|
byName.TryAdd(c.InstanceName, (c, inherited)); // leaf seen first -> wins
|
|
}
|
|
return byName.Values;
|
|
}
|
|
|
|
private TemplateFolderTree _tree = default!;
|
|
|
|
private void OpenTemplate(int templateId) =>
|
|
NavigationManager.NavigateTo($"/design/templates/{templateId}");
|
|
|
|
private RenderFragment RenderNodeLabel(TemplateTreeNode node) => __builder =>
|
|
{
|
|
switch (node.Kind)
|
|
{
|
|
case TemplateTreeNodeKind.Folder:
|
|
<span class="tv-glyph"><i class="bi bi-folder"></i></span>
|
|
<span class="tv-label @(node.Children.Count > 0 ? "fw-semibold" : "")"
|
|
title="@node.Name">@node.Name</span>
|
|
@if (node.Children.Count > 0)
|
|
{
|
|
<span class="tv-meta">
|
|
<span class="badge rounded-pill bg-secondary-subtle text-secondary-emphasis">@node.Children.Count</span>
|
|
</span>
|
|
}
|
|
break;
|
|
|
|
case TemplateTreeNodeKind.Template:
|
|
<span class="tv-glyph"><i class="bi bi-file-earmark-text"></i></span>
|
|
<span class="tv-label @(node.Children.Count > 0 ? "fw-semibold" : "")"
|
|
title="@node.Name"
|
|
@ondblclick="() => OpenTemplate(node.Id)">@node.Name</span>
|
|
break;
|
|
|
|
case TemplateTreeNodeKind.Composition:
|
|
var composedId = _compositionsById.TryGetValue(node.Id, out var comp) ? comp.ComposedTemplateId : 0;
|
|
<span class="tv-glyph"><i class="bi bi-arrow-return-right"></i></span>
|
|
<span class="tv-label" title="@node.Name"
|
|
@ondblclick="() => OpenTemplate(composedId)">@node.Name</span>
|
|
@if (node.IsInherited)
|
|
{
|
|
<span class="tv-meta">
|
|
<span class="badge rounded-pill bg-secondary-subtle text-secondary-emphasis"
|
|
title="Inherited from a base template">inherited</span>
|
|
</span>
|
|
}
|
|
break;
|
|
}
|
|
};
|
|
|
|
private RenderFragment RenderNodeContextMenu(TemplateTreeNode node) => __builder =>
|
|
{
|
|
switch (node.Kind)
|
|
{
|
|
case TemplateTreeNodeKind.Folder:
|
|
<button class="dropdown-item" @onclick="() => OpenNewFolderDialog(node.Id)">New Folder</button>
|
|
<button class="dropdown-item" @onclick='() => NavigationManager.NavigateTo($"/design/templates/create?folderId={node.Id}")'>New Template</button>
|
|
<button class="dropdown-item" @onclick="() => OpenRenameFolderDialog(node.Id, node.Name)">Rename</button>
|
|
<button class="dropdown-item" @onclick="() => OpenMoveFolderDialog(node.Id, node.Name)">Move to Folder…</button>
|
|
<div class="dropdown-divider"></div>
|
|
<button class="dropdown-item" disabled="@IsFirstSibling(node.Id)"
|
|
@onclick="() => ReorderFolder(node.Id, ReorderDirection.Up)">Move up</button>
|
|
<button class="dropdown-item" disabled="@IsLastSibling(node.Id)"
|
|
@onclick="() => ReorderFolder(node.Id, ReorderDirection.Down)">Move down</button>
|
|
<div class="dropdown-divider"></div>
|
|
<button class="dropdown-item text-danger" @onclick="() => DeleteFolder(node.Id, node.Name)">Delete</button>
|
|
break;
|
|
|
|
case TemplateTreeNodeKind.Template:
|
|
var tmpl = _templatesById.TryGetValue(node.Id, out var t) ? t : null;
|
|
<button class="dropdown-item" @onclick='() => NavigationManager.NavigateTo($"/design/templates/create?parentId={node.Id}")'>New Inheriting Template</button>
|
|
@if (tmpl != null)
|
|
{
|
|
<button class="dropdown-item" @onclick="() => OpenComposeDialog(tmpl)">Compose into…</button>
|
|
}
|
|
@if (_canCreateInstances)
|
|
{
|
|
<div class="dropdown-divider"></div>
|
|
<button class="dropdown-item" data-test="ctx-new-instance"
|
|
@onclick='() => NavigationManager.NavigateTo($"/deployment/instances/create?templateId={node.Id}")'>New Instance…</button>
|
|
<div class="dropdown-divider"></div>
|
|
}
|
|
<button class="dropdown-item" @onclick="() => OpenMoveTemplateDialog(node.Id, node.Name)">Move to Folder…</button>
|
|
<div class="dropdown-divider"></div>
|
|
@if (tmpl != null)
|
|
{
|
|
<button class="dropdown-item text-danger" @onclick="() => DeleteTemplate(tmpl)">Delete</button>
|
|
}
|
|
break;
|
|
|
|
case TemplateTreeNodeKind.Composition:
|
|
if (_compositionsById.TryGetValue(node.Id, out var ctx))
|
|
{
|
|
<button class="dropdown-item" @onclick='() => NavigationManager.NavigateTo($"/design/templates/{ctx.ComposedTemplateId}")'>Open composed template</button>
|
|
@if (node.IsInherited)
|
|
{
|
|
// Inherited slot — Rename/Delete would mutate the ancestor's
|
|
// composition (affecting every derivation), so they are offered
|
|
// on the base template's own slot, not here (followup #9).
|
|
<div class="dropdown-divider"></div>
|
|
<span class="dropdown-item-text text-muted small">Inherited from a base template — edit on the base.</span>
|
|
}
|
|
else
|
|
{
|
|
<button class="dropdown-item" @onclick="() => RenameComposition(ctx)">Rename…</button>
|
|
<div class="dropdown-divider"></div>
|
|
<button class="dropdown-item text-danger" @onclick="() => DeleteComposition(ctx)">Delete</button>
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
};
|
|
|
|
// New-folder dialog: replaced the dedicated <NewFolderDialog> component with
|
|
// IDialogService.PromptAsync. Validation failures surface via toast instead of
|
|
// inline error text — the prompt UI doesn't have a slot for an error message.
|
|
private async Task OpenNewFolderDialog(int? parentFolderId)
|
|
{
|
|
var name = await Dialog.PromptAsync("New folder", "Folder name", placeholder: "Folder name");
|
|
if (string.IsNullOrWhiteSpace(name)) return;
|
|
|
|
var user = await GetCurrentUserAsync();
|
|
var result = await TemplateFolderService.CreateFolderAsync(name.Trim(), parentFolderId, user);
|
|
if (result.IsSuccess)
|
|
{
|
|
_toast.ShowSuccess($"Folder '{result.Value.Name}' created.");
|
|
await LoadTemplatesAsync();
|
|
}
|
|
else
|
|
{
|
|
_toast.ShowError(result.Error);
|
|
}
|
|
}
|
|
|
|
// Move-template dialog: opened via IDialogService.ShowAsync. The body returns
|
|
// the picked folder id (null = Root) on Move, or null on Cancel; validation runs
|
|
// here after the dialog closes and surfaces server guard failures via a toast.
|
|
private async Task OpenMoveTemplateDialog(int templateId, string label)
|
|
{
|
|
var result = await Dialog.ShowAsync<MoveTemplateDialog.MoveTemplateResult>(
|
|
$"Move '{label}' to…",
|
|
ctx => @<MoveTemplateDialog Context="ctx" FolderOptions="EnumerateFolderOptions()" />);
|
|
if (result is null) return;
|
|
|
|
var user = await GetCurrentUserAsync();
|
|
var moved = await TemplateService.MoveTemplateAsync(templateId, result.NewFolderId, user);
|
|
if (moved.IsSuccess)
|
|
{
|
|
_toast.ShowSuccess($"Template '{label}' moved.");
|
|
await LoadTemplatesAsync();
|
|
}
|
|
else
|
|
{
|
|
_toast.ShowError(moved.Error);
|
|
}
|
|
}
|
|
|
|
// Flat list of folders with indentation labels, for the picker.
|
|
private IEnumerable<(int? Id, string Label)> EnumerateFolderOptions()
|
|
{
|
|
yield return (null, "(Root)");
|
|
foreach (var f in WalkFolderHierarchy(_folders.Where(f => f.ParentFolderId == null), 0, excludeFolderId: null))
|
|
yield return f;
|
|
}
|
|
|
|
// Same as EnumerateFolderOptions, but prunes the given folder and all its descendants
|
|
// so the move dialog can't surface an obvious cycle target (server still validates).
|
|
private IEnumerable<(int? Id, string Label)> EnumerateFolderOptionsExcluding(int excludeFolderId)
|
|
{
|
|
yield return (null, "(Root)");
|
|
foreach (var f in WalkFolderHierarchy(_folders.Where(f => f.ParentFolderId == null), 0, excludeFolderId))
|
|
yield return f;
|
|
}
|
|
|
|
private IEnumerable<(int? Id, string Label)> WalkFolderHierarchy(IEnumerable<TemplateFolder> level, int depth, int? excludeFolderId)
|
|
{
|
|
foreach (var f in level.OrderBy(f => f.Name, StringComparer.OrdinalIgnoreCase))
|
|
{
|
|
if (excludeFolderId.HasValue && f.Id == excludeFolderId.Value) continue;
|
|
yield return ((int?)f.Id, new string(' ', depth * 2) + f.Name);
|
|
foreach (var sub in WalkFolderHierarchy(_folders.Where(c => c.ParentFolderId == f.Id), depth + 1, excludeFolderId))
|
|
yield return sub;
|
|
}
|
|
}
|
|
|
|
// Move-folder dialog: opened via IDialogService.ShowAsync. The picker prunes the
|
|
// folder + its descendants (server still validates cycles). The body returns the
|
|
// picked parent id (null = Root) on Move, or null on Cancel; server guard failures
|
|
// surface via a toast.
|
|
private async Task OpenMoveFolderDialog(int folderId, string label)
|
|
{
|
|
var result = await Dialog.ShowAsync<MoveFolderDialog.MoveFolderResult>(
|
|
$"Move '{label}' to…",
|
|
ctx => @<MoveFolderDialog Context="ctx" FolderOptions="EnumerateFolderOptionsExcluding(folderId)" />);
|
|
if (result is null) return;
|
|
|
|
var user = await GetCurrentUserAsync();
|
|
var moved = await TemplateFolderService.MoveFolderAsync(folderId, result.NewParentId, user);
|
|
if (moved.IsSuccess)
|
|
{
|
|
_toast.ShowSuccess($"Folder '{label}' moved.");
|
|
await LoadTemplatesAsync();
|
|
}
|
|
else
|
|
{
|
|
_toast.ShowError(moved.Error);
|
|
}
|
|
}
|
|
|
|
// ---- Sibling reorder ----
|
|
// Dispatches the reorder the same way Move/Rename do — directly through
|
|
// TemplateFolderService (the backend swaps SortOrder with the adjacent
|
|
// same-parent sibling, no-op at the ends) — then reloads so the new order
|
|
// shows. Folder listing is ordered by SortOrder, so the swap is visible
|
|
// after reload.
|
|
private async Task ReorderFolder(int folderId, ReorderDirection direction)
|
|
{
|
|
var user = await GetCurrentUserAsync();
|
|
var result = await TemplateFolderService.ReorderFolderAsync(folderId, direction, user);
|
|
if (result.IsSuccess)
|
|
{
|
|
await LoadTemplatesAsync();
|
|
}
|
|
else
|
|
{
|
|
_toast.ShowError(result.Error);
|
|
}
|
|
}
|
|
|
|
// Sibling-order helpers for disabling Move up/down at the ends. Mirrors the
|
|
// backend ordering (ascending SortOrder, then Name). Returns false when the
|
|
// folder is unknown so the menu stays enabled and the backend no-op guards.
|
|
private bool IsFirstSibling(int folderId)
|
|
{
|
|
var ordered = OrderedSiblings(folderId);
|
|
return ordered.Count > 0 && ordered[0].Id == folderId;
|
|
}
|
|
|
|
private bool IsLastSibling(int folderId)
|
|
{
|
|
var ordered = OrderedSiblings(folderId);
|
|
return ordered.Count > 0 && ordered[^1].Id == folderId;
|
|
}
|
|
|
|
private List<TemplateFolder> OrderedSiblings(int folderId)
|
|
{
|
|
var folder = _folders.FirstOrDefault(f => f.Id == folderId);
|
|
if (folder == null) return new List<TemplateFolder>();
|
|
return _folders
|
|
.Where(f => f.ParentFolderId == folder.ParentFolderId)
|
|
.OrderBy(f => f.SortOrder)
|
|
.ThenBy(f => f.Name, StringComparer.OrdinalIgnoreCase)
|
|
.ToList();
|
|
}
|
|
|
|
// ---- Root-level context menu ----
|
|
// Right-click on the tree zone (empty space or below the tree) offers
|
|
// New Folder / New Template at root. Node right-clicks are handled by the
|
|
// TreeView's own context menu and never reach here.
|
|
private bool _showRootMenu;
|
|
private double _rootMenuX;
|
|
private double _rootMenuY;
|
|
private bool _rootMenuNeedsFocus;
|
|
private ElementReference _rootMenuRef;
|
|
|
|
private void OpenRootContextMenu(MouseEventArgs e)
|
|
{
|
|
// Guard: dismiss any open node context menu first so both menus are
|
|
// never visible simultaneously (double-menu flash fix, #258).
|
|
_tree.DismissNodeContextMenu();
|
|
|
|
_rootMenuX = e.ClientX;
|
|
_rootMenuY = e.ClientY;
|
|
_showRootMenu = true;
|
|
_rootMenuNeedsFocus = true;
|
|
}
|
|
|
|
private void DismissRootContextMenu() => _showRootMenu = false;
|
|
|
|
private void OnRootMenuKeyDown(KeyboardEventArgs e)
|
|
{
|
|
if (e.Key == "Escape")
|
|
DismissRootContextMenu();
|
|
}
|
|
|
|
protected override async Task OnAfterRenderAsync(bool firstRender)
|
|
{
|
|
if (_rootMenuNeedsFocus && _showRootMenu)
|
|
{
|
|
_rootMenuNeedsFocus = false;
|
|
try { await _rootMenuRef.FocusAsync(); }
|
|
catch (Microsoft.JSInterop.JSException) { }
|
|
catch (Microsoft.JSInterop.JSDisconnectedException) { }
|
|
catch (InvalidOperationException) { }
|
|
}
|
|
}
|
|
|
|
// Rename folder dialog: opened via IDialogService.ShowAsync. The body seeds the
|
|
// input from the current name and returns the trimmed new name on Save, or null on
|
|
// Cancel; server guard failures surface via a toast.
|
|
private async Task OpenRenameFolderDialog(int folderId, string currentName)
|
|
{
|
|
var newName = await Dialog.ShowAsync<string>(
|
|
"Rename Folder",
|
|
ctx => @<RenameFolderDialog Context="ctx" InitialName="@currentName" />,
|
|
size: "modal-sm");
|
|
if (string.IsNullOrWhiteSpace(newName)) return;
|
|
|
|
var user = await GetCurrentUserAsync();
|
|
var result = await TemplateFolderService.RenameFolderAsync(folderId, newName, user);
|
|
if (result.IsSuccess)
|
|
{
|
|
_toast.ShowSuccess("Folder renamed.");
|
|
await LoadTemplatesAsync();
|
|
}
|
|
else
|
|
{
|
|
_toast.ShowError(result.Error);
|
|
}
|
|
}
|
|
|
|
private async Task DeleteFolder(int folderId, string label)
|
|
{
|
|
var confirmed = await Dialog.ConfirmAsync("Delete Folder", $"Delete folder '{label}'?", danger: true);
|
|
if (!confirmed) return;
|
|
|
|
var user = await GetCurrentUserAsync();
|
|
var result = await TemplateFolderService.DeleteFolderAsync(folderId, user);
|
|
if (result.IsSuccess)
|
|
{
|
|
_toast.ShowSuccess($"Folder '{label}' deleted.");
|
|
await LoadTemplatesAsync();
|
|
}
|
|
else
|
|
{
|
|
_toast.ShowError(result.Error);
|
|
}
|
|
}
|
|
|
|
private async Task DeleteTemplate(Template template)
|
|
{
|
|
var confirmed = await Dialog.ConfirmAsync(
|
|
"Delete Template",
|
|
$"Delete template '{template.Name}'? This will fail if instances or child templates reference it.",
|
|
danger: true);
|
|
if (!confirmed) return;
|
|
|
|
try
|
|
{
|
|
var user = await GetCurrentUserAsync();
|
|
var result = await TemplateService.DeleteTemplateAsync(template.Id, user);
|
|
if (result.IsSuccess)
|
|
{
|
|
_toast.ShowSuccess($"Template '{template.Name}' deleted.");
|
|
await LoadTemplatesAsync();
|
|
}
|
|
else
|
|
{
|
|
_toast.ShowError(result.Error);
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
_toast.ShowError($"Delete failed: {ex.Message}");
|
|
}
|
|
}
|
|
|
|
// ---- Compose-into dialog ----
|
|
// Opened via IDialogService.ShowAsync. The body returns the chosen parent template
|
|
// + slot name on Compose (its own client-side guard keeps the button disabled until
|
|
// both are set), or null on Cancel; server guard failures surface via a toast.
|
|
private async Task OpenComposeDialog(Template source)
|
|
{
|
|
var sourceId = source.Id;
|
|
var sourceName = source.Name;
|
|
var result = await Dialog.ShowAsync<ComposeIntoDialog.ComposeResult>(
|
|
$"Compose '{sourceName}' into…",
|
|
ctx => @<ComposeIntoDialog Context="ctx"
|
|
SourceName="@sourceName"
|
|
ParentOptions="EnumerateComposableParents(sourceId)" />);
|
|
if (result is null) return;
|
|
|
|
var user = await GetCurrentUserAsync();
|
|
var composed = await TemplateService.AddCompositionAsync(result.ParentTemplateId, sourceId, result.SlotName, user);
|
|
if (composed.IsSuccess)
|
|
{
|
|
_toast.ShowSuccess($"Composed '{sourceName}' as '{result.SlotName}'.");
|
|
await LoadTemplatesAsync();
|
|
}
|
|
else
|
|
{
|
|
_toast.ShowError(composed.Error);
|
|
}
|
|
}
|
|
|
|
// Possible parents for a compose: every non-derived template except the source itself.
|
|
// Server still validates cycles + collisions; the picker just trims obvious bad choices.
|
|
private IEnumerable<(int Id, string Label)> EnumerateComposableParents(int sourceId)
|
|
{
|
|
return _templates
|
|
.Where(t => !t.IsDerived && t.Id != sourceId)
|
|
.OrderBy(t => t.Name, StringComparer.OrdinalIgnoreCase)
|
|
.Select(t => (t.Id, t.Name));
|
|
}
|
|
|
|
// ---- Composition leaf: rename + delete ----
|
|
private async Task RenameComposition(TemplateComposition composition)
|
|
{
|
|
var newName = await Dialog.PromptAsync(
|
|
"Rename slot",
|
|
$"New name for slot '{composition.InstanceName}':",
|
|
initialValue: composition.InstanceName,
|
|
placeholder: "Slot name");
|
|
if (string.IsNullOrWhiteSpace(newName) || newName.Trim() == composition.InstanceName) return;
|
|
|
|
var user = await GetCurrentUserAsync();
|
|
var result = await TemplateService.RenameCompositionAsync(composition.Id, newName.Trim(), user);
|
|
if (result.IsSuccess)
|
|
{
|
|
_toast.ShowSuccess($"Slot renamed to '{newName.Trim()}'.");
|
|
await LoadTemplatesAsync();
|
|
}
|
|
else
|
|
{
|
|
_toast.ShowError(result.Error);
|
|
}
|
|
}
|
|
|
|
private async Task DeleteComposition(TemplateComposition composition)
|
|
{
|
|
var confirmed = await Dialog.ConfirmAsync(
|
|
"Delete composition",
|
|
$"Delete slot '{composition.InstanceName}'? This removes the derived template and any overrides on it.",
|
|
danger: true);
|
|
if (!confirmed) return;
|
|
|
|
var user = await GetCurrentUserAsync();
|
|
var result = await TemplateService.DeleteCompositionAsync(composition.Id, user);
|
|
if (result.IsSuccess)
|
|
{
|
|
_toast.ShowSuccess($"Composition '{composition.InstanceName}' removed.");
|
|
await LoadTemplatesAsync();
|
|
}
|
|
else
|
|
{
|
|
_toast.ShowError(result.Error);
|
|
}
|
|
}
|
|
}
|