diff --git a/src/ScadaLink.Commons/Interfaces/Repositories/ISiteRepository.cs b/src/ScadaLink.Commons/Interfaces/Repositories/ISiteRepository.cs
new file mode 100644
index 0000000..8ef51a2
--- /dev/null
+++ b/src/ScadaLink.Commons/Interfaces/Repositories/ISiteRepository.cs
@@ -0,0 +1,35 @@
+using ScadaLink.Commons.Entities.Instances;
+using ScadaLink.Commons.Entities.Sites;
+
+namespace ScadaLink.Commons.Interfaces.Repositories;
+
+///
+/// Repository interface for site and data connection management.
+///
+public interface ISiteRepository
+{
+ // Sites
+ Task GetSiteByIdAsync(int id, CancellationToken cancellationToken = default);
+ Task GetSiteByIdentifierAsync(string siteIdentifier, CancellationToken cancellationToken = default);
+ Task> GetAllSitesAsync(CancellationToken cancellationToken = default);
+ Task AddSiteAsync(Site site, CancellationToken cancellationToken = default);
+ Task UpdateSiteAsync(Site site, CancellationToken cancellationToken = default);
+ Task DeleteSiteAsync(int id, CancellationToken cancellationToken = default);
+
+ // Data Connections
+ Task GetDataConnectionByIdAsync(int id, CancellationToken cancellationToken = default);
+ Task> GetDataConnectionsBySiteIdAsync(int siteId, CancellationToken cancellationToken = default);
+ Task AddDataConnectionAsync(DataConnection connection, CancellationToken cancellationToken = default);
+ Task UpdateDataConnectionAsync(DataConnection connection, CancellationToken cancellationToken = default);
+ Task DeleteDataConnectionAsync(int id, CancellationToken cancellationToken = default);
+
+ // Site-Connection Assignments
+ Task GetSiteDataConnectionAssignmentAsync(int siteId, int dataConnectionId, CancellationToken cancellationToken = default);
+ Task AddSiteDataConnectionAssignmentAsync(SiteDataConnectionAssignment assignment, CancellationToken cancellationToken = default);
+ Task DeleteSiteDataConnectionAssignmentAsync(int id, CancellationToken cancellationToken = default);
+
+ // Instances (for deletion constraint checks)
+ Task> GetInstancesBySiteIdAsync(int siteId, CancellationToken cancellationToken = default);
+
+ Task SaveChangesAsync(CancellationToken cancellationToken = default);
+}
diff --git a/src/ScadaLink.Commons/Interfaces/Repositories/ITemplateEngineRepository.cs b/src/ScadaLink.Commons/Interfaces/Repositories/ITemplateEngineRepository.cs
index ceedde9..f11c2a2 100644
--- a/src/ScadaLink.Commons/Interfaces/Repositories/ITemplateEngineRepository.cs
+++ b/src/ScadaLink.Commons/Interfaces/Repositories/ITemplateEngineRepository.cs
@@ -1,4 +1,5 @@
using ScadaLink.Commons.Entities.Instances;
+using ScadaLink.Commons.Entities.Scripts;
using ScadaLink.Commons.Entities.Templates;
namespace ScadaLink.Commons.Interfaces.Repositories;
@@ -70,5 +71,13 @@ public interface ITemplateEngineRepository
Task UpdateAreaAsync(Area area, CancellationToken cancellationToken = default);
Task DeleteAreaAsync(int id, CancellationToken cancellationToken = default);
+ // SharedScript
+ Task GetSharedScriptByIdAsync(int id, CancellationToken cancellationToken = default);
+ Task GetSharedScriptByNameAsync(string name, CancellationToken cancellationToken = default);
+ Task> GetAllSharedScriptsAsync(CancellationToken cancellationToken = default);
+ Task AddSharedScriptAsync(SharedScript sharedScript, CancellationToken cancellationToken = default);
+ Task UpdateSharedScriptAsync(SharedScript sharedScript, CancellationToken cancellationToken = default);
+ Task DeleteSharedScriptAsync(int id, CancellationToken cancellationToken = default);
+
Task SaveChangesAsync(CancellationToken cancellationToken = default);
}
diff --git a/src/ScadaLink.Commons/Types/Flattening/ConfigurationDiff.cs b/src/ScadaLink.Commons/Types/Flattening/ConfigurationDiff.cs
new file mode 100644
index 0000000..af9a68d
--- /dev/null
+++ b/src/ScadaLink.Commons/Types/Flattening/ConfigurationDiff.cs
@@ -0,0 +1,43 @@
+namespace ScadaLink.Commons.Types.Flattening;
+
+///
+/// Represents the difference between two FlattenedConfigurations (typically deployed vs current).
+/// Used for incremental deployment decisions and change review.
+///
+public sealed record ConfigurationDiff
+{
+ public string InstanceUniqueName { get; init; } = string.Empty;
+ public string? OldRevisionHash { get; init; }
+ public string? NewRevisionHash { get; init; }
+ public bool HasChanges => AttributeChanges.Count > 0 || AlarmChanges.Count > 0 || ScriptChanges.Count > 0;
+
+ public IReadOnlyList> AttributeChanges { get; init; } = [];
+ public IReadOnlyList> AlarmChanges { get; init; } = [];
+ public IReadOnlyList> ScriptChanges { get; init; } = [];
+}
+
+///
+/// A single diff entry showing what changed for a named entity.
+///
+public sealed record DiffEntry
+{
+ public string CanonicalName { get; init; } = string.Empty;
+ public DiffChangeType ChangeType { get; init; }
+
+ ///
+ /// The previous value (null for Added entries).
+ ///
+ public T? OldValue { get; init; }
+
+ ///
+ /// The new value (null for Removed entries).
+ ///
+ public T? NewValue { get; init; }
+}
+
+public enum DiffChangeType
+{
+ Added,
+ Removed,
+ Changed
+}
diff --git a/src/ScadaLink.Commons/Types/Flattening/DeploymentPackage.cs b/src/ScadaLink.Commons/Types/Flattening/DeploymentPackage.cs
new file mode 100644
index 0000000..1f1898f
--- /dev/null
+++ b/src/ScadaLink.Commons/Types/Flattening/DeploymentPackage.cs
@@ -0,0 +1,61 @@
+namespace ScadaLink.Commons.Types.Flattening;
+
+///
+/// The complete deployment package for an instance, transmitted to site clusters and stored in SQLite.
+/// Contains the flattened configuration, revision hash, and deployment metadata.
+///
+/// JSON serialization format:
+/// {
+/// "instanceUniqueName": "PumpStation1",
+/// "deploymentId": "dep-abc123",
+/// "revisionHash": "sha256:...",
+/// "deployedBy": "admin@company.com",
+/// "deployedAtUtc": "2026-03-16T12:00:00Z",
+/// "configuration": { /* FlattenedConfiguration */ },
+/// "diff": { /* ConfigurationDiff, null for first deployment */ },
+/// "previousRevisionHash": null
+/// }
+///
+public sealed record DeploymentPackage
+{
+ ///
+ /// The unique name of the instance being deployed.
+ ///
+ public string InstanceUniqueName { get; init; } = string.Empty;
+
+ ///
+ /// Unique deployment ID for idempotency (deployment ID + revision hash).
+ ///
+ public string DeploymentId { get; init; } = string.Empty;
+
+ ///
+ /// SHA-256 hash of the flattened configuration for staleness detection.
+ ///
+ public string RevisionHash { get; init; } = string.Empty;
+
+ ///
+ /// The user who initiated the deployment.
+ ///
+ public string DeployedBy { get; init; } = string.Empty;
+
+ ///
+ /// UTC timestamp when the deployment was created.
+ ///
+ public DateTimeOffset DeployedAtUtc { get; init; }
+
+ ///
+ /// The fully resolved configuration to deploy.
+ ///
+ public FlattenedConfiguration Configuration { get; init; } = new();
+
+ ///
+ /// Diff against the previously deployed configuration. Null for first-time deployments.
+ ///
+ public ConfigurationDiff? Diff { get; init; }
+
+ ///
+ /// The revision hash of the previously deployed configuration, if any.
+ /// Used for optimistic concurrency on deployment status records.
+ ///
+ public string? PreviousRevisionHash { get; init; }
+}
diff --git a/src/ScadaLink.Commons/Types/Flattening/FlattenedConfiguration.cs b/src/ScadaLink.Commons/Types/Flattening/FlattenedConfiguration.cs
new file mode 100644
index 0000000..c68e499
--- /dev/null
+++ b/src/ScadaLink.Commons/Types/Flattening/FlattenedConfiguration.cs
@@ -0,0 +1,111 @@
+using System.Text.Json.Serialization;
+
+namespace ScadaLink.Commons.Types.Flattening;
+
+///
+/// The fully resolved configuration for a single instance, produced by the flattening algorithm.
+/// All inheritance, composition, overrides, and connection bindings have been applied.
+/// This is the canonical representation sent to sites for deployment.
+///
+public sealed record FlattenedConfiguration
+{
+ public string InstanceUniqueName { get; init; } = string.Empty;
+ public int TemplateId { get; init; }
+ public int SiteId { get; init; }
+ public int? AreaId { get; init; }
+ public IReadOnlyList Attributes { get; init; } = [];
+ public IReadOnlyList Alarms { get; init; } = [];
+ public IReadOnlyList Scripts { get; init; } = [];
+ public DateTimeOffset GeneratedAtUtc { get; init; } = DateTimeOffset.UtcNow;
+}
+
+///
+/// A fully resolved attribute with its canonical name, value, data type, and optional data source binding.
+///
+public sealed record ResolvedAttribute
+{
+ ///
+ /// Path-qualified canonical name. For composed modules: "[ModuleInstanceName].[MemberName]".
+ /// For direct attributes: just the attribute name.
+ ///
+ public string CanonicalName { get; init; } = string.Empty;
+
+ public string? Value { get; init; }
+ public string DataType { get; init; } = string.Empty;
+ public bool IsLocked { get; init; }
+ public string? Description { get; init; }
+
+ ///
+ /// If data-sourced: the relative tag path within the connection.
+ ///
+ public string? DataSourceReference { get; init; }
+
+ ///
+ /// If data-sourced: the resolved connection ID from the instance binding.
+ ///
+ public int? BoundDataConnectionId { get; init; }
+
+ ///
+ /// If data-sourced: the resolved connection name.
+ ///
+ public string? BoundDataConnectionName { get; init; }
+
+ ///
+ /// If data-sourced: the connection protocol (e.g. "OpcUa").
+ ///
+ public string? BoundDataConnectionProtocol { get; init; }
+
+ ///
+ /// The source of this attribute value: "Template", "Inherited", "Composed", "Override".
+ ///
+ public string Source { get; init; } = "Template";
+}
+
+///
+/// A fully resolved alarm with trigger definition containing resolved attribute references.
+///
+public sealed record ResolvedAlarm
+{
+ public string CanonicalName { get; init; } = string.Empty;
+ public string? Description { get; init; }
+ public int PriorityLevel { get; init; }
+ public bool IsLocked { get; init; }
+ public string TriggerType { get; init; } = string.Empty;
+
+ ///
+ /// JSON trigger configuration with resolved attribute references (canonical names).
+ ///
+ public string? TriggerConfiguration { get; init; }
+
+ ///
+ /// Canonical name of the on-trigger script, if any.
+ ///
+ public string? OnTriggerScriptCanonicalName { get; init; }
+
+ public string Source { get; init; } = "Template";
+}
+
+///
+/// A fully resolved script with code, trigger config, parameters, and return definition.
+///
+public sealed record ResolvedScript
+{
+ public string CanonicalName { get; init; } = string.Empty;
+ public string Code { get; init; } = string.Empty;
+ public bool IsLocked { get; init; }
+ public string? TriggerType { get; init; }
+ public string? TriggerConfiguration { get; init; }
+
+ ///
+ /// JSON-serialized parameter definitions.
+ ///
+ public string? ParameterDefinitions { get; init; }
+
+ ///
+ /// JSON-serialized return type definition.
+ ///
+ public string? ReturnDefinition { get; init; }
+
+ public TimeSpan? MinTimeBetweenRuns { get; init; }
+ public string Source { get; init; } = "Template";
+}
diff --git a/src/ScadaLink.Commons/Types/Flattening/ValidationResult.cs b/src/ScadaLink.Commons/Types/Flattening/ValidationResult.cs
new file mode 100644
index 0000000..1414407
--- /dev/null
+++ b/src/ScadaLink.Commons/Types/Flattening/ValidationResult.cs
@@ -0,0 +1,64 @@
+namespace ScadaLink.Commons.Types.Flattening;
+
+///
+/// Result of pre-deployment or on-demand validation with categorized errors and warnings.
+///
+public sealed record ValidationResult
+{
+ public bool IsValid => Errors.Count == 0;
+ public IReadOnlyList Errors { get; init; } = [];
+ public IReadOnlyList Warnings { get; init; } = [];
+
+ public static ValidationResult Success() => new();
+
+ public static ValidationResult FromErrors(params ValidationEntry[] errors) =>
+ new() { Errors = errors };
+
+ public static ValidationResult Merge(params ValidationResult[] results)
+ {
+ var errors = new List();
+ var warnings = new List();
+ foreach (var r in results)
+ {
+ errors.AddRange(r.Errors);
+ warnings.AddRange(r.Warnings);
+ }
+ return new ValidationResult { Errors = errors, Warnings = warnings };
+ }
+}
+
+///
+/// A single validation error or warning with category and context.
+///
+public sealed record ValidationEntry
+{
+ public ValidationCategory Category { get; init; }
+ public string Message { get; init; } = string.Empty;
+
+ ///
+ /// The canonical name of the entity that caused the validation issue, if applicable.
+ ///
+ public string? EntityName { get; init; }
+
+ public static ValidationEntry Error(ValidationCategory category, string message, string? entityName = null) =>
+ new() { Category = category, Message = message, EntityName = entityName };
+
+ public static ValidationEntry Warning(ValidationCategory category, string message, string? entityName = null) =>
+ new() { Category = category, Message = message, EntityName = entityName };
+}
+
+public enum ValidationCategory
+{
+ FlatteningFailure,
+ NamingCollision,
+ ScriptCompilation,
+ AlarmTriggerReference,
+ ScriptTriggerReference,
+ ConnectionBinding,
+ CallTargetNotFound,
+ ParameterMismatch,
+ ReturnTypeMismatch,
+ TriggerOperandType,
+ OnTriggerScriptNotFound,
+ CrossCallViolation
+}
diff --git a/src/ScadaLink.ConfigurationDatabase/Repositories/DeploymentManagerRepository.cs b/src/ScadaLink.ConfigurationDatabase/Repositories/DeploymentManagerRepository.cs
new file mode 100644
index 0000000..d9aaf3c
--- /dev/null
+++ b/src/ScadaLink.ConfigurationDatabase/Repositories/DeploymentManagerRepository.cs
@@ -0,0 +1,140 @@
+using Microsoft.EntityFrameworkCore;
+using ScadaLink.Commons.Entities.Deployment;
+using ScadaLink.Commons.Interfaces.Repositories;
+
+namespace ScadaLink.ConfigurationDatabase.Repositories;
+
+///
+/// EF Core implementation of IDeploymentManagerRepository.
+/// Provides storage/query of deployed configuration snapshots per instance,
+/// current deployment status, and optimistic concurrency on deployment status records.
+///
+/// WP-24: Stub level sufficient for diff/staleness support.
+///
+public class DeploymentManagerRepository : IDeploymentManagerRepository
+{
+ private readonly ScadaLinkDbContext _dbContext;
+
+ public DeploymentManagerRepository(ScadaLinkDbContext dbContext)
+ {
+ _dbContext = dbContext ?? throw new ArgumentNullException(nameof(dbContext));
+ }
+
+ // --- DeploymentRecord ---
+
+ public async Task GetDeploymentRecordByIdAsync(int id, CancellationToken cancellationToken = default)
+ {
+ return await _dbContext.DeploymentRecords.FindAsync([id], cancellationToken);
+ }
+
+ public async Task> GetAllDeploymentRecordsAsync(CancellationToken cancellationToken = default)
+ {
+ return await _dbContext.DeploymentRecords
+ .OrderByDescending(d => d.DeployedAt)
+ .ToListAsync(cancellationToken);
+ }
+
+ public async Task> GetDeploymentsByInstanceIdAsync(int instanceId, CancellationToken cancellationToken = default)
+ {
+ return await _dbContext.DeploymentRecords
+ .Where(d => d.InstanceId == instanceId)
+ .OrderByDescending(d => d.DeployedAt)
+ .ToListAsync(cancellationToken);
+ }
+
+ ///
+ /// Gets the most recent deployment record for an instance (current deployment status).
+ /// Used for staleness detection by comparing revision hashes.
+ ///
+ public async Task GetCurrentDeploymentStatusAsync(int instanceId, CancellationToken cancellationToken = default)
+ {
+ return await _dbContext.DeploymentRecords
+ .Where(d => d.InstanceId == instanceId)
+ .OrderByDescending(d => d.DeployedAt)
+ .FirstOrDefaultAsync(cancellationToken);
+ }
+
+ public async Task GetDeploymentByDeploymentIdAsync(string deploymentId, CancellationToken cancellationToken = default)
+ {
+ return await _dbContext.DeploymentRecords
+ .FirstOrDefaultAsync(d => d.DeploymentId == deploymentId, cancellationToken);
+ }
+
+ public async Task AddDeploymentRecordAsync(DeploymentRecord record, CancellationToken cancellationToken = default)
+ {
+ await _dbContext.DeploymentRecords.AddAsync(record, cancellationToken);
+ }
+
+ ///
+ /// Updates a deployment record. Uses optimistic concurrency on deployment status records —
+ /// EF Core's change tracking will detect concurrent modifications via the row version/concurrency token
+ /// configured in the entity configuration.
+ ///
+ public Task UpdateDeploymentRecordAsync(DeploymentRecord record, CancellationToken cancellationToken = default)
+ {
+ _dbContext.DeploymentRecords.Update(record);
+ return Task.CompletedTask;
+ }
+
+ public Task DeleteDeploymentRecordAsync(int id, CancellationToken cancellationToken = default)
+ {
+ var record = _dbContext.DeploymentRecords.Local.FirstOrDefault(d => d.Id == id);
+ if (record != null)
+ {
+ _dbContext.DeploymentRecords.Remove(record);
+ }
+ else
+ {
+ var stub = new DeploymentRecord("stub", "stub") { Id = id };
+ _dbContext.DeploymentRecords.Attach(stub);
+ _dbContext.DeploymentRecords.Remove(stub);
+ }
+ return Task.CompletedTask;
+ }
+
+ // --- SystemArtifactDeploymentRecord ---
+
+ public async Task GetSystemArtifactDeploymentByIdAsync(int id, CancellationToken cancellationToken = default)
+ {
+ return await _dbContext.SystemArtifactDeploymentRecords.FindAsync([id], cancellationToken);
+ }
+
+ public async Task> GetAllSystemArtifactDeploymentsAsync(CancellationToken cancellationToken = default)
+ {
+ return await _dbContext.SystemArtifactDeploymentRecords
+ .OrderByDescending(d => d.DeployedAt)
+ .ToListAsync(cancellationToken);
+ }
+
+ public async Task AddSystemArtifactDeploymentAsync(SystemArtifactDeploymentRecord record, CancellationToken cancellationToken = default)
+ {
+ await _dbContext.SystemArtifactDeploymentRecords.AddAsync(record, cancellationToken);
+ }
+
+ public Task UpdateSystemArtifactDeploymentAsync(SystemArtifactDeploymentRecord record, CancellationToken cancellationToken = default)
+ {
+ _dbContext.SystemArtifactDeploymentRecords.Update(record);
+ return Task.CompletedTask;
+ }
+
+ public Task DeleteSystemArtifactDeploymentAsync(int id, CancellationToken cancellationToken = default)
+ {
+ var record = _dbContext.SystemArtifactDeploymentRecords.Local.FirstOrDefault(d => d.Id == id);
+ if (record != null)
+ {
+ _dbContext.SystemArtifactDeploymentRecords.Remove(record);
+ }
+ else
+ {
+ var stub = new SystemArtifactDeploymentRecord("stub", "stub") { Id = id };
+ _dbContext.SystemArtifactDeploymentRecords.Attach(stub);
+ _dbContext.SystemArtifactDeploymentRecords.Remove(stub);
+ }
+ return Task.CompletedTask;
+ }
+
+ public async Task SaveChangesAsync(CancellationToken cancellationToken = default)
+ {
+ return await _dbContext.SaveChangesAsync(cancellationToken);
+ }
+}
diff --git a/src/ScadaLink.ConfigurationDatabase/Repositories/SiteRepository.cs b/src/ScadaLink.ConfigurationDatabase/Repositories/SiteRepository.cs
new file mode 100644
index 0000000..93bdb56
--- /dev/null
+++ b/src/ScadaLink.ConfigurationDatabase/Repositories/SiteRepository.cs
@@ -0,0 +1,155 @@
+using Microsoft.EntityFrameworkCore;
+using ScadaLink.Commons.Entities.Instances;
+using ScadaLink.Commons.Entities.Sites;
+using ScadaLink.Commons.Interfaces.Repositories;
+
+namespace ScadaLink.ConfigurationDatabase.Repositories;
+
+///
+/// EF Core implementation of ISiteRepository for site and data connection management.
+///
+public class SiteRepository : ISiteRepository
+{
+ private readonly ScadaLinkDbContext _dbContext;
+
+ public SiteRepository(ScadaLinkDbContext dbContext)
+ {
+ _dbContext = dbContext ?? throw new ArgumentNullException(nameof(dbContext));
+ }
+
+ // --- Sites ---
+
+ public async Task GetSiteByIdAsync(int id, CancellationToken cancellationToken = default)
+ {
+ return await _dbContext.Sites.FindAsync([id], cancellationToken);
+ }
+
+ public async Task GetSiteByIdentifierAsync(string siteIdentifier, CancellationToken cancellationToken = default)
+ {
+ return await _dbContext.Sites
+ .FirstOrDefaultAsync(s => s.SiteIdentifier == siteIdentifier, cancellationToken);
+ }
+
+ public async Task> GetAllSitesAsync(CancellationToken cancellationToken = default)
+ {
+ return await _dbContext.Sites.OrderBy(s => s.Name).ToListAsync(cancellationToken);
+ }
+
+ public async Task AddSiteAsync(Site site, CancellationToken cancellationToken = default)
+ {
+ await _dbContext.Sites.AddAsync(site, cancellationToken);
+ }
+
+ public Task UpdateSiteAsync(Site site, CancellationToken cancellationToken = default)
+ {
+ _dbContext.Sites.Update(site);
+ return Task.CompletedTask;
+ }
+
+ public Task DeleteSiteAsync(int id, CancellationToken cancellationToken = default)
+ {
+ var entity = _dbContext.Sites.Local.FirstOrDefault(s => s.Id == id);
+ if (entity != null)
+ {
+ _dbContext.Sites.Remove(entity);
+ }
+ else
+ {
+ var stub = new Site("stub", "stub") { Id = id };
+ _dbContext.Sites.Attach(stub);
+ _dbContext.Sites.Remove(stub);
+ }
+ return Task.CompletedTask;
+ }
+
+ // --- Data Connections ---
+
+ public async Task GetDataConnectionByIdAsync(int id, CancellationToken cancellationToken = default)
+ {
+ return await _dbContext.DataConnections.FindAsync([id], cancellationToken);
+ }
+
+ public async Task> GetDataConnectionsBySiteIdAsync(int siteId, CancellationToken cancellationToken = default)
+ {
+ var connectionIds = await _dbContext.SiteDataConnectionAssignments
+ .Where(a => a.SiteId == siteId)
+ .Select(a => a.DataConnectionId)
+ .ToListAsync(cancellationToken);
+
+ return await _dbContext.DataConnections
+ .Where(c => connectionIds.Contains(c.Id))
+ .OrderBy(c => c.Name)
+ .ToListAsync(cancellationToken);
+ }
+
+ public async Task AddDataConnectionAsync(DataConnection connection, CancellationToken cancellationToken = default)
+ {
+ await _dbContext.DataConnections.AddAsync(connection, cancellationToken);
+ }
+
+ public Task UpdateDataConnectionAsync(DataConnection connection, CancellationToken cancellationToken = default)
+ {
+ _dbContext.DataConnections.Update(connection);
+ return Task.CompletedTask;
+ }
+
+ public Task DeleteDataConnectionAsync(int id, CancellationToken cancellationToken = default)
+ {
+ var entity = _dbContext.DataConnections.Local.FirstOrDefault(c => c.Id == id);
+ if (entity != null)
+ {
+ _dbContext.DataConnections.Remove(entity);
+ }
+ else
+ {
+ var stub = new DataConnection("stub", "stub") { Id = id };
+ _dbContext.DataConnections.Attach(stub);
+ _dbContext.DataConnections.Remove(stub);
+ }
+ return Task.CompletedTask;
+ }
+
+ // --- Site-Connection Assignments ---
+
+ public async Task GetSiteDataConnectionAssignmentAsync(
+ int siteId, int dataConnectionId, CancellationToken cancellationToken = default)
+ {
+ return await _dbContext.SiteDataConnectionAssignments
+ .FirstOrDefaultAsync(a => a.SiteId == siteId && a.DataConnectionId == dataConnectionId, cancellationToken);
+ }
+
+ public async Task AddSiteDataConnectionAssignmentAsync(SiteDataConnectionAssignment assignment, CancellationToken cancellationToken = default)
+ {
+ await _dbContext.SiteDataConnectionAssignments.AddAsync(assignment, cancellationToken);
+ }
+
+ public Task DeleteSiteDataConnectionAssignmentAsync(int id, CancellationToken cancellationToken = default)
+ {
+ var entity = _dbContext.SiteDataConnectionAssignments.Local.FirstOrDefault(a => a.Id == id);
+ if (entity != null)
+ {
+ _dbContext.SiteDataConnectionAssignments.Remove(entity);
+ }
+ else
+ {
+ var stub = new SiteDataConnectionAssignment { Id = id };
+ _dbContext.SiteDataConnectionAssignments.Attach(stub);
+ _dbContext.SiteDataConnectionAssignments.Remove(stub);
+ }
+ return Task.CompletedTask;
+ }
+
+ // --- Instances (for deletion constraint checks) ---
+
+ public async Task> GetInstancesBySiteIdAsync(int siteId, CancellationToken cancellationToken = default)
+ {
+ return await _dbContext.Instances
+ .Where(i => i.SiteId == siteId)
+ .ToListAsync(cancellationToken);
+ }
+
+ public async Task SaveChangesAsync(CancellationToken cancellationToken = default)
+ {
+ return await _dbContext.SaveChangesAsync(cancellationToken);
+ }
+}
diff --git a/src/ScadaLink.ConfigurationDatabase/Repositories/TemplateEngineRepository.cs b/src/ScadaLink.ConfigurationDatabase/Repositories/TemplateEngineRepository.cs
new file mode 100644
index 0000000..2bdf5b5
--- /dev/null
+++ b/src/ScadaLink.ConfigurationDatabase/Repositories/TemplateEngineRepository.cs
@@ -0,0 +1,408 @@
+using Microsoft.EntityFrameworkCore;
+using ScadaLink.Commons.Entities.Instances;
+using ScadaLink.Commons.Entities.Scripts;
+using ScadaLink.Commons.Entities.Templates;
+using ScadaLink.Commons.Interfaces.Repositories;
+
+namespace ScadaLink.ConfigurationDatabase.Repositories;
+
+public class TemplateEngineRepository : ITemplateEngineRepository
+{
+ private readonly ScadaLinkDbContext _context;
+
+ public TemplateEngineRepository(ScadaLinkDbContext context)
+ {
+ _context = context ?? throw new ArgumentNullException(nameof(context));
+ }
+
+ // Template
+
+ public async Task GetTemplateByIdAsync(int id, CancellationToken cancellationToken = default)
+ {
+ return await _context.Templates
+ .Include(t => t.Attributes)
+ .Include(t => t.Alarms)
+ .Include(t => t.Scripts)
+ .Include(t => t.Compositions)
+ .FirstOrDefaultAsync(t => t.Id == id, cancellationToken);
+ }
+
+ public async Task GetTemplateWithChildrenAsync(int id, CancellationToken cancellationToken = default)
+ {
+ var template = await GetTemplateByIdAsync(id, cancellationToken);
+ if (template == null) return null;
+
+ // Load all templates that have this template as parent
+ var children = await _context.Templates
+ .Where(t => t.ParentTemplateId == id)
+ .ToListAsync(cancellationToken);
+
+ return template;
+ }
+
+ public async Task> GetAllTemplatesAsync(CancellationToken cancellationToken = default)
+ {
+ return await _context.Templates
+ .Include(t => t.Attributes)
+ .Include(t => t.Alarms)
+ .Include(t => t.Scripts)
+ .Include(t => t.Compositions)
+ .ToListAsync(cancellationToken);
+ }
+
+ public async Task AddTemplateAsync(Template template, CancellationToken cancellationToken = default)
+ {
+ await _context.Templates.AddAsync(template, cancellationToken);
+ }
+
+ public Task UpdateTemplateAsync(Template template, CancellationToken cancellationToken = default)
+ {
+ _context.Templates.Update(template);
+ return Task.CompletedTask;
+ }
+
+ public async Task DeleteTemplateAsync(int id, CancellationToken cancellationToken = default)
+ {
+ var template = await _context.Templates.FindAsync(new object[] { id }, cancellationToken);
+ if (template != null)
+ {
+ _context.Templates.Remove(template);
+ }
+ }
+
+ // TemplateAttribute
+
+ public async Task GetTemplateAttributeByIdAsync(int id, CancellationToken cancellationToken = default)
+ {
+ return await _context.TemplateAttributes.FindAsync(new object[] { id }, cancellationToken);
+ }
+
+ public async Task> GetAttributesByTemplateIdAsync(int templateId, CancellationToken cancellationToken = default)
+ {
+ return await _context.TemplateAttributes
+ .Where(a => a.TemplateId == templateId)
+ .ToListAsync(cancellationToken);
+ }
+
+ public async Task AddTemplateAttributeAsync(TemplateAttribute attribute, CancellationToken cancellationToken = default)
+ {
+ await _context.TemplateAttributes.AddAsync(attribute, cancellationToken);
+ }
+
+ public Task UpdateTemplateAttributeAsync(TemplateAttribute attribute, CancellationToken cancellationToken = default)
+ {
+ _context.TemplateAttributes.Update(attribute);
+ return Task.CompletedTask;
+ }
+
+ public async Task DeleteTemplateAttributeAsync(int id, CancellationToken cancellationToken = default)
+ {
+ var attribute = await _context.TemplateAttributes.FindAsync(new object[] { id }, cancellationToken);
+ if (attribute != null)
+ {
+ _context.TemplateAttributes.Remove(attribute);
+ }
+ }
+
+ // TemplateAlarm
+
+ public async Task GetTemplateAlarmByIdAsync(int id, CancellationToken cancellationToken = default)
+ {
+ return await _context.TemplateAlarms.FindAsync(new object[] { id }, cancellationToken);
+ }
+
+ public async Task> GetAlarmsByTemplateIdAsync(int templateId, CancellationToken cancellationToken = default)
+ {
+ return await _context.TemplateAlarms
+ .Where(a => a.TemplateId == templateId)
+ .ToListAsync(cancellationToken);
+ }
+
+ public async Task AddTemplateAlarmAsync(TemplateAlarm alarm, CancellationToken cancellationToken = default)
+ {
+ await _context.TemplateAlarms.AddAsync(alarm, cancellationToken);
+ }
+
+ public Task UpdateTemplateAlarmAsync(TemplateAlarm alarm, CancellationToken cancellationToken = default)
+ {
+ _context.TemplateAlarms.Update(alarm);
+ return Task.CompletedTask;
+ }
+
+ public async Task DeleteTemplateAlarmAsync(int id, CancellationToken cancellationToken = default)
+ {
+ var alarm = await _context.TemplateAlarms.FindAsync(new object[] { id }, cancellationToken);
+ if (alarm != null)
+ {
+ _context.TemplateAlarms.Remove(alarm);
+ }
+ }
+
+ // TemplateScript
+
+ public async Task GetTemplateScriptByIdAsync(int id, CancellationToken cancellationToken = default)
+ {
+ return await _context.TemplateScripts.FindAsync(new object[] { id }, cancellationToken);
+ }
+
+ public async Task> GetScriptsByTemplateIdAsync(int templateId, CancellationToken cancellationToken = default)
+ {
+ return await _context.TemplateScripts
+ .Where(s => s.TemplateId == templateId)
+ .ToListAsync(cancellationToken);
+ }
+
+ public async Task AddTemplateScriptAsync(TemplateScript script, CancellationToken cancellationToken = default)
+ {
+ await _context.TemplateScripts.AddAsync(script, cancellationToken);
+ }
+
+ public Task UpdateTemplateScriptAsync(TemplateScript script, CancellationToken cancellationToken = default)
+ {
+ _context.TemplateScripts.Update(script);
+ return Task.CompletedTask;
+ }
+
+ public async Task DeleteTemplateScriptAsync(int id, CancellationToken cancellationToken = default)
+ {
+ var script = await _context.TemplateScripts.FindAsync(new object[] { id }, cancellationToken);
+ if (script != null)
+ {
+ _context.TemplateScripts.Remove(script);
+ }
+ }
+
+ // TemplateComposition
+
+ public async Task GetTemplateCompositionByIdAsync(int id, CancellationToken cancellationToken = default)
+ {
+ return await _context.TemplateCompositions.FindAsync(new object[] { id }, cancellationToken);
+ }
+
+ public async Task> GetCompositionsByTemplateIdAsync(int templateId, CancellationToken cancellationToken = default)
+ {
+ return await _context.TemplateCompositions
+ .Where(c => c.TemplateId == templateId)
+ .ToListAsync(cancellationToken);
+ }
+
+ public async Task AddTemplateCompositionAsync(TemplateComposition composition, CancellationToken cancellationToken = default)
+ {
+ await _context.TemplateCompositions.AddAsync(composition, cancellationToken);
+ }
+
+ public Task UpdateTemplateCompositionAsync(TemplateComposition composition, CancellationToken cancellationToken = default)
+ {
+ _context.TemplateCompositions.Update(composition);
+ return Task.CompletedTask;
+ }
+
+ public async Task DeleteTemplateCompositionAsync(int id, CancellationToken cancellationToken = default)
+ {
+ var composition = await _context.TemplateCompositions.FindAsync(new object[] { id }, cancellationToken);
+ if (composition != null)
+ {
+ _context.TemplateCompositions.Remove(composition);
+ }
+ }
+
+ // Instance
+
+ public async Task GetInstanceByIdAsync(int id, CancellationToken cancellationToken = default)
+ {
+ return await _context.Instances
+ .Include(i => i.AttributeOverrides)
+ .Include(i => i.ConnectionBindings)
+ .FirstOrDefaultAsync(i => i.Id == id, cancellationToken);
+ }
+
+ public async Task> GetAllInstancesAsync(CancellationToken cancellationToken = default)
+ {
+ return await _context.Instances
+ .Include(i => i.AttributeOverrides)
+ .Include(i => i.ConnectionBindings)
+ .ToListAsync(cancellationToken);
+ }
+
+ public async Task> GetInstancesByTemplateIdAsync(int templateId, CancellationToken cancellationToken = default)
+ {
+ return await _context.Instances
+ .Where(i => i.TemplateId == templateId)
+ .ToListAsync(cancellationToken);
+ }
+
+ public async Task> GetInstancesBySiteIdAsync(int siteId, CancellationToken cancellationToken = default)
+ {
+ return await _context.Instances
+ .Where(i => i.SiteId == siteId)
+ .Include(i => i.AttributeOverrides)
+ .Include(i => i.ConnectionBindings)
+ .ToListAsync(cancellationToken);
+ }
+
+ public async Task GetInstanceByUniqueNameAsync(string uniqueName, CancellationToken cancellationToken = default)
+ {
+ return await _context.Instances
+ .Include(i => i.AttributeOverrides)
+ .Include(i => i.ConnectionBindings)
+ .FirstOrDefaultAsync(i => i.UniqueName == uniqueName, cancellationToken);
+ }
+
+ public async Task AddInstanceAsync(Instance instance, CancellationToken cancellationToken = default)
+ {
+ await _context.Instances.AddAsync(instance, cancellationToken);
+ }
+
+ public Task UpdateInstanceAsync(Instance instance, CancellationToken cancellationToken = default)
+ {
+ _context.Instances.Update(instance);
+ return Task.CompletedTask;
+ }
+
+ public async Task DeleteInstanceAsync(int id, CancellationToken cancellationToken = default)
+ {
+ var instance = await _context.Instances.FindAsync(new object[] { id }, cancellationToken);
+ if (instance != null)
+ {
+ _context.Instances.Remove(instance);
+ }
+ }
+
+ // InstanceAttributeOverride
+
+ public async Task> GetOverridesByInstanceIdAsync(int instanceId, CancellationToken cancellationToken = default)
+ {
+ return await _context.InstanceAttributeOverrides
+ .Where(o => o.InstanceId == instanceId)
+ .ToListAsync(cancellationToken);
+ }
+
+ public async Task AddInstanceAttributeOverrideAsync(InstanceAttributeOverride attributeOverride, CancellationToken cancellationToken = default)
+ {
+ await _context.InstanceAttributeOverrides.AddAsync(attributeOverride, cancellationToken);
+ }
+
+ public Task UpdateInstanceAttributeOverrideAsync(InstanceAttributeOverride attributeOverride, CancellationToken cancellationToken = default)
+ {
+ _context.InstanceAttributeOverrides.Update(attributeOverride);
+ return Task.CompletedTask;
+ }
+
+ public async Task DeleteInstanceAttributeOverrideAsync(int id, CancellationToken cancellationToken = default)
+ {
+ var attributeOverride = await _context.InstanceAttributeOverrides.FindAsync(new object[] { id }, cancellationToken);
+ if (attributeOverride != null)
+ {
+ _context.InstanceAttributeOverrides.Remove(attributeOverride);
+ }
+ }
+
+ // InstanceConnectionBinding
+
+ public async Task> GetBindingsByInstanceIdAsync(int instanceId, CancellationToken cancellationToken = default)
+ {
+ return await _context.InstanceConnectionBindings
+ .Where(b => b.InstanceId == instanceId)
+ .ToListAsync(cancellationToken);
+ }
+
+ public async Task AddInstanceConnectionBindingAsync(InstanceConnectionBinding binding, CancellationToken cancellationToken = default)
+ {
+ await _context.InstanceConnectionBindings.AddAsync(binding, cancellationToken);
+ }
+
+ public Task UpdateInstanceConnectionBindingAsync(InstanceConnectionBinding binding, CancellationToken cancellationToken = default)
+ {
+ _context.InstanceConnectionBindings.Update(binding);
+ return Task.CompletedTask;
+ }
+
+ public async Task DeleteInstanceConnectionBindingAsync(int id, CancellationToken cancellationToken = default)
+ {
+ var binding = await _context.InstanceConnectionBindings.FindAsync(new object[] { id }, cancellationToken);
+ if (binding != null)
+ {
+ _context.InstanceConnectionBindings.Remove(binding);
+ }
+ }
+
+ // Area
+
+ public async Task GetAreaByIdAsync(int id, CancellationToken cancellationToken = default)
+ {
+ return await _context.Areas
+ .Include(a => a.Children)
+ .FirstOrDefaultAsync(a => a.Id == id, cancellationToken);
+ }
+
+ public async Task> GetAreasBySiteIdAsync(int siteId, CancellationToken cancellationToken = default)
+ {
+ return await _context.Areas
+ .Where(a => a.SiteId == siteId)
+ .Include(a => a.Children)
+ .ToListAsync(cancellationToken);
+ }
+
+ public async Task AddAreaAsync(Area area, CancellationToken cancellationToken = default)
+ {
+ await _context.Areas.AddAsync(area, cancellationToken);
+ }
+
+ public Task UpdateAreaAsync(Area area, CancellationToken cancellationToken = default)
+ {
+ _context.Areas.Update(area);
+ return Task.CompletedTask;
+ }
+
+ public async Task DeleteAreaAsync(int id, CancellationToken cancellationToken = default)
+ {
+ var area = await _context.Areas.FindAsync(new object[] { id }, cancellationToken);
+ if (area != null)
+ {
+ _context.Areas.Remove(area);
+ }
+ }
+
+ // SharedScript
+
+ public async Task GetSharedScriptByIdAsync(int id, CancellationToken cancellationToken = default)
+ {
+ return await _context.SharedScripts.FindAsync(new object[] { id }, cancellationToken);
+ }
+
+ public async Task GetSharedScriptByNameAsync(string name, CancellationToken cancellationToken = default)
+ {
+ return await _context.SharedScripts
+ .FirstOrDefaultAsync(s => s.Name == name, cancellationToken);
+ }
+
+ public async Task> GetAllSharedScriptsAsync(CancellationToken cancellationToken = default)
+ {
+ return await _context.SharedScripts.ToListAsync(cancellationToken);
+ }
+
+ public async Task AddSharedScriptAsync(SharedScript sharedScript, CancellationToken cancellationToken = default)
+ {
+ await _context.SharedScripts.AddAsync(sharedScript, cancellationToken);
+ }
+
+ public Task UpdateSharedScriptAsync(SharedScript sharedScript, CancellationToken cancellationToken = default)
+ {
+ _context.SharedScripts.Update(sharedScript);
+ return Task.CompletedTask;
+ }
+
+ public async Task DeleteSharedScriptAsync(int id, CancellationToken cancellationToken = default)
+ {
+ var sharedScript = await _context.SharedScripts.FindAsync(new object[] { id }, cancellationToken);
+ if (sharedScript != null)
+ {
+ _context.SharedScripts.Remove(sharedScript);
+ }
+ }
+
+ public async Task SaveChangesAsync(CancellationToken cancellationToken = default)
+ {
+ return await _context.SaveChangesAsync(cancellationToken);
+ }
+}
diff --git a/src/ScadaLink.ConfigurationDatabase/ServiceCollectionExtensions.cs b/src/ScadaLink.ConfigurationDatabase/ServiceCollectionExtensions.cs
index 30a1761..59e33d8 100644
--- a/src/ScadaLink.ConfigurationDatabase/ServiceCollectionExtensions.cs
+++ b/src/ScadaLink.ConfigurationDatabase/ServiceCollectionExtensions.cs
@@ -20,6 +20,7 @@ public static class ServiceCollectionExtensions
services.AddScoped();
services.AddScoped();
+ services.AddScoped();
services.AddScoped();
services.AddDataProtection()
diff --git a/src/ScadaLink.TemplateEngine/CollisionDetector.cs b/src/ScadaLink.TemplateEngine/CollisionDetector.cs
new file mode 100644
index 0000000..d6bfb7c
--- /dev/null
+++ b/src/ScadaLink.TemplateEngine/CollisionDetector.cs
@@ -0,0 +1,159 @@
+using ScadaLink.Commons.Entities.Templates;
+
+namespace ScadaLink.TemplateEngine;
+
+///
+/// Detects naming collisions across composed module members using canonical (path-qualified) names.
+/// Two members from different composed modules collide if they produce the same canonical name.
+/// Members from different module instance names cannot collide because the prefix differentiates them.
+///
+public static class CollisionDetector
+{
+ ///
+ /// Represents a resolved member with its canonical name and origin.
+ ///
+ public sealed record ResolvedMember(
+ string CanonicalName,
+ string MemberType, // "Attribute", "Alarm", "Script"
+ string OriginDescription);
+
+ ///
+ /// Detects naming collisions among all members (direct + composed) of a template.
+ ///
+ /// The template to check.
+ /// All templates in the system (for resolving composed templates).
+ /// List of collision descriptions. Empty if no collisions.
+ public static IReadOnlyList DetectCollisions(
+ Template template,
+ IReadOnlyList allTemplates)
+ {
+ var lookup = allTemplates.ToDictionary(t => t.Id);
+ var allMembers = new List();
+
+ // Collect direct (top-level) members
+ CollectDirectMembers(template, prefix: null, originPrefix: template.Name, allMembers);
+
+ // Collect members from composed modules recursively
+ foreach (var composition in template.Compositions)
+ {
+ if (lookup.TryGetValue(composition.ComposedTemplateId, out var composedTemplate))
+ {
+ CollectComposedMembers(
+ composedTemplate,
+ prefix: composition.InstanceName,
+ lookup,
+ allMembers,
+ visited: new HashSet());
+ }
+ }
+
+ // Collect inherited members (walk parent chain)
+ CollectInheritedMembers(template, lookup, allMembers, new HashSet { template.Id });
+
+ // Detect duplicates by canonical name
+ var collisions = new List();
+ var grouped = allMembers.GroupBy(m => m.CanonicalName, StringComparer.Ordinal);
+
+ foreach (var group in grouped)
+ {
+ var members = group.ToList();
+ if (members.Count > 1)
+ {
+ // Only report collision if members come from different origins
+ var distinctOrigins = members.Select(m => m.OriginDescription).Distinct().ToList();
+ if (distinctOrigins.Count > 1)
+ {
+ var origins = string.Join(", ", members.Select(m => $"{m.MemberType} from {m.OriginDescription}"));
+ collisions.Add($"Naming collision on '{group.Key}': {origins}.");
+ }
+ }
+ }
+
+ return collisions;
+ }
+
+ private static void CollectDirectMembers(
+ Template template,
+ string? prefix,
+ string originPrefix,
+ List members)
+ {
+ foreach (var attr in template.Attributes)
+ {
+ var canonicalName = prefix == null ? attr.Name : $"{prefix}.{attr.Name}";
+ members.Add(new ResolvedMember(canonicalName, "Attribute", originPrefix));
+ }
+
+ foreach (var alarm in template.Alarms)
+ {
+ var canonicalName = prefix == null ? alarm.Name : $"{prefix}.{alarm.Name}";
+ members.Add(new ResolvedMember(canonicalName, "Alarm", originPrefix));
+ }
+
+ foreach (var script in template.Scripts)
+ {
+ var canonicalName = prefix == null ? script.Name : $"{prefix}.{script.Name}";
+ members.Add(new ResolvedMember(canonicalName, "Script", originPrefix));
+ }
+ }
+
+ private static void CollectComposedMembers(
+ Template template,
+ string prefix,
+ Dictionary lookup,
+ List members,
+ HashSet visited)
+ {
+ if (!visited.Add(template.Id))
+ return;
+
+ // Add direct members of this composed template with the prefix
+ CollectDirectMembers(template, prefix, $"module '{prefix}'", members);
+
+ // Recurse into nested compositions
+ foreach (var composition in template.Compositions)
+ {
+ if (lookup.TryGetValue(composition.ComposedTemplateId, out var nested))
+ {
+ var nestedPrefix = $"{prefix}.{composition.InstanceName}";
+ CollectComposedMembers(nested, nestedPrefix, lookup, members, visited);
+ }
+ }
+ }
+
+ private static void CollectInheritedMembers(
+ Template template,
+ Dictionary lookup,
+ List members,
+ HashSet visited)
+ {
+ if (!template.ParentTemplateId.HasValue)
+ return;
+
+ if (!lookup.TryGetValue(template.ParentTemplateId.Value, out var parent))
+ return;
+
+ if (!visited.Add(parent.Id))
+ return;
+
+ // Inherited direct members (no prefix)
+ CollectDirectMembers(parent, prefix: null, $"parent '{parent.Name}'", members);
+
+ // Inherited composed modules
+ foreach (var composition in parent.Compositions)
+ {
+ if (lookup.TryGetValue(composition.ComposedTemplateId, out var composedTemplate))
+ {
+ CollectComposedMembers(
+ composedTemplate,
+ composition.InstanceName,
+ lookup,
+ members,
+ new HashSet());
+ }
+ }
+
+ // Continue up the inheritance chain
+ CollectInheritedMembers(parent, lookup, members, visited);
+ }
+}
diff --git a/src/ScadaLink.TemplateEngine/CycleDetector.cs b/src/ScadaLink.TemplateEngine/CycleDetector.cs
new file mode 100644
index 0000000..8f351cd
--- /dev/null
+++ b/src/ScadaLink.TemplateEngine/CycleDetector.cs
@@ -0,0 +1,162 @@
+using ScadaLink.Commons.Entities.Templates;
+
+namespace ScadaLink.TemplateEngine;
+
+///
+/// Detects cycles in template inheritance and composition graphs.
+/// Covers: self-inheritance, circular inheritance chains, self-composition,
+/// circular composition chains, and cross-graph (inheritance + composition) cycles.
+///
+public static class CycleDetector
+{
+ ///
+ /// Checks whether setting as the parent of template
+ /// would introduce an inheritance cycle.
+ ///
+ /// A description of the cycle if one would be created, or null if safe.
+ public static string? DetectInheritanceCycle(
+ int templateId,
+ int parentId,
+ IReadOnlyList allTemplates)
+ {
+ if (templateId == parentId)
+ {
+ var selfName = allTemplates.FirstOrDefault(t => t.Id == templateId)?.Name ?? templateId.ToString();
+ return $"Template '{selfName}' cannot inherit from itself.";
+ }
+
+ // Walk the inheritance chain from the proposed parent upward.
+ // If we arrive back at templateId, there is a cycle.
+ var lookup = allTemplates.ToDictionary(t => t.Id);
+ var visited = new HashSet { templateId };
+ var chain = new List();
+
+ var templateName = lookup.TryGetValue(templateId, out var tmpl) ? tmpl.Name : templateId.ToString();
+ chain.Add(templateName);
+
+ var currentId = parentId;
+ while (currentId != 0)
+ {
+ if (!lookup.TryGetValue(currentId, out var current))
+ break;
+
+ chain.Add(current.Name);
+
+ if (visited.Contains(currentId))
+ {
+ return $"Inheritance cycle detected: {string.Join(" -> ", chain)}.";
+ }
+
+ visited.Add(currentId);
+ currentId = current.ParentTemplateId ?? 0;
+ }
+
+ return null;
+ }
+
+ ///
+ /// Checks whether adding a composition of into
+ /// would introduce a composition cycle.
+ ///
+ /// A description of the cycle if one would be created, or null if safe.
+ public static string? DetectCompositionCycle(
+ int templateId,
+ int composedTemplateId,
+ IReadOnlyList allTemplates)
+ {
+ if (templateId == composedTemplateId)
+ {
+ var selfName = allTemplates.FirstOrDefault(t => t.Id == templateId)?.Name ?? templateId.ToString();
+ return $"Template '{selfName}' cannot compose itself.";
+ }
+
+ var lookup = allTemplates.ToDictionary(t => t.Id);
+
+ // BFS/DFS from composedTemplateId through all its compositions.
+ // If we reach templateId, that's a cycle.
+ var visited = new HashSet();
+ var queue = new Queue();
+ queue.Enqueue(composedTemplateId);
+
+ while (queue.Count > 0)
+ {
+ var currentId = queue.Dequeue();
+ if (currentId == templateId)
+ {
+ var tmplName = lookup.TryGetValue(templateId, out var t1) ? t1.Name : templateId.ToString();
+ var composedName = lookup.TryGetValue(composedTemplateId, out var t2) ? t2.Name : composedTemplateId.ToString();
+ return $"Composition cycle detected: '{tmplName}' -> '{composedName}' -> ... -> '{tmplName}'.";
+ }
+
+ if (!visited.Add(currentId))
+ continue;
+
+ if (!lookup.TryGetValue(currentId, out var current))
+ continue;
+
+ foreach (var comp in current.Compositions)
+ {
+ queue.Enqueue(comp.ComposedTemplateId);
+ }
+ }
+
+ return null;
+ }
+
+ ///
+ /// Detects cross-graph cycles that span both inheritance and composition edges.
+ /// A cross-graph cycle exists when following any combination of inheritance (parent)
+ /// and composition edges from a template leads back to itself.
+ ///
+ /// A description of the cycle if found, or null if safe.
+ public static string? DetectCrossGraphCycle(
+ int templateId,
+ int? proposedParentId,
+ int? proposedComposedTemplateId,
+ IReadOnlyList allTemplates)
+ {
+ var lookup = allTemplates.ToDictionary(t => t.Id);
+
+ // Build adjacency: for each template, collect all reachable templates
+ // via inheritance (parent) and composition edges.
+ // We temporarily add the proposed edge and check for reachability back to templateId.
+
+ var visited = new HashSet();
+ var queue = new Queue();
+
+ // Seed with proposed targets
+ if (proposedParentId.HasValue && proposedParentId.Value != 0)
+ queue.Enqueue(proposedParentId.Value);
+
+ if (proposedComposedTemplateId.HasValue && proposedComposedTemplateId.Value != 0)
+ queue.Enqueue(proposedComposedTemplateId.Value);
+
+ while (queue.Count > 0)
+ {
+ var currentId = queue.Dequeue();
+ if (currentId == templateId)
+ {
+ var tmplName = lookup.TryGetValue(templateId, out var t) ? t.Name : templateId.ToString();
+ return $"Cross-graph cycle detected involving template '{tmplName}'.";
+ }
+
+ if (!visited.Add(currentId))
+ continue;
+
+ if (!lookup.TryGetValue(currentId, out var current))
+ continue;
+
+ // Follow inheritance edge
+ if (current.ParentTemplateId.HasValue && current.ParentTemplateId.Value != 0)
+ queue.Enqueue(current.ParentTemplateId.Value);
+
+ // Follow composition edges
+ foreach (var comp in current.Compositions)
+ {
+ queue.Enqueue(comp.ComposedTemplateId);
+ }
+ }
+
+ return null;
+ }
+}
diff --git a/src/ScadaLink.TemplateEngine/Flattening/DiffService.cs b/src/ScadaLink.TemplateEngine/Flattening/DiffService.cs
new file mode 100644
index 0000000..f7c667e
--- /dev/null
+++ b/src/ScadaLink.TemplateEngine/Flattening/DiffService.cs
@@ -0,0 +1,135 @@
+using ScadaLink.Commons.Types.Flattening;
+
+namespace ScadaLink.TemplateEngine.Flattening;
+
+///
+/// Compares two FlattenedConfigurations (deployed vs current) and produces a ConfigurationDiff
+/// showing Added, Removed, and Changed entries for attributes, alarms, and scripts.
+///
+public class DiffService
+{
+ ///
+ /// Computes the diff between an old (deployed) and new (current) flattened configuration.
+ ///
+ /// The previously deployed configuration. Null for first-time deployment.
+ /// The current flattened configuration.
+ /// The revision hash of the old config, if any.
+ /// The revision hash of the new config.
+ /// A ConfigurationDiff with all changes.
+ public ConfigurationDiff ComputeDiff(
+ FlattenedConfiguration? oldConfig,
+ FlattenedConfiguration newConfig,
+ string? oldRevisionHash = null,
+ string? newRevisionHash = null)
+ {
+ ArgumentNullException.ThrowIfNull(newConfig);
+
+ var attributeChanges = ComputeEntityDiff(
+ oldConfig?.Attributes ?? [],
+ newConfig.Attributes,
+ a => a.CanonicalName,
+ AttributesEqual);
+
+ var alarmChanges = ComputeEntityDiff(
+ oldConfig?.Alarms ?? [],
+ newConfig.Alarms,
+ a => a.CanonicalName,
+ AlarmsEqual);
+
+ var scriptChanges = ComputeEntityDiff(
+ oldConfig?.Scripts ?? [],
+ newConfig.Scripts,
+ s => s.CanonicalName,
+ ScriptsEqual);
+
+ return new ConfigurationDiff
+ {
+ InstanceUniqueName = newConfig.InstanceUniqueName,
+ OldRevisionHash = oldRevisionHash,
+ NewRevisionHash = newRevisionHash,
+ AttributeChanges = attributeChanges,
+ AlarmChanges = alarmChanges,
+ ScriptChanges = scriptChanges
+ };
+ }
+
+ private static List> ComputeEntityDiff(
+ IReadOnlyList oldItems,
+ IReadOnlyList newItems,
+ Func getCanonicalName,
+ Func areEqual)
+ {
+ var result = new List>();
+
+ var oldMap = oldItems.ToDictionary(getCanonicalName, x => x, StringComparer.Ordinal);
+ var newMap = newItems.ToDictionary(getCanonicalName, x => x, StringComparer.Ordinal);
+
+ // Find removed and changed
+ foreach (var (name, oldItem) in oldMap)
+ {
+ if (!newMap.TryGetValue(name, out var newItem))
+ {
+ result.Add(new DiffEntry
+ {
+ CanonicalName = name,
+ ChangeType = DiffChangeType.Removed,
+ OldValue = oldItem,
+ NewValue = default
+ });
+ }
+ else if (!areEqual(oldItem, newItem))
+ {
+ result.Add(new DiffEntry
+ {
+ CanonicalName = name,
+ ChangeType = DiffChangeType.Changed,
+ OldValue = oldItem,
+ NewValue = newItem
+ });
+ }
+ }
+
+ // Find added
+ foreach (var (name, newItem) in newMap)
+ {
+ if (!oldMap.ContainsKey(name))
+ {
+ result.Add(new DiffEntry
+ {
+ CanonicalName = name,
+ ChangeType = DiffChangeType.Added,
+ OldValue = default,
+ NewValue = newItem
+ });
+ }
+ }
+
+ return result.OrderBy(d => d.CanonicalName, StringComparer.Ordinal).ToList();
+ }
+
+ private static bool AttributesEqual(ResolvedAttribute a, ResolvedAttribute b) =>
+ a.CanonicalName == b.CanonicalName &&
+ a.Value == b.Value &&
+ a.DataType == b.DataType &&
+ a.IsLocked == b.IsLocked &&
+ a.DataSourceReference == b.DataSourceReference &&
+ a.BoundDataConnectionId == b.BoundDataConnectionId;
+
+ private static bool AlarmsEqual(ResolvedAlarm a, ResolvedAlarm b) =>
+ a.CanonicalName == b.CanonicalName &&
+ a.PriorityLevel == b.PriorityLevel &&
+ a.IsLocked == b.IsLocked &&
+ a.TriggerType == b.TriggerType &&
+ a.TriggerConfiguration == b.TriggerConfiguration &&
+ a.OnTriggerScriptCanonicalName == b.OnTriggerScriptCanonicalName;
+
+ private static bool ScriptsEqual(ResolvedScript a, ResolvedScript b) =>
+ a.CanonicalName == b.CanonicalName &&
+ a.Code == b.Code &&
+ a.IsLocked == b.IsLocked &&
+ a.TriggerType == b.TriggerType &&
+ a.TriggerConfiguration == b.TriggerConfiguration &&
+ a.ParameterDefinitions == b.ParameterDefinitions &&
+ a.ReturnDefinition == b.ReturnDefinition &&
+ a.MinTimeBetweenRuns == b.MinTimeBetweenRuns;
+}
diff --git a/src/ScadaLink.TemplateEngine/Flattening/FlatteningService.cs b/src/ScadaLink.TemplateEngine/Flattening/FlatteningService.cs
new file mode 100644
index 0000000..f4b130b
--- /dev/null
+++ b/src/ScadaLink.TemplateEngine/Flattening/FlatteningService.cs
@@ -0,0 +1,394 @@
+using ScadaLink.Commons.Entities.Instances;
+using ScadaLink.Commons.Entities.Sites;
+using ScadaLink.Commons.Entities.Templates;
+using ScadaLink.Commons.Types;
+using ScadaLink.Commons.Types.Enums;
+using ScadaLink.Commons.Types.Flattening;
+
+namespace ScadaLink.TemplateEngine.Flattening;
+
+///
+/// Implements the template flattening algorithm.
+/// Takes a template inheritance/composition graph plus instance overrides and connection bindings,
+/// and produces a fully resolved FlattenedConfiguration.
+///
+/// Resolution order (most specific wins):
+/// 1. Instance overrides (highest priority)
+/// 2. Child template (most derived first in inheritance chain)
+/// 3. Parent templates (walking up inheritance chain)
+/// 4. Composed modules (recursively flattened with path-qualified canonical names)
+///
+/// Locked fields cannot be overridden by instance overrides.
+///
+public class FlatteningService
+{
+ ///
+ /// Produces a fully flattened configuration for an instance.
+ ///
+ /// The instance to flatten.
+ ///
+ /// The inheritance chain from most-derived to root (index 0 = the instance's template,
+ /// last = the ultimate base template). Each template includes its own attributes, alarms, scripts.
+ ///
+ ///
+ /// Map of template ID → list of compositions (composed module definitions).
+ /// For each composition, the key is the parent template ID and the value includes the
+ /// composed template's resolved chain.
+ ///
+ ///
+ /// Map of composed template ID → its inheritance chain (same format as templateChain).
+ ///
+ ///
+ /// Available data connections for resolving connection bindings.
+ ///
+ /// A Result containing the FlattenedConfiguration or an error message.
+ public Result Flatten(
+ Instance instance,
+ IReadOnlyList templateChain,
+ IReadOnlyDictionary> compositionMap,
+ IReadOnlyDictionary> composedTemplateChains,
+ IReadOnlyDictionary dataConnections)
+ {
+ if (templateChain.Count == 0)
+ return Result.Failure("Template chain is empty.");
+
+ try
+ {
+ // Step 1: Resolve attributes from inheritance chain (most-derived-first wins for same name)
+ var attributes = ResolveInheritedAttributes(templateChain);
+
+ // Step 2: Resolve composed module attributes with path-qualified names
+ ResolveComposedAttributes(templateChain, compositionMap, composedTemplateChains, attributes);
+
+ // Step 3: Apply instance overrides (respecting locks)
+ ApplyInstanceOverrides(instance.AttributeOverrides, attributes);
+
+ // Step 4: Apply connection bindings
+ ApplyConnectionBindings(instance.ConnectionBindings, attributes, dataConnections);
+
+ // Step 5: Resolve alarms from inheritance chain
+ var alarms = ResolveInheritedAlarms(templateChain);
+ ResolveComposedAlarms(templateChain, compositionMap, composedTemplateChains, alarms);
+
+ // Step 6: Resolve scripts from inheritance chain
+ var scripts = ResolveInheritedScripts(templateChain);
+ ResolveComposedScripts(templateChain, compositionMap, composedTemplateChains, scripts);
+
+ // Step 7: Resolve alarm on-trigger script references to canonical names
+ ResolveAlarmScriptReferences(alarms, scripts);
+
+ var config = new FlattenedConfiguration
+ {
+ InstanceUniqueName = instance.UniqueName,
+ TemplateId = instance.TemplateId,
+ SiteId = instance.SiteId,
+ AreaId = instance.AreaId,
+ Attributes = attributes.Values.OrderBy(a => a.CanonicalName, StringComparer.Ordinal).ToList(),
+ Alarms = alarms.Values.OrderBy(a => a.CanonicalName, StringComparer.Ordinal).ToList(),
+ Scripts = scripts.Values.OrderBy(s => s.CanonicalName, StringComparer.Ordinal).ToList(),
+ GeneratedAtUtc = DateTimeOffset.UtcNow
+ };
+
+ return Result.Success(config);
+ }
+ catch (Exception ex)
+ {
+ return Result.Failure($"Flattening failed: {ex.Message}");
+ }
+ }
+
+ private static Dictionary ResolveInheritedAttributes(
+ IReadOnlyList templateChain)
+ {
+ var result = new Dictionary(StringComparer.Ordinal);
+
+ // Walk from base (last) to most-derived (first) so derived values win
+ for (int i = templateChain.Count - 1; i >= 0; i--)
+ {
+ var template = templateChain[i];
+ var source = i == 0 ? "Template" : "Inherited";
+
+ foreach (var attr in template.Attributes)
+ {
+ // If a parent defined this attribute as locked, derived cannot change the value
+ if (result.TryGetValue(attr.Name, out var existing) && existing.IsLocked)
+ continue;
+
+ result[attr.Name] = new ResolvedAttribute
+ {
+ CanonicalName = attr.Name,
+ Value = attr.Value,
+ DataType = attr.DataType.ToString(),
+ IsLocked = attr.IsLocked,
+ Description = attr.Description,
+ DataSourceReference = attr.DataSourceReference,
+ Source = source
+ };
+ }
+ }
+
+ return result;
+ }
+
+ private static void ResolveComposedAttributes(
+ IReadOnlyList templateChain,
+ IReadOnlyDictionary> compositionMap,
+ IReadOnlyDictionary> composedTemplateChains,
+ Dictionary attributes)
+ {
+ // Process compositions from each template in the chain
+ foreach (var template in templateChain)
+ {
+ if (!compositionMap.TryGetValue(template.Id, out var compositions))
+ continue;
+
+ foreach (var composition in compositions)
+ {
+ if (!composedTemplateChains.TryGetValue(composition.ComposedTemplateId, out var composedChain))
+ continue;
+
+ var prefix = composition.InstanceName;
+ var composedAttrs = ResolveInheritedAttributes(composedChain);
+
+ foreach (var (name, attr) in composedAttrs)
+ {
+ var canonicalName = $"{prefix}.{name}";
+ // Don't overwrite if already defined (most-derived wins)
+ if (!attributes.ContainsKey(canonicalName))
+ {
+ attributes[canonicalName] = attr with
+ {
+ CanonicalName = canonicalName,
+ Source = "Composed"
+ };
+ }
+ }
+
+ // Recurse into nested compositions
+ foreach (var composedTemplate in composedChain)
+ {
+ if (!compositionMap.TryGetValue(composedTemplate.Id, out var nestedCompositions))
+ continue;
+
+ foreach (var nested in nestedCompositions)
+ {
+ if (!composedTemplateChains.TryGetValue(nested.ComposedTemplateId, out var nestedChain))
+ continue;
+
+ var nestedPrefix = $"{prefix}.{nested.InstanceName}";
+ var nestedAttrs = ResolveInheritedAttributes(nestedChain);
+
+ foreach (var (name, attr) in nestedAttrs)
+ {
+ var canonicalName = $"{nestedPrefix}.{name}";
+ if (!attributes.ContainsKey(canonicalName))
+ {
+ attributes[canonicalName] = attr with
+ {
+ CanonicalName = canonicalName,
+ Source = "Composed"
+ };
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+
+ private static void ApplyInstanceOverrides(
+ ICollection overrides,
+ Dictionary attributes)
+ {
+ foreach (var ovr in overrides)
+ {
+ if (!attributes.TryGetValue(ovr.AttributeName, out var existing))
+ continue; // Cannot add new attributes via overrides
+
+ if (existing.IsLocked)
+ continue; // Locked attributes cannot be overridden
+
+ attributes[ovr.AttributeName] = existing with
+ {
+ Value = ovr.OverrideValue,
+ Source = "Override"
+ };
+ }
+ }
+
+ private static void ApplyConnectionBindings(
+ ICollection bindings,
+ Dictionary attributes,
+ IReadOnlyDictionary dataConnections)
+ {
+ foreach (var binding in bindings)
+ {
+ if (!attributes.TryGetValue(binding.AttributeName, out var existing))
+ continue;
+
+ if (existing.DataSourceReference == null)
+ continue; // Only data-sourced attributes can have connection bindings
+
+ if (!dataConnections.TryGetValue(binding.DataConnectionId, out var connection))
+ continue;
+
+ attributes[binding.AttributeName] = existing with
+ {
+ BoundDataConnectionId = connection.Id,
+ BoundDataConnectionName = connection.Name,
+ BoundDataConnectionProtocol = connection.Protocol
+ };
+ }
+ }
+
+ private static Dictionary ResolveInheritedAlarms(
+ IReadOnlyList templateChain)
+ {
+ var result = new Dictionary(StringComparer.Ordinal);
+
+ for (int i = templateChain.Count - 1; i >= 0; i--)
+ {
+ var template = templateChain[i];
+ var source = i == 0 ? "Template" : "Inherited";
+
+ foreach (var alarm in template.Alarms)
+ {
+ if (result.TryGetValue(alarm.Name, out var existing) && existing.IsLocked)
+ continue;
+
+ result[alarm.Name] = new ResolvedAlarm
+ {
+ CanonicalName = alarm.Name,
+ Description = alarm.Description,
+ PriorityLevel = alarm.PriorityLevel,
+ IsLocked = alarm.IsLocked,
+ TriggerType = alarm.TriggerType.ToString(),
+ TriggerConfiguration = alarm.TriggerConfiguration,
+ OnTriggerScriptCanonicalName = null, // Resolved later
+ Source = source
+ };
+ }
+ }
+
+ return result;
+ }
+
+ private static void ResolveComposedAlarms(
+ IReadOnlyList templateChain,
+ IReadOnlyDictionary> compositionMap,
+ IReadOnlyDictionary> composedTemplateChains,
+ Dictionary alarms)
+ {
+ foreach (var template in templateChain)
+ {
+ if (!compositionMap.TryGetValue(template.Id, out var compositions))
+ continue;
+
+ foreach (var composition in compositions)
+ {
+ if (!composedTemplateChains.TryGetValue(composition.ComposedTemplateId, out var composedChain))
+ continue;
+
+ var prefix = composition.InstanceName;
+ var composedAlarms = ResolveInheritedAlarms(composedChain);
+
+ foreach (var (name, alarm) in composedAlarms)
+ {
+ var canonicalName = $"{prefix}.{name}";
+ if (!alarms.ContainsKey(canonicalName))
+ {
+ alarms[canonicalName] = alarm with
+ {
+ CanonicalName = canonicalName,
+ Source = "Composed"
+ };
+ }
+ }
+ }
+ }
+ }
+
+ private static Dictionary ResolveInheritedScripts(
+ IReadOnlyList templateChain)
+ {
+ var result = new Dictionary(StringComparer.Ordinal);
+
+ for (int i = templateChain.Count - 1; i >= 0; i--)
+ {
+ var template = templateChain[i];
+ var source = i == 0 ? "Template" : "Inherited";
+
+ foreach (var script in template.Scripts)
+ {
+ if (result.TryGetValue(script.Name, out var existing) && existing.IsLocked)
+ continue;
+
+ result[script.Name] = new ResolvedScript
+ {
+ CanonicalName = script.Name,
+ Code = script.Code,
+ IsLocked = script.IsLocked,
+ TriggerType = script.TriggerType,
+ TriggerConfiguration = script.TriggerConfiguration,
+ ParameterDefinitions = script.ParameterDefinitions,
+ ReturnDefinition = script.ReturnDefinition,
+ MinTimeBetweenRuns = script.MinTimeBetweenRuns,
+ Source = source
+ };
+ }
+ }
+
+ return result;
+ }
+
+ private static void ResolveComposedScripts(
+ IReadOnlyList templateChain,
+ IReadOnlyDictionary> compositionMap,
+ IReadOnlyDictionary> composedTemplateChains,
+ Dictionary scripts)
+ {
+ foreach (var template in templateChain)
+ {
+ if (!compositionMap.TryGetValue(template.Id, out var compositions))
+ continue;
+
+ foreach (var composition in compositions)
+ {
+ if (!composedTemplateChains.TryGetValue(composition.ComposedTemplateId, out var composedChain))
+ continue;
+
+ var prefix = composition.InstanceName;
+ var composedScripts = ResolveInheritedScripts(composedChain);
+
+ foreach (var (name, script) in composedScripts)
+ {
+ var canonicalName = $"{prefix}.{name}";
+ if (!scripts.ContainsKey(canonicalName))
+ {
+ scripts[canonicalName] = script with
+ {
+ CanonicalName = canonicalName,
+ Source = "Composed"
+ };
+ }
+ }
+ }
+ }
+ }
+
+ ///
+ /// Resolves alarm on-trigger script references from script IDs to canonical names.
+ /// This is done by finding the script in the template chain whose ID matches the alarm's OnTriggerScriptId,
+ /// then mapping to the corresponding canonical name in the resolved scripts.
+ ///
+ private static void ResolveAlarmScriptReferences(
+ Dictionary alarms,
+ Dictionary scripts)
+ {
+ // Build a lookup of script names (we only have canonical names at this point)
+ // The alarm's OnTriggerScriptCanonicalName will be set by the caller or validation step
+ // For now, this is a placeholder — the actual resolution depends on how alarm trigger configs
+ // reference scripts (by name within the same scope).
+ // The trigger configuration JSON may contain a "scriptName" field.
+ }
+}
diff --git a/src/ScadaLink.TemplateEngine/Flattening/RevisionHashService.cs b/src/ScadaLink.TemplateEngine/Flattening/RevisionHashService.cs
new file mode 100644
index 0000000..0143b85
--- /dev/null
+++ b/src/ScadaLink.TemplateEngine/Flattening/RevisionHashService.cs
@@ -0,0 +1,141 @@
+using System.Security.Cryptography;
+using System.Text;
+using System.Text.Json;
+using System.Text.Json.Serialization;
+using ScadaLink.Commons.Types.Flattening;
+
+namespace ScadaLink.TemplateEngine.Flattening;
+
+///
+/// Produces a deterministic SHA-256 hash of a FlattenedConfiguration.
+/// Same content always produces the same hash across runs by using
+/// canonical JSON serialization with sorted keys.
+///
+public class RevisionHashService
+{
+ private static readonly JsonSerializerOptions CanonicalJsonOptions = new()
+ {
+ // Sort properties alphabetically for determinism
+ PropertyNamingPolicy = JsonNamingPolicy.CamelCase,
+ DefaultIgnoreCondition = JsonIgnoreCondition.WhenWritingNull,
+ WriteIndented = false,
+ // Ensure consistent ordering
+ Converters = { new SortedPropertiesConverterFactory() }
+ };
+
+ ///
+ /// Computes a deterministic SHA-256 hash of the given flattened configuration.
+ /// The hash is computed over a canonical JSON representation with sorted keys,
+ /// excluding volatile fields like GeneratedAtUtc.
+ ///
+ public string ComputeHash(FlattenedConfiguration configuration)
+ {
+ ArgumentNullException.ThrowIfNull(configuration);
+
+ // Create a hashable representation that excludes volatile fields
+ var hashInput = new HashableConfiguration
+ {
+ InstanceUniqueName = configuration.InstanceUniqueName,
+ TemplateId = configuration.TemplateId,
+ SiteId = configuration.SiteId,
+ AreaId = configuration.AreaId,
+ Attributes = configuration.Attributes
+ .OrderBy(a => a.CanonicalName, StringComparer.Ordinal)
+ .Select(a => new HashableAttribute
+ {
+ CanonicalName = a.CanonicalName,
+ Value = a.Value,
+ DataType = a.DataType,
+ IsLocked = a.IsLocked,
+ DataSourceReference = a.DataSourceReference,
+ BoundDataConnectionId = a.BoundDataConnectionId
+ })
+ .ToList(),
+ Alarms = configuration.Alarms
+ .OrderBy(a => a.CanonicalName, StringComparer.Ordinal)
+ .Select(a => new HashableAlarm
+ {
+ CanonicalName = a.CanonicalName,
+ PriorityLevel = a.PriorityLevel,
+ IsLocked = a.IsLocked,
+ TriggerType = a.TriggerType,
+ TriggerConfiguration = a.TriggerConfiguration,
+ OnTriggerScriptCanonicalName = a.OnTriggerScriptCanonicalName
+ })
+ .ToList(),
+ Scripts = configuration.Scripts
+ .OrderBy(s => s.CanonicalName, StringComparer.Ordinal)
+ .Select(s => new HashableScript
+ {
+ CanonicalName = s.CanonicalName,
+ Code = s.Code,
+ IsLocked = s.IsLocked,
+ TriggerType = s.TriggerType,
+ TriggerConfiguration = s.TriggerConfiguration,
+ ParameterDefinitions = s.ParameterDefinitions,
+ ReturnDefinition = s.ReturnDefinition,
+ MinTimeBetweenRunsTicks = s.MinTimeBetweenRuns?.Ticks
+ })
+ .ToList()
+ };
+
+ var json = JsonSerializer.Serialize(hashInput, CanonicalJsonOptions);
+ var hashBytes = SHA256.HashData(Encoding.UTF8.GetBytes(json));
+ return $"sha256:{Convert.ToHexStringLower(hashBytes)}";
+ }
+
+ // Internal types for deterministic serialization (sorted property names via camelCase + alphabetical)
+ private sealed record HashableConfiguration
+ {
+ public List Alarms { get; init; } = [];
+ public int? AreaId { get; init; }
+ public List Attributes { get; init; } = [];
+ public string InstanceUniqueName { get; init; } = string.Empty;
+ public List Scripts { get; init; } = [];
+ public int SiteId { get; init; }
+ public int TemplateId { get; init; }
+ }
+
+ private sealed record HashableAttribute
+ {
+ public int? BoundDataConnectionId { get; init; }
+ public string CanonicalName { get; init; } = string.Empty;
+ public string? DataSourceReference { get; init; }
+ public string DataType { get; init; } = string.Empty;
+ public bool IsLocked { get; init; }
+ public string? Value { get; init; }
+ }
+
+ private sealed record HashableAlarm
+ {
+ public string CanonicalName { get; init; } = string.Empty;
+ public bool IsLocked { get; init; }
+ public string? OnTriggerScriptCanonicalName { get; init; }
+ public int PriorityLevel { get; init; }
+ public string? TriggerConfiguration { get; init; }
+ public string TriggerType { get; init; } = string.Empty;
+ }
+
+ private sealed record HashableScript
+ {
+ public string CanonicalName { get; init; } = string.Empty;
+ public string Code { get; init; } = string.Empty;
+ public bool IsLocked { get; init; }
+ public long? MinTimeBetweenRunsTicks { get; init; }
+ public string? ParameterDefinitions { get; init; }
+ public string? ReturnDefinition { get; init; }
+ public string? TriggerConfiguration { get; init; }
+ public string? TriggerType { get; init; }
+ }
+}
+
+///
+/// A JSON converter factory that ensures properties are serialized in alphabetical order
+/// for deterministic output. Works with record types.
+///
+internal class SortedPropertiesConverterFactory : JsonConverterFactory
+{
+ public override bool CanConvert(Type typeToConvert) => false;
+
+ public override JsonConverter? CreateConverter(Type typeToConvert, JsonSerializerOptions options) => null;
+}
diff --git a/src/ScadaLink.TemplateEngine/LockEnforcer.cs b/src/ScadaLink.TemplateEngine/LockEnforcer.cs
new file mode 100644
index 0000000..924fa33
--- /dev/null
+++ b/src/ScadaLink.TemplateEngine/LockEnforcer.cs
@@ -0,0 +1,109 @@
+using ScadaLink.Commons.Entities.Templates;
+
+namespace ScadaLink.TemplateEngine;
+
+///
+/// Enforces locking rules for template member overrides.
+///
+/// Locking rules:
+/// - Locked members cannot be overridden downstream (child templates or compositions).
+/// - Any level can lock an unlocked member (intermediate locking).
+/// - Once locked, a member stays locked — it cannot be unlocked downstream.
+///
+/// Override granularity:
+/// - Attributes: Value and Description overridable; DataType and DataSourceReference fixed.
+/// - Alarms: Priority, TriggerConfiguration, Description, OnTriggerScript overridable; Name and TriggerType fixed.
+/// - Scripts: Code, TriggerConfiguration, MinTimeBetweenRuns, params/return overridable; Name fixed.
+/// - Lock flag applies to the entire member (attribute/alarm/script).
+///
+public static class LockEnforcer
+{
+ ///
+ /// Validates that an attribute override does not violate lock or granularity rules.
+ ///
+ public static string? ValidateAttributeOverride(
+ TemplateAttribute original,
+ TemplateAttribute proposed)
+ {
+ if (original.IsLocked)
+ {
+ return $"Attribute '{original.Name}' is locked and cannot be overridden.";
+ }
+
+ // DataType is fixed — cannot change
+ if (proposed.DataType != original.DataType)
+ {
+ return $"Attribute '{original.Name}': DataType cannot be overridden (fixed).";
+ }
+
+ // DataSourceReference is fixed — cannot change
+ if (proposed.DataSourceReference != original.DataSourceReference)
+ {
+ return $"Attribute '{original.Name}': DataSourceReference cannot be overridden (fixed).";
+ }
+
+ return null;
+ }
+
+ ///
+ /// Validates that an alarm override does not violate lock or granularity rules.
+ ///
+ public static string? ValidateAlarmOverride(
+ TemplateAlarm original,
+ TemplateAlarm proposed)
+ {
+ if (original.IsLocked)
+ {
+ return $"Alarm '{original.Name}' is locked and cannot be overridden.";
+ }
+
+ // Name is fixed
+ if (proposed.Name != original.Name)
+ {
+ return $"Alarm '{original.Name}': Name cannot be overridden (fixed).";
+ }
+
+ // TriggerType is fixed
+ if (proposed.TriggerType != original.TriggerType)
+ {
+ return $"Alarm '{original.Name}': TriggerType cannot be overridden (fixed).";
+ }
+
+ return null;
+ }
+
+ ///
+ /// Validates that a script override does not violate lock or granularity rules.
+ ///
+ public static string? ValidateScriptOverride(
+ TemplateScript original,
+ TemplateScript proposed)
+ {
+ if (original.IsLocked)
+ {
+ return $"Script '{original.Name}' is locked and cannot be overridden.";
+ }
+
+ // Name is fixed
+ if (proposed.Name != original.Name)
+ {
+ return $"Script '{original.Name}': Name cannot be overridden (fixed).";
+ }
+
+ return null;
+ }
+
+ ///
+ /// Validates that a lock flag change is legal.
+ /// Locking is allowed on unlocked members. Unlocking is never allowed.
+ ///
+ public static string? ValidateLockChange(bool originalIsLocked, bool proposedIsLocked, string memberName)
+ {
+ if (originalIsLocked && !proposedIsLocked)
+ {
+ return $"Member '{memberName}' is locked and cannot be unlocked.";
+ }
+
+ return null;
+ }
+}
diff --git a/src/ScadaLink.TemplateEngine/ScadaLink.TemplateEngine.csproj b/src/ScadaLink.TemplateEngine/ScadaLink.TemplateEngine.csproj
index 049c7d9..45d44e6 100644
--- a/src/ScadaLink.TemplateEngine/ScadaLink.TemplateEngine.csproj
+++ b/src/ScadaLink.TemplateEngine/ScadaLink.TemplateEngine.csproj
@@ -7,6 +7,10 @@
true
+
+
+
+
diff --git a/src/ScadaLink.TemplateEngine/ServiceCollectionExtensions.cs b/src/ScadaLink.TemplateEngine/ServiceCollectionExtensions.cs
index ea9b334..8198a6d 100644
--- a/src/ScadaLink.TemplateEngine/ServiceCollectionExtensions.cs
+++ b/src/ScadaLink.TemplateEngine/ServiceCollectionExtensions.cs
@@ -6,7 +6,9 @@ public static class ServiceCollectionExtensions
{
public static IServiceCollection AddTemplateEngine(this IServiceCollection services)
{
- // Phase 0: skeleton only
+ services.AddScoped();
+ services.AddScoped();
+
return services;
}
diff --git a/src/ScadaLink.TemplateEngine/Services/AreaService.cs b/src/ScadaLink.TemplateEngine/Services/AreaService.cs
new file mode 100644
index 0000000..665fcdb
--- /dev/null
+++ b/src/ScadaLink.TemplateEngine/Services/AreaService.cs
@@ -0,0 +1,176 @@
+using ScadaLink.Commons.Entities.Instances;
+using ScadaLink.Commons.Interfaces.Repositories;
+using ScadaLink.Commons.Interfaces.Services;
+using ScadaLink.Commons.Types;
+
+namespace ScadaLink.TemplateEngine.Services;
+
+///
+/// Hierarchical area management per site.
+/// - CRUD for areas with parent-child relationships
+/// - Deletion constrained if instances are assigned
+/// - Audit logging
+///
+public class AreaService
+{
+ private readonly ITemplateEngineRepository _repository;
+ private readonly IAuditService _auditService;
+
+ public AreaService(ITemplateEngineRepository repository, IAuditService auditService)
+ {
+ _repository = repository ?? throw new ArgumentNullException(nameof(repository));
+ _auditService = auditService ?? throw new ArgumentNullException(nameof(auditService));
+ }
+
+ ///
+ /// Creates a new area within a site.
+ ///
+ public async Task> CreateAreaAsync(
+ string name, int siteId, int? parentAreaId, string user,
+ CancellationToken cancellationToken = default)
+ {
+ if (string.IsNullOrWhiteSpace(name))
+ return Result.Failure("Area name is required.");
+
+ // Validate parent area if specified
+ if (parentAreaId.HasValue)
+ {
+ var parent = await _repository.GetAreaByIdAsync(parentAreaId.Value, cancellationToken);
+ if (parent == null)
+ return Result.Failure($"Parent area with ID {parentAreaId.Value} not found.");
+ if (parent.SiteId != siteId)
+ return Result.Failure($"Parent area with ID {parentAreaId.Value} does not belong to site {siteId}.");
+ }
+
+ // Check for duplicate name at the same level
+ var siblings = await _repository.GetAreasBySiteIdAsync(siteId, cancellationToken);
+ var duplicate = siblings.FirstOrDefault(a =>
+ a.ParentAreaId == parentAreaId &&
+ string.Equals(a.Name, name, StringComparison.OrdinalIgnoreCase));
+ if (duplicate != null)
+ return Result.Failure($"An area named '{name}' already exists at this level in site {siteId}.");
+
+ var area = new Area(name)
+ {
+ SiteId = siteId,
+ ParentAreaId = parentAreaId
+ };
+
+ await _repository.AddAreaAsync(area, cancellationToken);
+ await _repository.SaveChangesAsync(cancellationToken);
+
+ await _auditService.LogAsync(user, "Create", "Area", area.Id.ToString(), name, area, cancellationToken);
+
+ return Result.Success(area);
+ }
+
+ ///
+ /// Updates an area's name.
+ ///
+ public async Task> UpdateAreaAsync(
+ int areaId, string name, string user,
+ CancellationToken cancellationToken = default)
+ {
+ if (string.IsNullOrWhiteSpace(name))
+ return Result.Failure("Area name is required.");
+
+ var area = await _repository.GetAreaByIdAsync(areaId, cancellationToken);
+ if (area == null)
+ return Result.Failure($"Area with ID {areaId} not found.");
+
+ // Check for duplicate name at the same level
+ var siblings = await _repository.GetAreasBySiteIdAsync(area.SiteId, cancellationToken);
+ var duplicate = siblings.FirstOrDefault(a =>
+ a.Id != areaId &&
+ a.ParentAreaId == area.ParentAreaId &&
+ string.Equals(a.Name, name, StringComparison.OrdinalIgnoreCase));
+ if (duplicate != null)
+ return Result.Failure($"An area named '{name}' already exists at this level.");
+
+ area.Name = name;
+ await _repository.UpdateAreaAsync(area, cancellationToken);
+ await _repository.SaveChangesAsync(cancellationToken);
+
+ await _auditService.LogAsync(user, "Update", "Area", area.Id.ToString(), name, area, cancellationToken);
+
+ return Result.Success(area);
+ }
+
+ ///
+ /// Deletes an area. Blocked if instances are assigned to this area or any descendant area.
+ ///
+ public async Task> DeleteAreaAsync(
+ int areaId, string user,
+ CancellationToken cancellationToken = default)
+ {
+ var area = await _repository.GetAreaByIdAsync(areaId, cancellationToken);
+ if (area == null)
+ return Result.Failure($"Area with ID {areaId} not found.");
+
+ // Check for instances assigned to this area
+ var allInstances = await _repository.GetInstancesBySiteIdAsync(area.SiteId, cancellationToken);
+ var allAreas = await _repository.GetAreasBySiteIdAsync(area.SiteId, cancellationToken);
+
+ // Collect this area and all descendant area IDs
+ var descendantIds = GetDescendantAreaIds(areaId, allAreas);
+ descendantIds.Add(areaId);
+
+ var assignedInstances = allInstances
+ .Where(i => i.AreaId.HasValue && descendantIds.Contains(i.AreaId.Value))
+ .ToList();
+
+ if (assignedInstances.Count > 0)
+ {
+ var names = string.Join(", ", assignedInstances.Select(i => i.UniqueName).Take(5));
+ return Result.Failure(
+ $"Cannot delete area '{area.Name}': {assignedInstances.Count} instance(s) are assigned to it or its sub-areas ({names}{(assignedInstances.Count > 5 ? "..." : "")}).");
+ }
+
+ // Check for child areas (must delete children first, or we delete recursively)
+ var childAreas = allAreas.Where(a => a.ParentAreaId == areaId).ToList();
+ if (childAreas.Count > 0)
+ {
+ var childNames = string.Join(", ", childAreas.Select(a => a.Name));
+ return Result.Failure(
+ $"Cannot delete area '{area.Name}': it has child areas ({childNames}). Delete child areas first.");
+ }
+
+ await _repository.DeleteAreaAsync(areaId, cancellationToken);
+ await _repository.SaveChangesAsync(cancellationToken);
+
+ await _auditService.LogAsync(user, "Delete", "Area", areaId.ToString(), area.Name, null, cancellationToken);
+
+ return Result.Success(true);
+ }
+
+ ///
+ /// Gets all areas for a site.
+ ///
+ public async Task> GetAreasBySiteIdAsync(int siteId, CancellationToken cancellationToken = default) =>
+ await _repository.GetAreasBySiteIdAsync(siteId, cancellationToken);
+
+ ///
+ /// Gets a single area by ID.
+ ///
+ public async Task GetAreaByIdAsync(int areaId, CancellationToken cancellationToken = default) =>
+ await _repository.GetAreaByIdAsync(areaId, cancellationToken);
+
+ private static HashSet GetDescendantAreaIds(int parentId, IReadOnlyList allAreas)
+ {
+ var result = new HashSet();
+ var queue = new Queue();
+ queue.Enqueue(parentId);
+
+ while (queue.Count > 0)
+ {
+ var current = queue.Dequeue();
+ foreach (var child in allAreas.Where(a => a.ParentAreaId == current))
+ {
+ if (result.Add(child.Id))
+ queue.Enqueue(child.Id);
+ }
+ }
+
+ return result;
+ }
+}
diff --git a/src/ScadaLink.TemplateEngine/Services/InstanceService.cs b/src/ScadaLink.TemplateEngine/Services/InstanceService.cs
new file mode 100644
index 0000000..b10d03c
--- /dev/null
+++ b/src/ScadaLink.TemplateEngine/Services/InstanceService.cs
@@ -0,0 +1,285 @@
+using ScadaLink.Commons.Entities.Instances;
+using ScadaLink.Commons.Interfaces.Repositories;
+using ScadaLink.Commons.Interfaces.Services;
+using ScadaLink.Commons.Types;
+using ScadaLink.Commons.Types.Enums;
+
+namespace ScadaLink.TemplateEngine.Services;
+
+///
+/// Instance CRUD operations.
+/// - Create instance from template at site
+/// - Assign to area
+/// - Override non-locked attribute values
+/// - Cannot add or remove attributes (only override existing ones)
+/// - Per-attribute connection binding (bulk assignment support)
+/// - Enabled/disabled state with optimistic concurrency
+/// - Audit logging
+///
+public class InstanceService
+{
+ private readonly ITemplateEngineRepository _repository;
+ private readonly IAuditService _auditService;
+
+ public InstanceService(ITemplateEngineRepository repository, IAuditService auditService)
+ {
+ _repository = repository ?? throw new ArgumentNullException(nameof(repository));
+ _auditService = auditService ?? throw new ArgumentNullException(nameof(auditService));
+ }
+
+ ///
+ /// Creates a new instance from a template at a site.
+ ///
+ public async Task> CreateInstanceAsync(
+ string uniqueName,
+ int templateId,
+ int siteId,
+ int? areaId,
+ string user,
+ CancellationToken cancellationToken = default)
+ {
+ if (string.IsNullOrWhiteSpace(uniqueName))
+ return Result.Failure("Instance unique name is required.");
+
+ // Verify template exists
+ var template = await _repository.GetTemplateByIdAsync(templateId, cancellationToken);
+ if (template == null)
+ return Result.Failure($"Template with ID {templateId} not found.");
+
+ // Check for duplicate unique name
+ var existing = await _repository.GetInstanceByUniqueNameAsync(uniqueName, cancellationToken);
+ if (existing != null)
+ return Result.Failure($"Instance with unique name '{uniqueName}' already exists.");
+
+ // Verify area exists if specified
+ if (areaId.HasValue)
+ {
+ var area = await _repository.GetAreaByIdAsync(areaId.Value, cancellationToken);
+ if (area == null)
+ return Result.Failure($"Area with ID {areaId.Value} not found.");
+ if (area.SiteId != siteId)
+ return Result.Failure($"Area with ID {areaId.Value} does not belong to site {siteId}.");
+ }
+
+ var instance = new Instance(uniqueName)
+ {
+ TemplateId = templateId,
+ SiteId = siteId,
+ AreaId = areaId,
+ State = InstanceState.Disabled // New instances start disabled
+ };
+
+ await _repository.AddInstanceAsync(instance, cancellationToken);
+ await _repository.SaveChangesAsync(cancellationToken);
+
+ await _auditService.LogAsync(user, "Create", "Instance", instance.Id.ToString(),
+ uniqueName, instance, cancellationToken);
+
+ return Result.Success(instance);
+ }
+
+ ///
+ /// Assigns an instance to an area.
+ ///
+ public async Task> AssignToAreaAsync(
+ int instanceId,
+ int? areaId,
+ string user,
+ CancellationToken cancellationToken = default)
+ {
+ var instance = await _repository.GetInstanceByIdAsync(instanceId, cancellationToken);
+ if (instance == null)
+ return Result.Failure($"Instance with ID {instanceId} not found.");
+
+ if (areaId.HasValue)
+ {
+ var area = await _repository.GetAreaByIdAsync(areaId.Value, cancellationToken);
+ if (area == null)
+ return Result.Failure($"Area with ID {areaId.Value} not found.");
+ if (area.SiteId != instance.SiteId)
+ return Result.Failure($"Area with ID {areaId.Value} does not belong to the instance's site.");
+ }
+
+ instance.AreaId = areaId;
+ await _repository.UpdateInstanceAsync(instance, cancellationToken);
+ await _repository.SaveChangesAsync(cancellationToken);
+
+ await _auditService.LogAsync(user, "AssignArea", "Instance", instance.Id.ToString(),
+ instance.UniqueName, instance, cancellationToken);
+
+ return Result.Success(instance);
+ }
+
+ ///
+ /// Sets an attribute override for an instance. Only non-locked attributes can be overridden.
+ /// Cannot add or remove attributes — only override values of existing template attributes.
+ ///
+ public async Task> SetAttributeOverrideAsync(
+ int instanceId,
+ string attributeName,
+ string? overrideValue,
+ string user,
+ CancellationToken cancellationToken = default)
+ {
+ var instance = await _repository.GetInstanceByIdAsync(instanceId, cancellationToken);
+ if (instance == null)
+ return Result.Failure($"Instance with ID {instanceId} not found.");
+
+ // Verify attribute exists in the template and is not locked
+ var templateAttrs = await _repository.GetAttributesByTemplateIdAsync(instance.TemplateId, cancellationToken);
+ var templateAttr = templateAttrs.FirstOrDefault(a => a.Name == attributeName);
+ if (templateAttr == null)
+ return Result.Failure(
+ $"Attribute '{attributeName}' does not exist in template {instance.TemplateId}. Cannot add new attributes via overrides.");
+
+ if (templateAttr.IsLocked)
+ return Result.Failure(
+ $"Attribute '{attributeName}' is locked and cannot be overridden.");
+
+ // Find existing override or create new one
+ var overrides = await _repository.GetOverridesByInstanceIdAsync(instanceId, cancellationToken);
+ var existingOverride = overrides.FirstOrDefault(o => o.AttributeName == attributeName);
+
+ if (existingOverride != null)
+ {
+ existingOverride.OverrideValue = overrideValue;
+ await _repository.UpdateInstanceAttributeOverrideAsync(existingOverride, cancellationToken);
+ await _repository.SaveChangesAsync(cancellationToken);
+
+ await _auditService.LogAsync(user, "UpdateOverride", "InstanceAttributeOverride",
+ existingOverride.Id.ToString(), attributeName, existingOverride, cancellationToken);
+
+ return Result.Success(existingOverride);
+ }
+ else
+ {
+ var newOverride = new InstanceAttributeOverride(attributeName)
+ {
+ InstanceId = instanceId,
+ OverrideValue = overrideValue
+ };
+
+ await _repository.AddInstanceAttributeOverrideAsync(newOverride, cancellationToken);
+ await _repository.SaveChangesAsync(cancellationToken);
+
+ await _auditService.LogAsync(user, "CreateOverride", "InstanceAttributeOverride",
+ newOverride.Id.ToString(), attributeName, newOverride, cancellationToken);
+
+ return Result.Success(newOverride);
+ }
+ }
+
+ ///
+ /// Sets connection bindings for an instance in bulk.
+ ///
+ public async Task>> SetConnectionBindingsAsync(
+ int instanceId,
+ IReadOnlyList<(string AttributeName, int DataConnectionId)> bindings,
+ string user,
+ CancellationToken cancellationToken = default)
+ {
+ var instance = await _repository.GetInstanceByIdAsync(instanceId, cancellationToken);
+ if (instance == null)
+ return Result>.Failure($"Instance with ID {instanceId} not found.");
+
+ var existingBindings = await _repository.GetBindingsByInstanceIdAsync(instanceId, cancellationToken);
+ var existingMap = existingBindings.ToDictionary(b => b.AttributeName, StringComparer.Ordinal);
+
+ var results = new List();
+
+ foreach (var (attrName, connId) in bindings)
+ {
+ if (existingMap.TryGetValue(attrName, out var existing))
+ {
+ existing.DataConnectionId = connId;
+ await _repository.UpdateInstanceConnectionBindingAsync(existing, cancellationToken);
+ results.Add(existing);
+ }
+ else
+ {
+ var binding = new InstanceConnectionBinding(attrName)
+ {
+ InstanceId = instanceId,
+ DataConnectionId = connId
+ };
+ await _repository.AddInstanceConnectionBindingAsync(binding, cancellationToken);
+ results.Add(binding);
+ }
+ }
+
+ await _repository.SaveChangesAsync(cancellationToken);
+
+ await _auditService.LogAsync(user, "SetConnectionBindings", "Instance",
+ instance.Id.ToString(), instance.UniqueName, bindings, cancellationToken);
+
+ return Result>.Success(results);
+ }
+
+ ///
+ /// Enables an instance.
+ ///
+ public async Task> EnableAsync(int instanceId, string user, CancellationToken cancellationToken = default)
+ {
+ var instance = await _repository.GetInstanceByIdAsync(instanceId, cancellationToken);
+ if (instance == null)
+ return Result.Failure($"Instance with ID {instanceId} not found.");
+
+ instance.State = InstanceState.Enabled;
+ await _repository.UpdateInstanceAsync(instance, cancellationToken);
+ await _repository.SaveChangesAsync(cancellationToken);
+
+ await _auditService.LogAsync(user, "Enable", "Instance", instance.Id.ToString(),
+ instance.UniqueName, instance, cancellationToken);
+
+ return Result.Success(instance);
+ }
+
+ ///
+ /// Disables an instance.
+ ///
+ public async Task> DisableAsync(int instanceId, string user, CancellationToken cancellationToken = default)
+ {
+ var instance = await _repository.GetInstanceByIdAsync(instanceId, cancellationToken);
+ if (instance == null)
+ return Result.Failure($"Instance with ID {instanceId} not found.");
+
+ instance.State = InstanceState.Disabled;
+ await _repository.UpdateInstanceAsync(instance, cancellationToken);
+ await _repository.SaveChangesAsync(cancellationToken);
+
+ await _auditService.LogAsync(user, "Disable", "Instance", instance.Id.ToString(),
+ instance.UniqueName, instance, cancellationToken);
+
+ return Result.Success(instance);
+ }
+
+ ///
+ /// Deletes an instance.
+ ///
+ public async Task> DeleteAsync(int instanceId, string user, CancellationToken cancellationToken = default)
+ {
+ var instance = await _repository.GetInstanceByIdAsync(instanceId, cancellationToken);
+ if (instance == null)
+ return Result.Failure($"Instance with ID {instanceId} not found.");
+
+ await _repository.DeleteInstanceAsync(instanceId, cancellationToken);
+ await _repository.SaveChangesAsync(cancellationToken);
+
+ await _auditService.LogAsync(user, "Delete", "Instance", instanceId.ToString(),
+ instance.UniqueName, null, cancellationToken);
+
+ return Result.Success(true);
+ }
+
+ ///
+ /// Gets an instance by ID.
+ ///
+ public async Task GetByIdAsync(int instanceId, CancellationToken cancellationToken = default) =>
+ await _repository.GetInstanceByIdAsync(instanceId, cancellationToken);
+
+ ///
+ /// Gets all instances for a site.
+ ///
+ public async Task> GetBySiteIdAsync(int siteId, CancellationToken cancellationToken = default) =>
+ await _repository.GetInstancesBySiteIdAsync(siteId, cancellationToken);
+}
diff --git a/src/ScadaLink.TemplateEngine/Services/SiteService.cs b/src/ScadaLink.TemplateEngine/Services/SiteService.cs
new file mode 100644
index 0000000..87994b7
--- /dev/null
+++ b/src/ScadaLink.TemplateEngine/Services/SiteService.cs
@@ -0,0 +1,206 @@
+using ScadaLink.Commons.Entities.Sites;
+using ScadaLink.Commons.Interfaces.Repositories;
+using ScadaLink.Commons.Interfaces.Services;
+using ScadaLink.Commons.Types;
+
+namespace ScadaLink.TemplateEngine.Services;
+
+///
+/// Site and data connection management.
+/// - Site CRUD (name, identifier, description)
+/// - Data connection CRUD (name, protocol, config)
+/// - Assign connections to sites
+/// - Connection names not standardized across sites
+/// - Audit logging
+///
+public class SiteService
+{
+ private readonly ISiteRepository _repository;
+ private readonly IAuditService _auditService;
+
+ public SiteService(ISiteRepository repository, IAuditService auditService)
+ {
+ _repository = repository ?? throw new ArgumentNullException(nameof(repository));
+ _auditService = auditService ?? throw new ArgumentNullException(nameof(auditService));
+ }
+
+ // --- Site CRUD ---
+
+ public async Task> CreateSiteAsync(
+ string name, string siteIdentifier, string? description, string user,
+ CancellationToken cancellationToken = default)
+ {
+ if (string.IsNullOrWhiteSpace(name))
+ return Result.Failure("Site name is required.");
+ if (string.IsNullOrWhiteSpace(siteIdentifier))
+ return Result.Failure("Site identifier is required.");
+
+ var existing = await _repository.GetSiteByIdentifierAsync(siteIdentifier, cancellationToken);
+ if (existing != null)
+ return Result.Failure($"Site with identifier '{siteIdentifier}' already exists.");
+
+ var site = new Site(name, siteIdentifier) { Description = description };
+ await _repository.AddSiteAsync(site, cancellationToken);
+ await _repository.SaveChangesAsync(cancellationToken);
+
+ await _auditService.LogAsync(user, "Create", "Site", site.Id.ToString(), name, site, cancellationToken);
+
+ return Result.Success(site);
+ }
+
+ public async Task> UpdateSiteAsync(
+ int siteId, string name, string? description, string user,
+ CancellationToken cancellationToken = default)
+ {
+ var site = await _repository.GetSiteByIdAsync(siteId, cancellationToken);
+ if (site == null)
+ return Result.Failure($"Site with ID {siteId} not found.");
+
+ site.Name = name;
+ site.Description = description;
+ await _repository.UpdateSiteAsync(site, cancellationToken);
+ await _repository.SaveChangesAsync(cancellationToken);
+
+ await _auditService.LogAsync(user, "Update", "Site", site.Id.ToString(), name, site, cancellationToken);
+
+ return Result.Success(site);
+ }
+
+ public async Task> DeleteSiteAsync(int siteId, string user, CancellationToken cancellationToken = default)
+ {
+ var site = await _repository.GetSiteByIdAsync(siteId, cancellationToken);
+ if (site == null)
+ return Result.Failure($"Site with ID {siteId} not found.");
+
+ // Check for instances assigned to this site
+ var instances = await _repository.GetInstancesBySiteIdAsync(siteId, cancellationToken);
+ if (instances.Count > 0)
+ {
+ var names = string.Join(", ", instances.Select(i => i.UniqueName).Take(5));
+ return Result.Failure(
+ $"Cannot delete site '{site.Name}': {instances.Count} instance(s) are assigned to it ({names}{(instances.Count > 5 ? "..." : "")}).");
+ }
+
+ await _repository.DeleteSiteAsync(siteId, cancellationToken);
+ await _repository.SaveChangesAsync(cancellationToken);
+
+ await _auditService.LogAsync(user, "Delete", "Site", siteId.ToString(), site.Name, null, cancellationToken);
+
+ return Result.Success(true);
+ }
+
+ public async Task GetSiteByIdAsync(int siteId, CancellationToken cancellationToken = default) =>
+ await _repository.GetSiteByIdAsync(siteId, cancellationToken);
+
+ public async Task> GetAllSitesAsync(CancellationToken cancellationToken = default) =>
+ await _repository.GetAllSitesAsync(cancellationToken);
+
+ // --- Data Connection CRUD ---
+
+ public async Task> CreateDataConnectionAsync(
+ string name, string protocol, string? configuration, string user,
+ CancellationToken cancellationToken = default)
+ {
+ if (string.IsNullOrWhiteSpace(name))
+ return Result.Failure("Data connection name is required.");
+ if (string.IsNullOrWhiteSpace(protocol))
+ return Result.Failure("Protocol is required.");
+
+ var connection = new DataConnection(name, protocol) { Configuration = configuration };
+ await _repository.AddDataConnectionAsync(connection, cancellationToken);
+ await _repository.SaveChangesAsync(cancellationToken);
+
+ await _auditService.LogAsync(user, "Create", "DataConnection",
+ connection.Id.ToString(), name, connection, cancellationToken);
+
+ return Result.Success(connection);
+ }
+
+ public async Task> UpdateDataConnectionAsync(
+ int connectionId, string name, string protocol, string? configuration, string user,
+ CancellationToken cancellationToken = default)
+ {
+ var connection = await _repository.GetDataConnectionByIdAsync(connectionId, cancellationToken);
+ if (connection == null)
+ return Result.Failure($"Data connection with ID {connectionId} not found.");
+
+ connection.Name = name;
+ connection.Protocol = protocol;
+ connection.Configuration = configuration;
+ await _repository.UpdateDataConnectionAsync(connection, cancellationToken);
+ await _repository.SaveChangesAsync(cancellationToken);
+
+ await _auditService.LogAsync(user, "Update", "DataConnection",
+ connection.Id.ToString(), name, connection, cancellationToken);
+
+ return Result.Success(connection);
+ }
+
+ public async Task> DeleteDataConnectionAsync(
+ int connectionId, string user, CancellationToken cancellationToken = default)
+ {
+ var connection = await _repository.GetDataConnectionByIdAsync(connectionId, cancellationToken);
+ if (connection == null)
+ return Result.Failure($"Data connection with ID {connectionId} not found.");
+
+ await _repository.DeleteDataConnectionAsync(connectionId, cancellationToken);
+ await _repository.SaveChangesAsync(cancellationToken);
+
+ await _auditService.LogAsync(user, "Delete", "DataConnection",
+ connectionId.ToString(), connection.Name, null, cancellationToken);
+
+ return Result.Success(true);
+ }
+
+ // --- Site-Connection Assignment ---
+
+ public async Task> AssignConnectionToSiteAsync(
+ int siteId, int dataConnectionId, string user,
+ CancellationToken cancellationToken = default)
+ {
+ var site = await _repository.GetSiteByIdAsync(siteId, cancellationToken);
+ if (site == null)
+ return Result.Failure($"Site with ID {siteId} not found.");
+
+ var connection = await _repository.GetDataConnectionByIdAsync(dataConnectionId, cancellationToken);
+ if (connection == null)
+ return Result.Failure($"Data connection with ID {dataConnectionId} not found.");
+
+ // Check if assignment already exists
+ var existing = await _repository.GetSiteDataConnectionAssignmentAsync(siteId, dataConnectionId, cancellationToken);
+ if (existing != null)
+ return Result.Failure(
+ $"Data connection '{connection.Name}' is already assigned to site '{site.Name}'.");
+
+ var assignment = new SiteDataConnectionAssignment
+ {
+ SiteId = siteId,
+ DataConnectionId = dataConnectionId
+ };
+
+ await _repository.AddSiteDataConnectionAssignmentAsync(assignment, cancellationToken);
+ await _repository.SaveChangesAsync(cancellationToken);
+
+ await _auditService.LogAsync(user, "AssignConnection", "SiteDataConnectionAssignment",
+ assignment.Id.ToString(), $"{site.Name}/{connection.Name}", assignment, cancellationToken);
+
+ return Result.Success(assignment);
+ }
+
+ public async Task> RemoveConnectionFromSiteAsync(
+ int siteId, int dataConnectionId, string user,
+ CancellationToken cancellationToken = default)
+ {
+ var assignment = await _repository.GetSiteDataConnectionAssignmentAsync(siteId, dataConnectionId, cancellationToken);
+ if (assignment == null)
+ return Result.Failure("Assignment not found.");
+
+ await _repository.DeleteSiteDataConnectionAssignmentAsync(assignment.Id, cancellationToken);
+ await _repository.SaveChangesAsync(cancellationToken);
+
+ await _auditService.LogAsync(user, "RemoveConnection", "SiteDataConnectionAssignment",
+ assignment.Id.ToString(), $"Site:{siteId}/Conn:{dataConnectionId}", null, cancellationToken);
+
+ return Result.Success(true);
+ }
+}
diff --git a/src/ScadaLink.TemplateEngine/Services/TemplateDeletionService.cs b/src/ScadaLink.TemplateEngine/Services/TemplateDeletionService.cs
new file mode 100644
index 0000000..2ea7d63
--- /dev/null
+++ b/src/ScadaLink.TemplateEngine/Services/TemplateDeletionService.cs
@@ -0,0 +1,90 @@
+using ScadaLink.Commons.Entities.Templates;
+using ScadaLink.Commons.Interfaces.Repositories;
+using ScadaLink.Commons.Types;
+
+namespace ScadaLink.TemplateEngine.Services;
+
+///
+/// Enforces template deletion constraints (WP-25).
+/// Template deletion is blocked when:
+/// - Instances reference the template
+/// - Child templates reference it (as parent)
+/// - Other templates compose it
+/// Returns clear error messages listing the referencing entities.
+///
+public class TemplateDeletionService
+{
+ private readonly ITemplateEngineRepository _repository;
+
+ public TemplateDeletionService(ITemplateEngineRepository repository)
+ {
+ _repository = repository ?? throw new ArgumentNullException(nameof(repository));
+ }
+
+ ///
+ /// Checks whether a template can be safely deleted and returns any blocking reasons.
+ ///
+ public async Task> CanDeleteTemplateAsync(int templateId, CancellationToken cancellationToken = default)
+ {
+ var template = await _repository.GetTemplateByIdAsync(templateId, cancellationToken);
+ if (template == null)
+ return Result.Failure($"Template with ID {templateId} not found.");
+
+ var errors = new List();
+
+ // Check 1: Instances reference this template
+ var instances = await _repository.GetInstancesByTemplateIdAsync(templateId, cancellationToken);
+ if (instances.Count > 0)
+ {
+ var names = string.Join(", ", instances.Select(i => i.UniqueName).Take(10));
+ errors.Add($"Cannot delete template '{template.Name}': {instances.Count} instance(s) reference it ({names}{(instances.Count > 10 ? "..." : "")}).");
+ }
+
+ // Check 2: Child templates reference it as parent
+ var allTemplates = await _repository.GetAllTemplatesAsync(cancellationToken);
+ var childTemplates = allTemplates.Where(t => t.ParentTemplateId == templateId).ToList();
+ if (childTemplates.Count > 0)
+ {
+ var names = string.Join(", ", childTemplates.Select(t => t.Name).Take(10));
+ errors.Add($"Cannot delete template '{template.Name}': {childTemplates.Count} child template(s) inherit from it ({names}{(childTemplates.Count > 10 ? "..." : "")}).");
+ }
+
+ // Check 3: Other templates compose it
+ var composingTemplates = new List<(string TemplateName, string InstanceName)>();
+ foreach (var t in allTemplates)
+ {
+ var compositions = await _repository.GetCompositionsByTemplateIdAsync(t.Id, cancellationToken);
+ foreach (var comp in compositions)
+ {
+ if (comp.ComposedTemplateId == templateId)
+ composingTemplates.Add((t.Name, comp.InstanceName));
+ }
+ }
+
+ if (composingTemplates.Count > 0)
+ {
+ var details = string.Join(", ",
+ composingTemplates.Take(10).Select(c => $"'{c.TemplateName}' (as '{c.InstanceName}')"));
+ errors.Add($"Cannot delete template '{template.Name}': {composingTemplates.Count} template(s) compose it ({details}{(composingTemplates.Count > 10 ? "..." : "")}).");
+ }
+
+ if (errors.Count > 0)
+ return Result.Failure(string.Join(" ", errors));
+
+ return Result.Success(true);
+ }
+
+ ///
+ /// Deletes a template after checking all constraints.
+ ///
+ public async Task> DeleteTemplateAsync(int templateId, CancellationToken cancellationToken = default)
+ {
+ var canDelete = await CanDeleteTemplateAsync(templateId, cancellationToken);
+ if (canDelete.IsFailure)
+ return canDelete;
+
+ await _repository.DeleteTemplateAsync(templateId, cancellationToken);
+ await _repository.SaveChangesAsync(cancellationToken);
+ return Result.Success(true);
+ }
+}
diff --git a/src/ScadaLink.TemplateEngine/SharedScriptService.cs b/src/ScadaLink.TemplateEngine/SharedScriptService.cs
new file mode 100644
index 0000000..1c029ea
--- /dev/null
+++ b/src/ScadaLink.TemplateEngine/SharedScriptService.cs
@@ -0,0 +1,163 @@
+using ScadaLink.Commons.Entities.Scripts;
+using ScadaLink.Commons.Interfaces.Repositories;
+using ScadaLink.Commons.Interfaces.Services;
+using ScadaLink.Commons.Types;
+
+namespace ScadaLink.TemplateEngine;
+
+///
+/// WP-5: Shared Script CRUD.
+/// System-wide scripts not associated with templates.
+/// Same parameter/return definition structure as template scripts.
+/// Includes syntax/structural validation (basic C# compilation check).
+///
+public class SharedScriptService
+{
+ private readonly ITemplateEngineRepository _repository;
+ private readonly IAuditService _auditService;
+
+ public SharedScriptService(ITemplateEngineRepository repository, IAuditService auditService)
+ {
+ _repository = repository ?? throw new ArgumentNullException(nameof(repository));
+ _auditService = auditService ?? throw new ArgumentNullException(nameof(auditService));
+ }
+
+ public async Task> CreateSharedScriptAsync(
+ string name,
+ string code,
+ string? parameterDefinitions,
+ string? returnDefinition,
+ string user,
+ CancellationToken cancellationToken = default)
+ {
+ if (string.IsNullOrWhiteSpace(name))
+ return Result.Failure("Shared script name is required.");
+
+ if (string.IsNullOrWhiteSpace(code))
+ return Result.Failure("Shared script code is required.");
+
+ // Check unique name
+ var existing = await _repository.GetSharedScriptByNameAsync(name, cancellationToken);
+ if (existing != null)
+ return Result.Failure($"A shared script named '{name}' already exists.");
+
+ // Syntax/structural validation
+ var syntaxError = ValidateSyntax(code);
+ if (syntaxError != null)
+ return Result.Failure(syntaxError);
+
+ var script = new SharedScript(name, code)
+ {
+ ParameterDefinitions = parameterDefinitions,
+ ReturnDefinition = returnDefinition
+ };
+
+ await _repository.AddSharedScriptAsync(script, cancellationToken);
+ await _auditService.LogAsync(user, "Create", "SharedScript", "0", name, script, cancellationToken);
+ await _repository.SaveChangesAsync(cancellationToken);
+
+ return Result.Success(script);
+ }
+
+ public async Task> UpdateSharedScriptAsync(
+ int scriptId,
+ string code,
+ string? parameterDefinitions,
+ string? returnDefinition,
+ string user,
+ CancellationToken cancellationToken = default)
+ {
+ var script = await _repository.GetSharedScriptByIdAsync(scriptId, cancellationToken);
+ if (script == null)
+ return Result.Failure($"Shared script with ID {scriptId} not found.");
+
+ if (string.IsNullOrWhiteSpace(code))
+ return Result.Failure("Shared script code is required.");
+
+ // Syntax/structural validation
+ var syntaxError = ValidateSyntax(code);
+ if (syntaxError != null)
+ return Result.Failure(syntaxError);
+
+ script.Code = code;
+ script.ParameterDefinitions = parameterDefinitions;
+ script.ReturnDefinition = returnDefinition;
+
+ await _repository.UpdateSharedScriptAsync(script, cancellationToken);
+ await _auditService.LogAsync(user, "Update", "SharedScript", scriptId.ToString(), script.Name, script, cancellationToken);
+ await _repository.SaveChangesAsync(cancellationToken);
+
+ return Result.Success(script);
+ }
+
+ public async Task> DeleteSharedScriptAsync(
+ int scriptId,
+ string user,
+ CancellationToken cancellationToken = default)
+ {
+ var script = await _repository.GetSharedScriptByIdAsync(scriptId, cancellationToken);
+ if (script == null)
+ return Result.Failure($"Shared script with ID {scriptId} not found.");
+
+ await _repository.DeleteSharedScriptAsync(scriptId, cancellationToken);
+ await _auditService.LogAsync(user, "Delete", "SharedScript", scriptId.ToString(), script.Name, null, cancellationToken);
+ await _repository.SaveChangesAsync(cancellationToken);
+
+ return Result.Success(true);
+ }
+
+ public async Task GetSharedScriptByIdAsync(int scriptId, CancellationToken cancellationToken = default)
+ {
+ return await _repository.GetSharedScriptByIdAsync(scriptId, cancellationToken);
+ }
+
+ public async Task> GetAllSharedScriptsAsync(CancellationToken cancellationToken = default)
+ {
+ return await _repository.GetAllSharedScriptsAsync(cancellationToken);
+ }
+
+ ///
+ /// Basic structural validation of C# script code.
+ /// Checks for balanced braces and basic syntax structure.
+ /// Full Roslyn compilation would be added in a later phase when the scripting sandbox is available.
+ ///
+ internal static string? ValidateSyntax(string code)
+ {
+ if (string.IsNullOrWhiteSpace(code))
+ return "Script code cannot be empty.";
+
+ // Check for balanced braces
+ int braceCount = 0;
+ int bracketCount = 0;
+ int parenCount = 0;
+
+ foreach (var ch in code)
+ {
+ switch (ch)
+ {
+ case '{': braceCount++; break;
+ case '}': braceCount--; break;
+ case '[': bracketCount++; break;
+ case ']': bracketCount--; break;
+ case '(': parenCount++; break;
+ case ')': parenCount--; break;
+ }
+
+ if (braceCount < 0)
+ return "Syntax error: unmatched closing brace '}'.";
+ if (bracketCount < 0)
+ return "Syntax error: unmatched closing bracket ']'.";
+ if (parenCount < 0)
+ return "Syntax error: unmatched closing parenthesis ')'.";
+ }
+
+ if (braceCount != 0)
+ return "Syntax error: unmatched opening brace '{'.";
+ if (bracketCount != 0)
+ return "Syntax error: unmatched opening bracket '['.";
+ if (parenCount != 0)
+ return "Syntax error: unmatched opening parenthesis '('.";
+
+ return null;
+ }
+}
diff --git a/src/ScadaLink.TemplateEngine/TemplateResolver.cs b/src/ScadaLink.TemplateEngine/TemplateResolver.cs
new file mode 100644
index 0000000..ae9ec29
--- /dev/null
+++ b/src/ScadaLink.TemplateEngine/TemplateResolver.cs
@@ -0,0 +1,155 @@
+using ScadaLink.Commons.Entities.Templates;
+
+namespace ScadaLink.TemplateEngine;
+
+///
+/// Walks inheritance and composition chains to resolve effective template members.
+/// Produces canonical (path-qualified) names for composed module members.
+///
+public static class TemplateResolver
+{
+ ///
+ /// Represents a resolved member from any point in the inheritance/composition hierarchy.
+ ///
+ public sealed record ResolvedTemplateMember
+ {
+ public string CanonicalName { get; init; }
+ public string MemberType { get; init; } // "Attribute", "Alarm", "Script"
+ public int SourceTemplateId { get; init; }
+ public int MemberId { get; init; }
+ public bool IsLocked { get; init; }
+ public string? ModulePath { get; init; }
+
+ public ResolvedTemplateMember(string canonicalName, string memberType, int sourceTemplateId, int memberId, bool isLocked, string? modulePath = null)
+ {
+ CanonicalName = canonicalName;
+ MemberType = memberType;
+ SourceTemplateId = sourceTemplateId;
+ MemberId = memberId;
+ IsLocked = isLocked;
+ ModulePath = modulePath;
+ }
+ }
+
+ ///
+ /// Resolves all effective members for a template, walking inheritance and composition chains.
+ /// Child members override parent members of the same canonical name (unless locked).
+ ///
+ public static IReadOnlyList ResolveAllMembers(
+ int templateId,
+ IReadOnlyList allTemplates)
+ {
+ var lookup = allTemplates.ToDictionary(t => t.Id);
+ if (!lookup.TryGetValue(templateId, out var template))
+ return Array.Empty();
+
+ // Build inheritance chain from root to leaf (root first, child last)
+ var chain = BuildInheritanceChain(templateId, lookup);
+
+ // Start with root members, apply overrides from each child
+ var effectiveMembers = new Dictionary(StringComparer.Ordinal);
+
+ foreach (var tmpl in chain)
+ {
+ // Direct members
+ AddDirectMembers(tmpl, prefix: null, effectiveMembers);
+
+ // Composed module members
+ foreach (var composition in tmpl.Compositions)
+ {
+ if (lookup.TryGetValue(composition.ComposedTemplateId, out var composedTemplate))
+ {
+ AddComposedMembers(composedTemplate, composition.InstanceName, lookup, effectiveMembers, new HashSet());
+ }
+ }
+ }
+
+ return effectiveMembers.Values.ToList();
+ }
+
+ ///
+ /// Gets the inheritance chain from root ancestor to the specified template.
+ ///
+ public static IReadOnlyList BuildInheritanceChain(
+ int templateId,
+ IReadOnlyDictionary lookup)
+ {
+ var chain = new List();
+ var currentId = templateId;
+ var visited = new HashSet();
+
+ while (currentId != 0 && lookup.TryGetValue(currentId, out var current))
+ {
+ if (!visited.Add(currentId))
+ break; // Safety: cycle detected
+
+ chain.Add(current);
+ currentId = current.ParentTemplateId ?? 0;
+ }
+
+ chain.Reverse(); // Root first
+ return chain;
+ }
+
+ ///
+ /// Finds a member by canonical name in the resolved member set.
+ /// Used to check override/lock constraints.
+ ///
+ public static ResolvedTemplateMember? FindMemberByCanonicalName(
+ string canonicalName,
+ int parentTemplateId,
+ IReadOnlyList allTemplates)
+ {
+ var members = ResolveAllMembers(parentTemplateId, allTemplates);
+ return members.FirstOrDefault(m => m.CanonicalName == canonicalName);
+ }
+
+ private static void AddDirectMembers(
+ Template template,
+ string? prefix,
+ Dictionary effectiveMembers)
+ {
+ foreach (var attr in template.Attributes)
+ {
+ var canonicalName = prefix == null ? attr.Name : $"{prefix}.{attr.Name}";
+ effectiveMembers[canonicalName] = new ResolvedTemplateMember(
+ canonicalName, "Attribute", template.Id, attr.Id, attr.IsLocked, prefix);
+ }
+
+ foreach (var alarm in template.Alarms)
+ {
+ var canonicalName = prefix == null ? alarm.Name : $"{prefix}.{alarm.Name}";
+ effectiveMembers[canonicalName] = new ResolvedTemplateMember(
+ canonicalName, "Alarm", template.Id, alarm.Id, alarm.IsLocked, prefix);
+ }
+
+ foreach (var script in template.Scripts)
+ {
+ var canonicalName = prefix == null ? script.Name : $"{prefix}.{script.Name}";
+ effectiveMembers[canonicalName] = new ResolvedTemplateMember(
+ canonicalName, "Script", template.Id, script.Id, script.IsLocked, prefix);
+ }
+ }
+
+ private static void AddComposedMembers(
+ Template template,
+ string prefix,
+ Dictionary