Add TechnicalDataBuilder with ECLASS/IEC-61360 validation and Template Integration

FluentAAS/FluentAAS.Templates.Tests/TechnicalData/TechnicalDataBuilderTests.cs

@@ -0,0 +1,102 @@
+using AasCore.Aas3_0;
+using FluentAAS.Builder;
+using FluentAAS.Templates.TechnicalData;
+using Shouldly;
+
+namespace FluentAAS.Templates.Tests.TechnicalData;
+
+public class TechnicalDataBuilderTests
+{
+    [Fact]
+    public void BuildTechnicalData_ShouldFail_WhenMandatoryParametersAreMissing()
+    {
+        var envBuilder = AasBuilder.Create();
+        var shellBuilder = envBuilder.AddShell("urn:aas:example:shell:technical-data", "DriveShell");
+
+        var sut = shellBuilder.AddTechnicalData("urn:aas:example:submodel:technical-data")
+                              .WithMotorPerformance(motor => motor
+                                  .WithRatedVoltage(400m)
+                                  .WithRatedCurrent(82.5m));
+
+        var ex = Record.Exception(() => sut.BuildTechnicalData());
+
+        ex.ShouldBeOfType<InvalidOperationException>();
+        ex.Message.ShouldContain("MotorPerformance.RatedPower");
+        ex.Message.ShouldContain("MotorPerformance.RatedSpeed");
+        ex.Message.ShouldContain("BearingCharacteristics.InnerDiameter");
+    }
+
+    [Fact]
+    public void BuildTechnicalData_ShouldFail_WhenUnitIsInvalid()
+    {
+        var envBuilder = AasBuilder.Create();
+        var shellBuilder = envBuilder.AddShell("urn:aas:example:shell:technical-data", "DriveShell");
+
+        var ex = Record.Exception(() => shellBuilder.AddTechnicalData("urn:aas:example:submodel:technical-data")
+            .WithMotorPerformance(motor => motor.WithRatedVoltage(400m, "mm")));
+
+        ex.ShouldBeOfType<InvalidOperationException>();
+        ex.Message.ShouldContain("Unit 'mm' is invalid for 'RatedVoltage'");
+    }
+
+    [Fact]
+    public void BuildTechnicalData_ShouldFail_WhenSemanticIdDoesNotMatchEclassCatalogEntry()
+    {
+        var envBuilder = AasBuilder.Create();
+        var shellBuilder = envBuilder.AddShell("urn:aas:example:shell:technical-data", "DriveShell");
+
+        var ex = Record.Exception(() => shellBuilder.AddTechnicalData("urn:aas:example:submodel:technical-data")
+            .WithMotorPerformance(motor => motor.WithRatedVoltage(400m, "V", TechnicalDataSemantics.RatedCurrent)));
+
+        ex.ShouldBeOfType<InvalidOperationException>();
+        ex.Message.ShouldContain("Semantic ID mismatch for 'RatedVoltage'");
+    }
+
+    [Fact]
+    public void BuildTechnicalData_ShouldCreateStructuredGroups_WithEclassSemanticIds()
+    {
+        var envBuilder = AasBuilder.Create();
+        var shellBuilder = envBuilder.AddShell("urn:aas:example:shell:technical-data", "DriveShell");
+
+        shellBuilder.AddTechnicalData("urn:aas:example:submodel:technical-data")
+                    .WithMotorPerformance(motor => motor
+                        .WithRatedVoltage(400m, "V", TechnicalDataSemantics.RatedVoltage)
+                        .WithRatedCurrent(82.5m, "A", TechnicalDataSemantics.RatedCurrent)
+                        .WithRatedPower(45m, "kW", TechnicalDataSemantics.RatedPower)
+                        .WithRatedSpeed(1470m, "1/min", TechnicalDataSemantics.RatedSpeed))
+                    .WithBearingCharacteristics(bearing => bearing
+                        .WithInnerDiameter(50m, "mm", TechnicalDataSemantics.InnerDiameter)
+                        .WithOuterDiameter(90m, "mm", TechnicalDataSemantics.OuterDiameter)
+                        .WithWidth(20m, "mm", TechnicalDataSemantics.Width)
+                        .WithLimitingSpeed(6500m, "1/min", TechnicalDataSemantics.LimitingSpeed))
+                    .BuildTechnicalData();
+
+        var env = envBuilder.Build();
+
+        var submodel = env.Submodels!.Single(sm => sm.Id == "urn:aas:example:submodel:technical-data");
+        submodel.SemanticId!.Keys.Single().Value.ShouldBe(TechnicalDataSemantics.SubmodelTechnicalData);
+
+        var motorGroup = submodel.SubmodelElements!
+                                 .OfType<SubmodelElementCollection>()
+                                 .Single(x => x.IdShort == TechnicalDataIdentifiers.MotorPerformance);
+
+        var ratedVoltage = motorGroup.Value!
+                                    .OfType<Property>()
+                                    .Single(x => x.IdShort == TechnicalDataIdentifiers.RatedVoltage);
+
+        ratedVoltage.Value.ShouldBe("400");
+        ratedVoltage.Category.ShouldBe("V");
+        ratedVoltage.SemanticId!.Keys.Single().Value.ShouldBe(TechnicalDataSemantics.RatedVoltage);
+    }
+
+    [Fact]
+    public void CompositionExample_ShouldBuildEnvironment()
+    {
+        var env = TechnicalDataCompositionExample.BuildMotorAndBearingExampleEnvironment();
+
+        env.AssetAdministrationShells.ShouldNotBeNull();
+        env.AssetAdministrationShells!.Count.ShouldBe(1);
+        env.Submodels.ShouldNotBeNull();
+        env.Submodels!.Count.ShouldBe(1);
+    }
+}

FluentAAS/FluentAAS.Templates/TechnicalData/TechnicalDataBuilder.cs

@@ -0,0 +1,249 @@
+using FluentAAS.Builder;
+using FluentAAS.Builder.SubModel;
+
+namespace FluentAAS.Templates.TechnicalData;
+
+public sealed class TechnicalDataBuilder
+{
+    private readonly IShellBuilder _shellBuilder;
+    private string _id;
+    private string _idShort;
+
+    private readonly Dictionary<string, GroupAssignment> _groups = new(StringComparer.Ordinal);
+
+    internal TechnicalDataBuilder(IShellBuilder shellBuilder, string id, string idShort)
+    {
+        _shellBuilder = shellBuilder ?? throw new ArgumentNullException(nameof(shellBuilder));
+
+        if (string.IsNullOrWhiteSpace(id))
+        {
+            throw new ArgumentException("Submodel id must not be empty.", nameof(id));
+        }
+
+        if (string.IsNullOrWhiteSpace(idShort))
+        {
+            throw new ArgumentException("Submodel idShort must not be empty.", nameof(idShort));
+        }
+
+        _id = id;
+        _idShort = idShort;
+    }
+
+    public TechnicalDataBuilder WithIds(string id, string idShort)
+    {
+        if (string.IsNullOrWhiteSpace(id))
+        {
+            throw new ArgumentException("Submodel id must not be empty.", nameof(id));
+        }
+
+        if (string.IsNullOrWhiteSpace(idShort))
+        {
+            throw new ArgumentException("Submodel idShort must not be empty.", nameof(idShort));
+        }
+
+        _id = id;
+        _idShort = idShort;
+        return this;
+    }
+
+    public TechnicalDataBuilder WithMotorPerformance(Action<MotorPerformanceGroupBuilder> configure)
+    {
+        ArgumentNullException.ThrowIfNull(configure);
+
+        var groupBuilder = new MotorPerformanceGroupBuilder(this);
+        configure(groupBuilder);
+
+        return this;
+    }
+
+    public TechnicalDataBuilder WithBearingCharacteristics(Action<BearingCharacteristicsGroupBuilder> configure)
+    {
+        ArgumentNullException.ThrowIfNull(configure);
+
+        var groupBuilder = new BearingCharacteristicsGroupBuilder(this);
+        configure(groupBuilder);
+
+        return this;
+    }
+
+    public IShellBuilder BuildTechnicalData()
+    {
+        ValidateRequiredParameters();
+
+        var submodelBuilder = new SubmodelBuilder(_shellBuilder, _id, _idShort)
+            .WithSemanticId(ReferenceFactory.GlobalConceptDescription(TechnicalDataSemantics.SubmodelTechnicalData));
+
+        foreach (var group in _groups.Values.OrderBy(x => x.IdShort, StringComparer.Ordinal))
+        {
+            var collection = new SubmodelElementCollection
+            {
+                IdShort = group.IdShort,
+                Value = [],
+                SemanticId = ReferenceFactory.GlobalSemanticReference($"{TechnicalDataSemantics.SubmodelTechnicalData}/{group.IdShort}")
+            };
+
+            foreach (var assignment in group.Assignments.Values.OrderBy(x => x.Definition.IdShort, StringComparer.Ordinal))
+            {
+                ValidateEclassCatalogMapping(assignment.Definition.EclassIrdi);
+
+                var property = new Property(assignment.Definition.ValueType)
+                {
+                    IdShort = assignment.Definition.IdShort,
+                    Value = assignment.Value,
+                    ValueId = ReferenceFactory.GlobalSemanticReference(assignment.Definition.EclassIrdi),
+                    SemanticId = ReferenceFactory.GlobalConceptDescription(assignment.Definition.EclassIrdi),
+                    Category = assignment.Unit
+                };
+
+                collection.Value!.Add(property);
+            }
+
+            submodelBuilder.AddElement(collection);
+        }
+
+        var submodel = submodelBuilder.BuildSubmodel();
+        _shellBuilder.AddSubmodelReference(submodel);
+
+        return _shellBuilder;
+    }
+
+    private void ValidateRequiredParameters()
+    {
+        var missing = new List<string>();
+
+        foreach (var groupIdShort in new[] { TechnicalDataIdentifiers.MotorPerformance, TechnicalDataIdentifiers.BearingCharacteristics })
+        {
+            if (!_groups.TryGetValue(groupIdShort, out var group))
+            {
+                missing.AddRange(TechnicalDataEclassCatalog.RequiredInGroup(groupIdShort).Select(x => $"{groupIdShort}.{x.IdShort}"));
+                continue;
+            }
+
+            var required = TechnicalDataEclassCatalog.RequiredInGroup(groupIdShort);
+            missing.AddRange(required.Where(x => !group.Assignments.ContainsKey(x.IdShort)).Select(x => $"{groupIdShort}.{x.IdShort}"));
+        }
+
+        if (missing.Count == 0)
+        {
+            return;
+        }
+
+        throw new InvalidOperationException("Technical data is incomplete. Missing mandatory parameters: " + string.Join(", ", missing));
+    }
+
+    private static void ValidateEclassCatalogMapping(string eclassIrdi)
+    {
+        if (!TechnicalDataEclassCatalog.IsKnownEclassReference(eclassIrdi))
+        {
+            throw new InvalidOperationException($"The ECLASS semantic ID '{eclassIrdi}' is not available in the integrated ECLASS catalog map.");
+        }
+    }
+
+    internal void UpsertDecimalProperty(string groupIdShort, string idShort, decimal value, string unit, string? semanticIdOverride)
+    {
+        var definition = TechnicalDataEclassCatalog.ForIdShort(idShort);
+
+        if (!string.Equals(definition.GroupIdShort, groupIdShort, StringComparison.Ordinal))
+        {
+            throw new InvalidOperationException($"Property '{idShort}' is not allowed in group '{groupIdShort}'.");
+        }
+
+        if (definition.ValueType != DataTypeDefXsd.Decimal)
+        {
+            throw new InvalidOperationException($"Property '{idShort}' does not accept decimal values according to IEC 61360 type constraints.");
+        }
+
+        if (!definition.AllowedUnits.Contains(unit, StringComparer.OrdinalIgnoreCase))
+        {
+            throw new InvalidOperationException(
+                $"Unit '{unit}' is invalid for '{idShort}'. Allowed IEC 61360 units: {string.Join(", ", definition.AllowedUnits)}.");
+        }
+
+        if (!string.IsNullOrWhiteSpace(semanticIdOverride) && !string.Equals(semanticIdOverride, definition.EclassIrdi, StringComparison.Ordinal))
+        {
+            throw new InvalidOperationException(
+                $"Semantic ID mismatch for '{idShort}'. Expected '{definition.EclassIrdi}' but got '{semanticIdOverride}'.");
+        }
+
+        var group = GetOrCreateGroup(groupIdShort);
+        group.Assignments[idShort] = new PropertyAssignment(definition, value.ToString(System.Globalization.CultureInfo.InvariantCulture), unit);
+    }
+
+    private GroupAssignment GetOrCreateGroup(string groupIdShort)
+    {
+        if (_groups.TryGetValue(groupIdShort, out var existing))
+        {
+            return existing;
+        }
+
+        var created = new GroupAssignment(groupIdShort);
+        _groups[groupIdShort] = created;
+        return created;
+    }
+
+    private sealed class GroupAssignment(string idShort)
+    {
+        public string IdShort { get; } = idShort;
+
+        public Dictionary<string, PropertyAssignment> Assignments { get; } = new(StringComparer.Ordinal);
+    }
+
+    private sealed record PropertyAssignment(
+        TechnicalDataEclassCatalog.PropertyDefinition Definition,
+        string Value,
+        string Unit);
+
+    public sealed class MotorPerformanceGroupBuilder(TechnicalDataBuilder parent)
+    {
+        public MotorPerformanceGroupBuilder WithRatedVoltage(decimal value, string unit = "V", string? semanticId = null)
+        {
+            parent.UpsertDecimalProperty(TechnicalDataIdentifiers.MotorPerformance, TechnicalDataIdentifiers.RatedVoltage, value, unit, semanticId);
+            return this;
+        }
+
+        public MotorPerformanceGroupBuilder WithRatedCurrent(decimal value, string unit = "A", string? semanticId = null)
+        {
+            parent.UpsertDecimalProperty(TechnicalDataIdentifiers.MotorPerformance, TechnicalDataIdentifiers.RatedCurrent, value, unit, semanticId);
+            return this;
+        }
+
+        public MotorPerformanceGroupBuilder WithRatedPower(decimal value, string unit = "kW", string? semanticId = null)
+        {
+            parent.UpsertDecimalProperty(TechnicalDataIdentifiers.MotorPerformance, TechnicalDataIdentifiers.RatedPower, value, unit, semanticId);
+            return this;
+        }
+
+        public MotorPerformanceGroupBuilder WithRatedSpeed(decimal value, string unit = "1/min", string? semanticId = null)
+        {
+            parent.UpsertDecimalProperty(TechnicalDataIdentifiers.MotorPerformance, TechnicalDataIdentifiers.RatedSpeed, value, unit, semanticId);
+            return this;
+        }
+    }
+
+    public sealed class BearingCharacteristicsGroupBuilder(TechnicalDataBuilder parent)
+    {
+        public BearingCharacteristicsGroupBuilder WithInnerDiameter(decimal value, string unit = "mm", string? semanticId = null)
+        {
+            parent.UpsertDecimalProperty(TechnicalDataIdentifiers.BearingCharacteristics, TechnicalDataIdentifiers.InnerDiameter, value, unit, semanticId);
+            return this;
+        }
+
+        public BearingCharacteristicsGroupBuilder WithOuterDiameter(decimal value, string unit = "mm", string? semanticId = null)
+        {
+            parent.UpsertDecimalProperty(TechnicalDataIdentifiers.BearingCharacteristics, TechnicalDataIdentifiers.OuterDiameter, value, unit, semanticId);
+            return this;
+        }
+
+        public BearingCharacteristicsGroupBuilder WithWidth(decimal value, string unit = "mm", string? semanticId = null)
+        {
+            parent.UpsertDecimalProperty(TechnicalDataIdentifiers.BearingCharacteristics, TechnicalDataIdentifiers.Width, value, unit, semanticId);
+            return this;
+        }
+
+        public BearingCharacteristicsGroupBuilder WithLimitingSpeed(decimal value, string unit = "1/min", string? semanticId = null)
+        {
+            parent.UpsertDecimalProperty(TechnicalDataIdentifiers.BearingCharacteristics, TechnicalDataIdentifiers.LimitingSpeed, value, unit, semanticId);
+            return this;
+        }
+    }
+}

FluentAAS/FluentAAS.Templates/TechnicalData/TechnicalDataCompositionExample.cs

@@ -0,0 +1,25 @@
+using FluentAAS.Builder;
+
+namespace FluentAAS.Templates.TechnicalData;
+
+public static class TechnicalDataCompositionExample
+{
+    public static IEnvironment BuildMotorAndBearingExampleEnvironment()
+    {
+        return AasBuilder.Create()
+                         .AddShell("urn:aas:example:drivetrain:1000", "DriveTrainAAS")
+                         .AddTechnicalData("urn:aas:submodel:technical-data:drivetrain:1000")
+                         .WithMotorPerformance(motor => motor
+                             .WithRatedVoltage(400m, "V", TechnicalDataSemantics.RatedVoltage)
+                             .WithRatedCurrent(82.5m, "A", TechnicalDataSemantics.RatedCurrent)
+                             .WithRatedPower(45m, "kW", TechnicalDataSemantics.RatedPower)
+                             .WithRatedSpeed(1470m, "1/min", TechnicalDataSemantics.RatedSpeed))
+                         .WithBearingCharacteristics(bearing => bearing
+                             .WithInnerDiameter(50m, "mm", TechnicalDataSemantics.InnerDiameter)
+                             .WithOuterDiameter(90m, "mm", TechnicalDataSemantics.OuterDiameter)
+                             .WithWidth(20m, "mm", TechnicalDataSemantics.Width)
+                             .WithLimitingSpeed(6500m, "1/min", TechnicalDataSemantics.LimitingSpeed))
+                         .BuildTechnicalData()
+                         .Build();
+    }
+}