Joseph Doherty
345 lines
15 KiB
C#
345 lines
15 KiB
C#
using ScadaLink.Commons.Entities.ExternalSystems;
|
|
using ScadaLink.Commons.Entities.InboundApi;
|
|
using ScadaLink.Commons.Entities.Notifications;
|
|
using ScadaLink.Commons.Entities.Scripts;
|
|
using ScadaLink.Commons.Entities.Templates;
|
|
|
|
namespace ScadaLink.Transport.Serialization;
|
|
|
|
/// <summary>
|
|
/// Converts between the persistence-shaped <see cref="EntityAggregate"/> and
|
|
/// the wire-shaped <see cref="BundleContentDto"/>. The conversion strips EF
|
|
/// identity (FK ints) and references inter-entity links by name so bundles
|
|
/// remain portable across environments. Secrets are carved into a per-entity
|
|
/// <see cref="SecretsBlock"/> so the bundle's secret-free public surface can
|
|
/// be inspected (or, in future, exported without secrets) without touching the
|
|
/// rest of the payload.
|
|
/// </summary>
|
|
public sealed class EntitySerializer
|
|
{
|
|
public BundleContentDto ToBundleContent(EntityAggregate aggregate)
|
|
{
|
|
ArgumentNullException.ThrowIfNull(aggregate);
|
|
|
|
var folderNameById = aggregate.TemplateFolders.ToDictionary(f => f.Id, f => f.Name);
|
|
var templateNameById = aggregate.Templates.ToDictionary(t => t.Id, t => t.Name);
|
|
|
|
return new BundleContentDto(
|
|
TemplateFolders: aggregate.TemplateFolders.Select(f => new TemplateFolderDto(
|
|
Name: f.Name,
|
|
ParentName: f.ParentFolderId is { } pid && folderNameById.TryGetValue(pid, out var pname) ? pname : null,
|
|
SortOrder: f.SortOrder)).ToList(),
|
|
Templates: aggregate.Templates.Select(t => new TemplateDto(
|
|
Name: t.Name,
|
|
FolderName: t.FolderId is { } fid && folderNameById.TryGetValue(fid, out var fname) ? fname : null,
|
|
BaseTemplateName: t.ParentTemplateId is { } btid && templateNameById.TryGetValue(btid, out var bname) ? bname : null,
|
|
Description: t.Description,
|
|
Attributes: t.Attributes.Select(a => new TemplateAttributeDto(
|
|
Name: a.Name,
|
|
Value: a.Value,
|
|
DataType: a.DataType,
|
|
IsLocked: a.IsLocked,
|
|
Description: a.Description,
|
|
DataSourceReference: a.DataSourceReference)).ToList(),
|
|
Alarms: t.Alarms.Select(a => new TemplateAlarmDto(
|
|
Name: a.Name,
|
|
Description: a.Description,
|
|
PriorityLevel: a.PriorityLevel,
|
|
TriggerType: a.TriggerType,
|
|
TriggerConfiguration: a.TriggerConfiguration,
|
|
IsLocked: a.IsLocked)).ToList(),
|
|
Scripts: t.Scripts.Select(s => new TemplateScriptDto(
|
|
Name: s.Name,
|
|
Code: s.Code,
|
|
TriggerType: s.TriggerType,
|
|
TriggerConfiguration: s.TriggerConfiguration,
|
|
ParameterDefinitions: s.ParameterDefinitions,
|
|
ReturnDefinition: s.ReturnDefinition,
|
|
IsLocked: s.IsLocked)).ToList(),
|
|
Compositions: t.Compositions.Select(c => new TemplateCompositionDto(
|
|
InstanceName: c.InstanceName,
|
|
ComposedTemplateName: templateNameById.TryGetValue(c.ComposedTemplateId, out var cn) ? cn : string.Empty)).ToList())).ToList(),
|
|
SharedScripts: aggregate.SharedScripts.Select(s => new SharedScriptDto(
|
|
Name: s.Name,
|
|
Code: s.Code,
|
|
ParameterDefinitions: s.ParameterDefinitions,
|
|
ReturnDefinition: s.ReturnDefinition)).ToList(),
|
|
ExternalSystems: aggregate.ExternalSystems.Select(sys =>
|
|
{
|
|
var methods = aggregate.ExternalSystemMethods
|
|
.Where(m => m.ExternalSystemDefinitionId == sys.Id)
|
|
.Select(m => new ExternalSystemMethodDto(
|
|
Name: m.Name,
|
|
HttpMethod: m.HttpMethod,
|
|
Path: m.Path,
|
|
ParameterDefinitions: m.ParameterDefinitions,
|
|
ReturnDefinition: m.ReturnDefinition))
|
|
.ToList();
|
|
|
|
SecretsBlock? secrets = null;
|
|
if (!string.IsNullOrEmpty(sys.AuthConfiguration))
|
|
{
|
|
secrets = new SecretsBlock(new Dictionary<string, string>(StringComparer.Ordinal)
|
|
{
|
|
["AuthConfiguration"] = sys.AuthConfiguration,
|
|
});
|
|
}
|
|
|
|
return new ExternalSystemDto(
|
|
Name: sys.Name,
|
|
BaseUrl: sys.EndpointUrl,
|
|
AuthType: sys.AuthType,
|
|
Methods: methods,
|
|
Secrets: secrets);
|
|
}).ToList(),
|
|
DatabaseConnections: aggregate.DatabaseConnections.Select(dc => new DatabaseConnectionDto(
|
|
Name: dc.Name,
|
|
MaxRetries: dc.MaxRetries,
|
|
RetryDelay: dc.RetryDelay,
|
|
// Connection strings typically embed credentials inline; treat the entire
|
|
// string as secret rather than try to parse out the password fragment.
|
|
Secrets: new SecretsBlock(new Dictionary<string, string>(StringComparer.Ordinal)
|
|
{
|
|
["ConnectionString"] = dc.ConnectionString,
|
|
}))).ToList(),
|
|
NotificationLists: aggregate.NotificationLists.Select(nl => new NotificationListDto(
|
|
Name: nl.Name,
|
|
Type: nl.Type,
|
|
Recipients: nl.Recipients.Select(r => new NotificationRecipientDto(
|
|
Name: r.Name,
|
|
EmailAddress: r.EmailAddress)).ToList())).ToList(),
|
|
SmtpConfigs: aggregate.SmtpConfigurations.Select(smtp =>
|
|
{
|
|
SecretsBlock? secrets = null;
|
|
if (!string.IsNullOrEmpty(smtp.Credentials))
|
|
{
|
|
secrets = new SecretsBlock(new Dictionary<string, string>(StringComparer.Ordinal)
|
|
{
|
|
["Credentials"] = smtp.Credentials,
|
|
});
|
|
}
|
|
|
|
return new SmtpConfigDto(
|
|
Host: smtp.Host,
|
|
Port: smtp.Port,
|
|
AuthType: smtp.AuthType,
|
|
FromAddress: smtp.FromAddress,
|
|
TlsMode: smtp.TlsMode,
|
|
ConnectionTimeoutSeconds: smtp.ConnectionTimeoutSeconds,
|
|
MaxConcurrentConnections: smtp.MaxConcurrentConnections,
|
|
MaxRetries: smtp.MaxRetries,
|
|
RetryDelay: smtp.RetryDelay,
|
|
Secrets: secrets);
|
|
}).ToList(),
|
|
// ApiKey stores only KeyHash already; no plaintext to carve. SecretsBlock
|
|
// stays null per design — KeyHash is on the public DTO.
|
|
ApiKeys: aggregate.ApiKeys.Select(k => new ApiKeyDto(
|
|
Name: k.Name,
|
|
KeyHash: k.KeyHash,
|
|
IsEnabled: k.IsEnabled,
|
|
Secrets: null)).ToList(),
|
|
ApiMethods: aggregate.ApiMethods.Select(m => new ApiMethodDto(
|
|
Name: m.Name,
|
|
Script: m.Script,
|
|
ApprovedApiKeyIds: m.ApprovedApiKeyIds,
|
|
ParameterDefinitions: m.ParameterDefinitions,
|
|
ReturnDefinition: m.ReturnDefinition,
|
|
TimeoutSeconds: m.TimeoutSeconds)).ToList());
|
|
}
|
|
|
|
public EntityAggregate FromBundleContent(BundleContentDto content)
|
|
{
|
|
ArgumentNullException.ThrowIfNull(content);
|
|
|
|
// Folders: assign synthetic ids by ordinal, resolve parent pointers by name.
|
|
var folders = content.TemplateFolders
|
|
.Select((dto, ix) => new TemplateFolder(dto.Name) { Id = ix + 1, SortOrder = dto.SortOrder })
|
|
.ToList();
|
|
var folderIdByName = folders.ToDictionary(f => f.Name, f => f.Id, StringComparer.Ordinal);
|
|
for (var i = 0; i < folders.Count; i++)
|
|
{
|
|
var parentName = content.TemplateFolders[i].ParentName;
|
|
if (parentName is not null && folderIdByName.TryGetValue(parentName, out var parentId))
|
|
{
|
|
folders[i].ParentFolderId = parentId;
|
|
}
|
|
}
|
|
|
|
// Templates: same pattern — assign ids, second pass resolves base + folder.
|
|
var templates = content.Templates
|
|
.Select((dto, ix) =>
|
|
{
|
|
var t = new Template(dto.Name) { Id = ix + 1, Description = dto.Description };
|
|
foreach (var a in dto.Attributes)
|
|
{
|
|
t.Attributes.Add(new TemplateAttribute(a.Name)
|
|
{
|
|
TemplateId = t.Id,
|
|
Value = a.Value,
|
|
DataType = a.DataType,
|
|
IsLocked = a.IsLocked,
|
|
Description = a.Description,
|
|
DataSourceReference = a.DataSourceReference,
|
|
});
|
|
}
|
|
foreach (var al in dto.Alarms)
|
|
{
|
|
t.Alarms.Add(new TemplateAlarm(al.Name)
|
|
{
|
|
TemplateId = t.Id,
|
|
Description = al.Description,
|
|
PriorityLevel = al.PriorityLevel,
|
|
TriggerType = al.TriggerType,
|
|
TriggerConfiguration = al.TriggerConfiguration,
|
|
IsLocked = al.IsLocked,
|
|
});
|
|
}
|
|
foreach (var s in dto.Scripts)
|
|
{
|
|
t.Scripts.Add(new TemplateScript(s.Name, s.Code)
|
|
{
|
|
TemplateId = t.Id,
|
|
TriggerType = s.TriggerType,
|
|
TriggerConfiguration = s.TriggerConfiguration,
|
|
ParameterDefinitions = s.ParameterDefinitions,
|
|
ReturnDefinition = s.ReturnDefinition,
|
|
IsLocked = s.IsLocked,
|
|
});
|
|
}
|
|
return t;
|
|
})
|
|
.ToList();
|
|
var templateIdByName = templates.ToDictionary(t => t.Name, t => t.Id, StringComparer.Ordinal);
|
|
for (var i = 0; i < templates.Count; i++)
|
|
{
|
|
var dto = content.Templates[i];
|
|
if (dto.FolderName is not null && folderIdByName.TryGetValue(dto.FolderName, out var fid))
|
|
{
|
|
templates[i].FolderId = fid;
|
|
}
|
|
if (dto.BaseTemplateName is not null && templateIdByName.TryGetValue(dto.BaseTemplateName, out var btid))
|
|
{
|
|
templates[i].ParentTemplateId = btid;
|
|
}
|
|
foreach (var compDto in dto.Compositions)
|
|
{
|
|
var comp = new TemplateComposition(compDto.InstanceName)
|
|
{
|
|
TemplateId = templates[i].Id,
|
|
};
|
|
if (templateIdByName.TryGetValue(compDto.ComposedTemplateName, out var ctid))
|
|
{
|
|
comp.ComposedTemplateId = ctid;
|
|
}
|
|
templates[i].Compositions.Add(comp);
|
|
}
|
|
}
|
|
|
|
var sharedScripts = content.SharedScripts
|
|
.Select((dto, ix) => new SharedScript(dto.Name, dto.Code)
|
|
{
|
|
Id = ix + 1,
|
|
ParameterDefinitions = dto.ParameterDefinitions,
|
|
ReturnDefinition = dto.ReturnDefinition,
|
|
})
|
|
.ToList();
|
|
|
|
var externalSystems = new List<ExternalSystemDefinition>();
|
|
var externalSystemMethods = new List<ExternalSystemMethod>();
|
|
for (var ix = 0; ix < content.ExternalSystems.Count; ix++)
|
|
{
|
|
var dto = content.ExternalSystems[ix];
|
|
var sys = new ExternalSystemDefinition(dto.Name, dto.BaseUrl, dto.AuthType)
|
|
{
|
|
Id = ix + 1,
|
|
AuthConfiguration = dto.Secrets?.Values.TryGetValue("AuthConfiguration", out var auth) == true ? auth : null,
|
|
};
|
|
externalSystems.Add(sys);
|
|
foreach (var m in dto.Methods)
|
|
{
|
|
externalSystemMethods.Add(new ExternalSystemMethod(m.Name, m.HttpMethod, m.Path)
|
|
{
|
|
ExternalSystemDefinitionId = sys.Id,
|
|
ParameterDefinitions = m.ParameterDefinitions,
|
|
ReturnDefinition = m.ReturnDefinition,
|
|
});
|
|
}
|
|
}
|
|
|
|
var databaseConnections = content.DatabaseConnections
|
|
.Select((dto, ix) =>
|
|
{
|
|
var connStr = dto.Secrets?.Values.TryGetValue("ConnectionString", out var cs) == true ? cs : string.Empty;
|
|
return new DatabaseConnectionDefinition(dto.Name, connStr)
|
|
{
|
|
Id = ix + 1,
|
|
MaxRetries = dto.MaxRetries,
|
|
RetryDelay = dto.RetryDelay,
|
|
};
|
|
})
|
|
.ToList();
|
|
|
|
var notificationLists = content.NotificationLists
|
|
.Select((dto, ix) =>
|
|
{
|
|
var list = new NotificationList(dto.Name) { Id = ix + 1, Type = dto.Type };
|
|
foreach (var r in dto.Recipients)
|
|
{
|
|
list.Recipients.Add(new NotificationRecipient(r.Name, r.EmailAddress)
|
|
{
|
|
NotificationListId = list.Id,
|
|
});
|
|
}
|
|
return list;
|
|
})
|
|
.ToList();
|
|
|
|
var smtpConfigurations = content.SmtpConfigs
|
|
.Select((dto, ix) => new SmtpConfiguration(dto.Host, dto.AuthType, dto.FromAddress)
|
|
{
|
|
Id = ix + 1,
|
|
Port = dto.Port,
|
|
Credentials = dto.Secrets?.Values.TryGetValue("Credentials", out var cred) == true ? cred : null,
|
|
TlsMode = dto.TlsMode,
|
|
ConnectionTimeoutSeconds = dto.ConnectionTimeoutSeconds,
|
|
MaxConcurrentConnections = dto.MaxConcurrentConnections,
|
|
MaxRetries = dto.MaxRetries,
|
|
RetryDelay = dto.RetryDelay,
|
|
})
|
|
.ToList();
|
|
|
|
var apiKeys = content.ApiKeys
|
|
.Select((dto, ix) =>
|
|
{
|
|
var key = ApiKey.FromHash(dto.Name, dto.KeyHash);
|
|
key.Id = ix + 1;
|
|
key.IsEnabled = dto.IsEnabled;
|
|
return key;
|
|
})
|
|
.ToList();
|
|
|
|
var apiMethods = content.ApiMethods
|
|
.Select((dto, ix) => new ApiMethod(dto.Name, dto.Script)
|
|
{
|
|
Id = ix + 1,
|
|
ApprovedApiKeyIds = dto.ApprovedApiKeyIds,
|
|
ParameterDefinitions = dto.ParameterDefinitions,
|
|
ReturnDefinition = dto.ReturnDefinition,
|
|
TimeoutSeconds = dto.TimeoutSeconds,
|
|
})
|
|
.ToList();
|
|
|
|
return new EntityAggregate(
|
|
TemplateFolders: folders,
|
|
Templates: templates,
|
|
SharedScripts: sharedScripts,
|
|
ExternalSystems: externalSystems,
|
|
ExternalSystemMethods: externalSystemMethods,
|
|
DatabaseConnections: databaseConnections,
|
|
NotificationLists: notificationLists,
|
|
SmtpConfigurations: smtpConfigurations,
|
|
ApiKeys: apiKeys,
|
|
ApiMethods: apiMethods);
|
|
}
|
|
}
|