refactor: rename ScadaLink → ZB.MOM.WW.ScadaBridge (code + projects + namespaces)

Solution + 23 src projects + 26 test projects renamed; folders, csproj,
namespaces, and ScadaLinkDbContext/ScadaBridgeDbContext class updated.
ActorSystem "scadalink" → "scadabridge", Akka seed-node URLs migrated.
SQL roles/logins, LDAP domains, CLI command name, and CLI config dir
(~/.scadalink → ~/.scadabridge) also renamed.

Build green; 5 Host.Tests fail awaiting SQL login rename in next commit.
Pre-existing StaleTagMonitor timing flakes unchanged.

Rename script committed at tools/rename-to-scadabridge.sh.
This commit is contained in:
Joseph Doherty
2026-05-28 09:37:45 -04:00
parent 6d87ee3c3b
commit 7b0b9c7365
1531 changed files with 11180 additions and 11054 deletions
@@ -0,0 +1,577 @@
using Microsoft.EntityFrameworkCore;
using ZB.MOM.WW.ScadaBridge.Commons.Entities.Instances;
using ZB.MOM.WW.ScadaBridge.Commons.Entities.Scripts;
using ZB.MOM.WW.ScadaBridge.Commons.Entities.Templates;
using ZB.MOM.WW.ScadaBridge.Commons.Interfaces.Repositories;
namespace ZB.MOM.WW.ScadaBridge.ConfigurationDatabase.Repositories;
public class TemplateEngineRepository : ITemplateEngineRepository
{
private readonly ScadaBridgeDbContext _context;
/// <summary>
/// Initializes a new instance of the TemplateEngineRepository class.
/// </summary>
/// <param name="context">The database context used to access template and instance data.</param>
public TemplateEngineRepository(ScadaBridgeDbContext context)
{
_context = context ?? throw new ArgumentNullException(nameof(context));
}
// Template
/// <inheritdoc />
public async Task<Template?> 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)
.AsSplitQuery()
.FirstOrDefaultAsync(t => t.Id == id, cancellationToken);
}
/// <inheritdoc />
public async Task<Template?> GetTemplateWithChildrenAsync(int id, CancellationToken cancellationToken = default)
{
return await GetTemplateByIdAsync(id, cancellationToken);
}
/// <inheritdoc />
public async Task<IReadOnlyList<Template>> GetTemplatesWithChildrenAsync(
IEnumerable<string> names, CancellationToken cancellationToken = default)
{
// Transport-008: bulk lookup replaces the per-name N+1 in
// BundleImporter.PreviewAsync. Filter out null / empty / duplicate
// names before the query so EF emits a clean, deduplicated IN clause.
if (names is null) return Array.Empty<Template>();
var distinct = names
.Where(n => !string.IsNullOrEmpty(n))
.Distinct(StringComparer.Ordinal)
.ToArray();
if (distinct.Length == 0) return Array.Empty<Template>();
return await _context.Templates
.Where(t => distinct.Contains(t.Name))
.Include(t => t.Attributes)
.Include(t => t.Alarms)
.Include(t => t.Scripts)
.Include(t => t.Compositions)
.AsSplitQuery()
.ToListAsync(cancellationToken);
}
/// <inheritdoc />
public async Task<IReadOnlyList<Template>> GetAllTemplatesAsync(CancellationToken cancellationToken = default)
{
return await _context.Templates
.Include(t => t.Attributes)
.Include(t => t.Alarms)
.Include(t => t.Scripts)
.Include(t => t.Compositions)
.AsSplitQuery()
.ToListAsync(cancellationToken);
}
/// <inheritdoc />
public async Task<IReadOnlyList<Template>> GetTemplatesComposingAsync(int composedTemplateId, CancellationToken cancellationToken = default)
{
return await _context.Templates
.Where(t => t.Compositions.Any(c => c.ComposedTemplateId == composedTemplateId))
.Include(t => t.Attributes)
.Include(t => t.Scripts)
.Include(t => t.Compositions)
.AsSplitQuery()
.ToListAsync(cancellationToken);
}
/// <inheritdoc />
public async Task AddTemplateAsync(Template template, CancellationToken cancellationToken = default)
{
await _context.Templates.AddAsync(template, cancellationToken);
}
/// <inheritdoc />
public Task UpdateTemplateAsync(Template template, CancellationToken cancellationToken = default)
{
_context.Templates.Update(template);
return Task.CompletedTask;
}
/// <inheritdoc />
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
/// <inheritdoc />
public async Task<TemplateAttribute?> GetTemplateAttributeByIdAsync(int id, CancellationToken cancellationToken = default)
{
return await _context.TemplateAttributes.FindAsync(new object[] { id }, cancellationToken);
}
/// <inheritdoc />
public async Task<IReadOnlyList<TemplateAttribute>> GetAttributesByTemplateIdAsync(int templateId, CancellationToken cancellationToken = default)
{
return await _context.TemplateAttributes
.Where(a => a.TemplateId == templateId)
.ToListAsync(cancellationToken);
}
/// <inheritdoc />
public async Task AddTemplateAttributeAsync(TemplateAttribute attribute, CancellationToken cancellationToken = default)
{
await _context.TemplateAttributes.AddAsync(attribute, cancellationToken);
}
/// <inheritdoc />
public Task UpdateTemplateAttributeAsync(TemplateAttribute attribute, CancellationToken cancellationToken = default)
{
_context.TemplateAttributes.Update(attribute);
return Task.CompletedTask;
}
/// <inheritdoc />
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
/// <inheritdoc />
public async Task<TemplateAlarm?> GetTemplateAlarmByIdAsync(int id, CancellationToken cancellationToken = default)
{
return await _context.TemplateAlarms.FindAsync(new object[] { id }, cancellationToken);
}
/// <inheritdoc />
public async Task<IReadOnlyList<TemplateAlarm>> GetAlarmsByTemplateIdAsync(int templateId, CancellationToken cancellationToken = default)
{
return await _context.TemplateAlarms
.Where(a => a.TemplateId == templateId)
.ToListAsync(cancellationToken);
}
/// <inheritdoc />
public async Task AddTemplateAlarmAsync(TemplateAlarm alarm, CancellationToken cancellationToken = default)
{
await _context.TemplateAlarms.AddAsync(alarm, cancellationToken);
}
/// <inheritdoc />
public Task UpdateTemplateAlarmAsync(TemplateAlarm alarm, CancellationToken cancellationToken = default)
{
_context.TemplateAlarms.Update(alarm);
return Task.CompletedTask;
}
/// <inheritdoc />
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
/// <inheritdoc />
public async Task<TemplateScript?> GetTemplateScriptByIdAsync(int id, CancellationToken cancellationToken = default)
{
return await _context.TemplateScripts.FindAsync(new object[] { id }, cancellationToken);
}
/// <inheritdoc />
public async Task<IReadOnlyList<TemplateScript>> GetScriptsByTemplateIdAsync(int templateId, CancellationToken cancellationToken = default)
{
return await _context.TemplateScripts
.Where(s => s.TemplateId == templateId)
.ToListAsync(cancellationToken);
}
/// <inheritdoc />
public async Task AddTemplateScriptAsync(TemplateScript script, CancellationToken cancellationToken = default)
{
await _context.TemplateScripts.AddAsync(script, cancellationToken);
}
/// <inheritdoc />
public Task UpdateTemplateScriptAsync(TemplateScript script, CancellationToken cancellationToken = default)
{
_context.TemplateScripts.Update(script);
return Task.CompletedTask;
}
/// <inheritdoc />
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
/// <inheritdoc />
public async Task<TemplateComposition?> GetTemplateCompositionByIdAsync(int id, CancellationToken cancellationToken = default)
{
return await _context.TemplateCompositions.FindAsync(new object[] { id }, cancellationToken);
}
/// <inheritdoc />
public async Task<IReadOnlyList<TemplateComposition>> GetCompositionsByTemplateIdAsync(int templateId, CancellationToken cancellationToken = default)
{
return await _context.TemplateCompositions
.Where(c => c.TemplateId == templateId)
.ToListAsync(cancellationToken);
}
/// <inheritdoc />
public async Task AddTemplateCompositionAsync(TemplateComposition composition, CancellationToken cancellationToken = default)
{
await _context.TemplateCompositions.AddAsync(composition, cancellationToken);
}
/// <inheritdoc />
public Task UpdateTemplateCompositionAsync(TemplateComposition composition, CancellationToken cancellationToken = default)
{
_context.TemplateCompositions.Update(composition);
return Task.CompletedTask;
}
/// <inheritdoc />
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
/// <inheritdoc />
public async Task<Instance?> GetInstanceByIdAsync(int id, CancellationToken cancellationToken = default)
{
return await _context.Instances
.Include(i => i.AttributeOverrides)
.Include(i => i.AlarmOverrides)
.Include(i => i.ConnectionBindings)
.AsSplitQuery()
.FirstOrDefaultAsync(i => i.Id == id, cancellationToken);
}
/// <inheritdoc />
public async Task<IReadOnlyList<Instance>> GetAllInstancesAsync(CancellationToken cancellationToken = default)
{
return await _context.Instances
.Include(i => i.AttributeOverrides)
.Include(i => i.AlarmOverrides)
.Include(i => i.ConnectionBindings)
.AsSplitQuery()
.ToListAsync(cancellationToken);
}
/// <inheritdoc />
public async Task<IReadOnlyList<Instance>> GetInstancesByTemplateIdAsync(int templateId, CancellationToken cancellationToken = default)
{
return await _context.Instances
.Where(i => i.TemplateId == templateId)
.ToListAsync(cancellationToken);
}
/// <inheritdoc />
public async Task<IReadOnlyList<Instance>> GetInstancesBySiteIdAsync(int siteId, CancellationToken cancellationToken = default)
{
return await _context.Instances
.Where(i => i.SiteId == siteId)
.Include(i => i.AttributeOverrides)
.Include(i => i.AlarmOverrides)
.Include(i => i.ConnectionBindings)
.AsSplitQuery()
.ToListAsync(cancellationToken);
}
/// <inheritdoc />
public async Task<Instance?> GetInstanceByUniqueNameAsync(string uniqueName, CancellationToken cancellationToken = default)
{
return await _context.Instances
.Include(i => i.AttributeOverrides)
.Include(i => i.AlarmOverrides)
.Include(i => i.ConnectionBindings)
.AsSplitQuery()
.FirstOrDefaultAsync(i => i.UniqueName == uniqueName, cancellationToken);
}
/// <inheritdoc />
public async Task AddInstanceAsync(Instance instance, CancellationToken cancellationToken = default)
{
await _context.Instances.AddAsync(instance, cancellationToken);
}
/// <inheritdoc />
public Task UpdateInstanceAsync(Instance instance, CancellationToken cancellationToken = default)
{
_context.Instances.Update(instance);
return Task.CompletedTask;
}
/// <inheritdoc />
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
/// <inheritdoc />
public async Task<IReadOnlyList<InstanceAttributeOverride>> GetOverridesByInstanceIdAsync(int instanceId, CancellationToken cancellationToken = default)
{
return await _context.InstanceAttributeOverrides
.Where(o => o.InstanceId == instanceId)
.ToListAsync(cancellationToken);
}
/// <inheritdoc />
public async Task AddInstanceAttributeOverrideAsync(InstanceAttributeOverride attributeOverride, CancellationToken cancellationToken = default)
{
await _context.InstanceAttributeOverrides.AddAsync(attributeOverride, cancellationToken);
}
/// <inheritdoc />
public Task UpdateInstanceAttributeOverrideAsync(InstanceAttributeOverride attributeOverride, CancellationToken cancellationToken = default)
{
_context.InstanceAttributeOverrides.Update(attributeOverride);
return Task.CompletedTask;
}
/// <inheritdoc />
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);
}
}
// InstanceAlarmOverride
/// <inheritdoc />
public async Task<IReadOnlyList<InstanceAlarmOverride>> GetAlarmOverridesByInstanceIdAsync(int instanceId, CancellationToken cancellationToken = default)
{
return await _context.InstanceAlarmOverrides
.Where(o => o.InstanceId == instanceId)
.ToListAsync(cancellationToken);
}
/// <inheritdoc />
public async Task<InstanceAlarmOverride?> GetAlarmOverrideAsync(int instanceId, string alarmCanonicalName, CancellationToken cancellationToken = default)
{
return await _context.InstanceAlarmOverrides
.FirstOrDefaultAsync(
o => o.InstanceId == instanceId && o.AlarmCanonicalName == alarmCanonicalName,
cancellationToken);
}
/// <inheritdoc />
public async Task AddInstanceAlarmOverrideAsync(InstanceAlarmOverride alarmOverride, CancellationToken cancellationToken = default)
{
await _context.InstanceAlarmOverrides.AddAsync(alarmOverride, cancellationToken);
}
/// <inheritdoc />
public Task UpdateInstanceAlarmOverrideAsync(InstanceAlarmOverride alarmOverride, CancellationToken cancellationToken = default)
{
_context.InstanceAlarmOverrides.Update(alarmOverride);
return Task.CompletedTask;
}
/// <inheritdoc />
public async Task DeleteInstanceAlarmOverrideAsync(int id, CancellationToken cancellationToken = default)
{
var alarmOverride = await _context.InstanceAlarmOverrides.FindAsync(new object[] { id }, cancellationToken);
if (alarmOverride != null)
{
_context.InstanceAlarmOverrides.Remove(alarmOverride);
}
}
// InstanceConnectionBinding
/// <inheritdoc />
public async Task<IReadOnlyList<InstanceConnectionBinding>> GetBindingsByInstanceIdAsync(int instanceId, CancellationToken cancellationToken = default)
{
return await _context.InstanceConnectionBindings
.Where(b => b.InstanceId == instanceId)
.ToListAsync(cancellationToken);
}
/// <inheritdoc />
public async Task AddInstanceConnectionBindingAsync(InstanceConnectionBinding binding, CancellationToken cancellationToken = default)
{
await _context.InstanceConnectionBindings.AddAsync(binding, cancellationToken);
}
/// <inheritdoc />
public Task UpdateInstanceConnectionBindingAsync(InstanceConnectionBinding binding, CancellationToken cancellationToken = default)
{
_context.InstanceConnectionBindings.Update(binding);
return Task.CompletedTask;
}
/// <inheritdoc />
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
/// <inheritdoc />
public async Task<Area?> GetAreaByIdAsync(int id, CancellationToken cancellationToken = default)
{
return await _context.Areas
.Include(a => a.Children)
.FirstOrDefaultAsync(a => a.Id == id, cancellationToken);
}
/// <inheritdoc />
public async Task<IReadOnlyList<Area>> GetAreasBySiteIdAsync(int siteId, CancellationToken cancellationToken = default)
{
return await _context.Areas
.Where(a => a.SiteId == siteId)
.Include(a => a.Children)
.ToListAsync(cancellationToken);
}
/// <inheritdoc />
public async Task AddAreaAsync(Area area, CancellationToken cancellationToken = default)
{
await _context.Areas.AddAsync(area, cancellationToken);
}
/// <inheritdoc />
public Task UpdateAreaAsync(Area area, CancellationToken cancellationToken = default)
{
_context.Areas.Update(area);
return Task.CompletedTask;
}
/// <inheritdoc />
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
/// <inheritdoc />
public async Task<SharedScript?> GetSharedScriptByIdAsync(int id, CancellationToken cancellationToken = default)
{
return await _context.SharedScripts.FindAsync(new object[] { id }, cancellationToken);
}
/// <inheritdoc />
public async Task<SharedScript?> GetSharedScriptByNameAsync(string name, CancellationToken cancellationToken = default)
{
return await _context.SharedScripts
.FirstOrDefaultAsync(s => s.Name == name, cancellationToken);
}
/// <inheritdoc />
public async Task<IReadOnlyList<SharedScript>> GetAllSharedScriptsAsync(CancellationToken cancellationToken = default)
{
return await _context.SharedScripts.ToListAsync(cancellationToken);
}
/// <inheritdoc />
public async Task AddSharedScriptAsync(SharedScript sharedScript, CancellationToken cancellationToken = default)
{
await _context.SharedScripts.AddAsync(sharedScript, cancellationToken);
}
/// <inheritdoc />
public Task UpdateSharedScriptAsync(SharedScript sharedScript, CancellationToken cancellationToken = default)
{
_context.SharedScripts.Update(sharedScript);
return Task.CompletedTask;
}
/// <inheritdoc />
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);
}
}
// TemplateFolder
/// <inheritdoc />
public async Task<TemplateFolder?> GetFolderByIdAsync(int id, CancellationToken cancellationToken = default)
=> await _context.TemplateFolders.FindAsync(new object[] { id }, cancellationToken);
/// <inheritdoc />
public async Task<IReadOnlyList<TemplateFolder>> GetAllFoldersAsync(CancellationToken cancellationToken = default)
=> await _context.TemplateFolders.ToListAsync(cancellationToken);
/// <inheritdoc />
public async Task AddFolderAsync(TemplateFolder folder, CancellationToken cancellationToken = default)
=> await _context.TemplateFolders.AddAsync(folder, cancellationToken);
/// <inheritdoc />
public Task UpdateFolderAsync(TemplateFolder folder, CancellationToken cancellationToken = default)
{
_context.TemplateFolders.Update(folder);
return Task.CompletedTask;
}
/// <inheritdoc />
public async Task DeleteFolderAsync(int id, CancellationToken cancellationToken = default)
{
var folder = await _context.TemplateFolders.FindAsync(new object[] { id }, cancellationToken);
if (folder != null)
{
_context.TemplateFolders.Remove(folder);
}
}
/// <inheritdoc />
public async Task<int> SaveChangesAsync(CancellationToken cancellationToken = default)
{
return await _context.SaveChangesAsync(cancellationToken);
}
}