feat: Start MeteredDataForMeasurementPoint orchestration from EDI

source/IncomingMessages.Infrastructure/IncomingMessagePublisher.cs

@@ -128,13 +128,9 @@ private async Task SendInitializeMeteredDataForMeasurementPointMessageProcessAsy
     {
         ArgumentNullException.ThrowIfNull(initializeMeteredDataForMeasurementPointMessageProcessDto);
 
-        var serviceBusMessage =
-            new ServiceBusMessage(
-                _serializer.Serialize(initializeMeteredDataForMeasurementPointMessageProcessDto))
-            {
-                Subject = nameof(InitializeMeteredDataForMeasurementPointMessageProcessDto),
-            };
-
-        await _sender.SendMessageAsync(serviceBusMessage, cancellationToken).ConfigureAwait(false);
+        await _requestProcessOrchestrationStarter.StartMeteredDataForMeasurementPointOrchestrationAsync(
+            initializeMeteredDataForMeasurementPointMessageProcessDto,
+            cancellationToken)
+        .ConfigureAwait(false);
     }
 }

source/IncomingMessages.Infrastructure/IncomingMessages.Infrastructure.csproj

@@ -1,4 +1,4 @@
-<Project Sdk="Microsoft.NET.Sdk">
+<Project Sdk="Microsoft.NET.Sdk">
   <PropertyGroup>
     <AssemblyName>Energinet.DataHub.EDI.IncomingMessages.Infrastructure</AssemblyName>
     <RootNamespace>Energinet.DataHub.EDI.IncomingMessages.Infrastructure</RootNamespace>

source/IncomingMessages.Infrastructure/ProcessManager/IRequestProcessOrchestrationStarter.cs

@@ -25,4 +25,8 @@ Task StartRequestWholesaleServicesOrchestrationAsync(
     Task StartRequestAggregatedMeasureDataOrchestrationAsync(
         InitializeAggregatedMeasureDataProcessDto initializeProcessDto,
         CancellationToken cancellationToken);
+
+    Task StartMeteredDataForMeasurementPointOrchestrationAsync(
+        InitializeMeteredDataForMeasurementPointMessageProcessDto initializeProcessDto,
+        CancellationToken cancellationToken);
 }

source/IncomingMessages.Infrastructure/ProcessManager/RequestProcessOrchestrationStarter.cs

@@ -12,13 +12,17 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
+using System.Collections.ObjectModel;
+using System.Globalization;
 using Energinet.DataHub.EDI.BuildingBlocks.Domain.Authentication;
 using Energinet.DataHub.EDI.BuildingBlocks.Domain.Models;
 using Energinet.DataHub.EDI.Process.Interfaces;
 using Energinet.DataHub.ProcessManager.Abstractions.Api.Model.OrchestrationInstance;
 using Energinet.DataHub.ProcessManager.Client;
+using Energinet.DataHub.ProcessManager.Orchestrations.Abstractions.Processes.BRS_021.ForwardMeteredData.V1.Model;
 using Energinet.DataHub.ProcessManager.Orchestrations.Abstractions.Processes.BRS_026.V1.Model;
 using Energinet.DataHub.ProcessManager.Orchestrations.Abstractions.Processes.BRS_028.V1.Model;
+using NodaTime.Text;
 
 namespace Energinet.DataHub.EDI.IncomingMessages.Infrastructure.ProcessManager;
 
@@ -130,6 +134,62 @@ public async Task StartRequestAggregatedMeasureDataOrchestrationAsync(
         await Task.WhenAll(startProcessTasks).ConfigureAwait(false);
     }
 
+    public async Task StartMeteredDataForMeasurementPointOrchestrationAsync(
+        InitializeMeteredDataForMeasurementPointMessageProcessDto initializeProcessDto,
+        CancellationToken cancellationToken)
+    {
+        var actorId = GetAuthenticatedActorId(initializeProcessDto.MessageId);
+        var actorIdentity = new ActorIdentityDto(actorId);
+
+        var startProcessTasks = new List<Task>();
+        foreach (var transaction in initializeProcessDto.Series)
+        {
+            var meteringPointType = transaction.MeteringPointType is not null
+                ? MeteringPointType.TryGetNameFromCode(transaction.MeteringPointType, fallbackValue: transaction.MeteringPointType)
+                : null;
+
+            var productUnitType = transaction.ProductUnitType is not null
+                ? MeasurementUnit.TryGetNameFromCode(transaction.ProductUnitType, fallbackValue: transaction.ProductUnitType)
+                : null;
+
+            var resolution = transaction.Resolution is not null
+                ? Resolution.TryGetNameFromCode(transaction.Resolution, fallbackValue: transaction.Resolution)
+                : null;
+
+            var startCommand =
+                new StartForwardMeteredDataCommandV1(
+                    operatingIdentity: actorIdentity,
+                    new MeteredDataForMeasurementPointMessageInputV1(
+                        AuthenticatedActorId: actorId,
+                        TransactionId: transaction.TransactionId,
+                        MeteringPointId: transaction.MeteringPointLocationId,
+                        MeteringPointType: meteringPointType,
+                        ProductNumber: transaction.ProductNumber,
+                        MeasureUnit: productUnitType,
+                        RegistrationDateTime: InstantPattern.General.Parse(initializeProcessDto.CreatedAt).Value.ToString(),
+                        Resolution: resolution,
+                        StartDateTime: transaction.StartDateTime,
+                        EndDateTime: transaction.EndDateTime,
+                        GridAccessProviderNumber: transaction.RequestedByActor.ActorNumber.Value,
+                        DelegatedGridAreaCodes: transaction.DelegatedGridAreaCodes,
+                        EnergyObservations:
+                            new ReadOnlyCollection<EnergyObservation>(
+                                transaction.EnergyObservations
+                                    .Select(energyObservation =>
+                                        new EnergyObservation(
+                                            Position: energyObservation.Position,
+                                            EnergyQuantity: energyObservation.EnergyQuantity,
+                                            QuantityQuality: energyObservation.QuantityQuality))
+                                    .ToList())),
+                    initializeProcessDto.MessageId);
+
+            var startProcessTask = _processManagerMessageClient.StartNewOrchestrationInstanceAsync(startCommand, CancellationToken.None);
+            startProcessTasks.Add(startProcessTask);
+        }
+
+        await Task.WhenAll(startProcessTasks).ConfigureAwait(false);
+    }
+
     private Guid GetAuthenticatedActorId(string messageId)
     {
         if (!_authenticatedActor.TryGetCurrentActorIdentity(out var actorIdentity))

source/Process.Application/ProcessInitializationHandlers/InitializeAggregatedMeasureDataHandler.cs

@@ -12,8 +12,10 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
+using Energinet.DataHub.EDI.BuildingBlocks.Infrastructure.FeatureFlag;
 using Energinet.DataHub.EDI.BuildingBlocks.Interfaces;
 using Energinet.DataHub.EDI.Process.Application.Transactions.AggregatedMeasureData;
+using Energinet.DataHub.EDI.Process.Domain.Transactions;
 using Energinet.DataHub.EDI.Process.Interfaces;
 using MediatR;
 
@@ -41,6 +43,7 @@ public bool CanHandle(string processTypeToInitialize)
     public async Task ProcessAsync(byte[] processInitializationData)
     {
         var marketMessage = _serializer.Deserialize<InitializeAggregatedMeasureDataProcessDto>(System.Text.Encoding.UTF8.GetString(processInitializationData));
+
         await _mediator.Send(new InitializeAggregatedMeasureDataProcessesCommand(marketMessage)).ConfigureAwait(false);
     }
 }

source/Process.Application/ProcessInitializationHandlers/InitializeMeteredDataForMeasurementPointHandler.cs

@@ -19,9 +19,7 @@
 using Energinet.DataHub.EDI.OutgoingMessages.Interfaces;
 using Energinet.DataHub.EDI.OutgoingMessages.Interfaces.Models.MeteredDataForMeasurementPoint;
 using Energinet.DataHub.EDI.Process.Interfaces;
-using MediatR;
 using Microsoft.Extensions.Logging;
-using NodaTime;
 using NodaTime.Text;
 using EventId = Energinet.DataHub.EDI.BuildingBlocks.Domain.Models.EventId;
 

source/Tests/Infrastructure/IncomingMessages/RequestProcessOrchestrationStarterTests.cs

@@ -14,11 +14,13 @@
 
 using Energinet.DataHub.EDI.BuildingBlocks.Domain.Authentication;
 using Energinet.DataHub.EDI.BuildingBlocks.Domain.Models;
+using Energinet.DataHub.EDI.IncomingMessages.Domain;
 using Energinet.DataHub.EDI.IncomingMessages.Infrastructure.ProcessManager;
 using Energinet.DataHub.EDI.Process.Interfaces;
 using Energinet.DataHub.ProcessManager.Abstractions.Api.Model;
 using Energinet.DataHub.ProcessManager.Abstractions.Api.Model.OrchestrationInstance;
 using Energinet.DataHub.ProcessManager.Client;
+using Energinet.DataHub.ProcessManager.Orchestrations.Abstractions.Processes.BRS_021.ForwardMeteredData.V1.Model;
 using Energinet.DataHub.ProcessManager.Orchestrations.Abstractions.Processes.BRS_026.V1.Model;
 using Energinet.DataHub.ProcessManager.Orchestrations.Abstractions.Processes.BRS_028.V1.Model;
 using FluentAssertions;
@@ -247,4 +249,128 @@ await sut.StartRequestAggregatedMeasureDataOrchestrationAsync(
             .NotBeNull()
             .And.BeEquivalentTo(expectedCommand);
     }
+
+    [Theory]
+    [InlineData("571313101700011887", "E17", "2023-05-31T22:00:00Z", "8716867000030", "Kwh", "PT1H")]
+    [InlineData(null, null, null, null, null, null)]
+    public async Task Given_MeteredDataForMeasurementPoint_When_StartMeteredDataForMeasurementCalled_Then_ProcessManagerMessageClientIsCalled(
+        string? expectedMeteringPointId,
+        string? expectedMeteringPointType,
+        string? expectedEndDate,
+        string? expectedProductNumber,
+        string? expectedMeasureUnit,
+        string? expectedResolution)
+    {
+        // Arrange
+        // => Setup input
+        var requestedByActor = RequestedByActor.From(ActorNumber.Create("1111111111111"), ActorRole.GridAccessProvider);
+
+        var expectedBusinessReason = BusinessReason.PeriodicMetering;
+        var expectedTransactionId = MessageId.Create("9b6184bf-2f05-40b9-d783-08dc814df95a").Value;
+        var expectedStart = "2023-04-30T22:00:00Z";
+        var expectedRegistrationDateFrom = "2023-04-30T22:00:00Z";
+        var expectedPosition = "1";
+        var expectedEnergyQuantity = "A03";
+        var expectedQuantityQuality = "1001";
+
+        var meteringPointType = expectedMeteringPointType is not null
+            ? MeteringPointType.FromCode(expectedMeteringPointType)
+            : null;
+        var productUnitType = expectedMeasureUnit is not null
+            ? MeasurementUnit.FromCode(expectedMeasureUnit)
+            : null;
+        var resolution = expectedResolution is not null
+            ? Resolution.FromCode(expectedResolution)
+            : null;
+
+        var initializeProcessDto = new InitializeMeteredDataForMeasurementPointMessageProcessDto(
+            MessageId: expectedTransactionId,
+            MessageType: "E66",
+            CreatedAt: expectedRegistrationDateFrom,
+            BusinessReason: expectedBusinessReason.Code,
+            BusinessType: "23",
+            Series:
+            [
+                new InitializeMeteredDataForMeasurementPointMessageSeries(
+                    TransactionId: expectedTransactionId,
+                    Resolution: resolution?.Code,
+                    StartDateTime: expectedStart,
+                    EndDateTime: expectedEndDate,
+                    ProductNumber: expectedProductNumber,
+                    ProductUnitType: productUnitType?.Code,
+                    MeteringPointType: meteringPointType?.Code,
+                    MeteringPointLocationId: expectedMeteringPointId,
+                    DelegatedGridAreaCodes: null,
+                    RequestedByActor: requestedByActor,
+                    EnergyObservations:
+                    [
+                        new InitializeEnergyObservation(
+                            Position: expectedPosition,
+                            EnergyQuantity: expectedEnergyQuantity,
+                            QuantityQuality: expectedQuantityQuality)
+                    ])
+            ]);
+
+        // => Setup Process Manager client and callback
+        var processManagerClient = new Mock<IProcessManagerMessageClient>();
+        MessageCommand<MeteredDataForMeasurementPointMessageInputV1>? actualCommand = null;
+        processManagerClient.Setup(
+                client => client.StartNewOrchestrationInstanceAsync(
+                    It.IsAny<StartForwardMeteredDataCommandV1>(),
+                    It.IsAny<CancellationToken>()))
+            .Callback((MessageCommand<MeteredDataForMeasurementPointMessageInputV1> command, CancellationToken token) => actualCommand = command);
+
+        // => Setup authenticated actor
+        var expectedActorId = Guid.NewGuid();
+        var authenticatedActor = new AuthenticatedActor();
+        authenticatedActor.SetAuthenticatedActor(new ActorIdentity(
+            ActorNumber.Create("1234567890123"),
+            Restriction.None,
+            ActorRole.GridAccessProvider,
+            expectedActorId));
+
+        var sut = new RequestProcessOrchestrationStarter(
+            processManagerClient.Object,
+            authenticatedActor);
+
+        // Act
+        await sut.StartMeteredDataForMeasurementPointOrchestrationAsync(
+            initializeProcessDto,
+            CancellationToken.None);
+
+        // Assert
+        processManagerClient.Verify(
+            client => client.StartNewOrchestrationInstanceAsync(
+                It.IsAny<StartForwardMeteredDataCommandV1>(),
+                It.IsAny<CancellationToken>()),
+            Times.Once);
+
+        var expectedCommand = new StartForwardMeteredDataCommandV1(
+            operatingIdentity: new ActorIdentityDto(expectedActorId),
+            inputParameter: new MeteredDataForMeasurementPointMessageInputV1(
+                AuthenticatedActorId: expectedActorId,
+                TransactionId: expectedTransactionId,
+                MeteringPointId: expectedMeteringPointId,
+                MeteringPointType: meteringPointType?.Name,
+                ProductNumber: expectedProductNumber,
+                MeasureUnit: expectedMeasureUnit,
+                RegistrationDateTime: expectedRegistrationDateFrom,
+                Resolution: resolution?.Name,
+                StartDateTime: expectedStart,
+                EndDateTime: expectedEndDate,
+                GridAccessProviderNumber: requestedByActor.ActorNumber.Value,
+                DelegatedGridAreaCodes: null,
+                EnergyObservations:
+                [
+                    new ProcessManager.Orchestrations.Abstractions.Processes.BRS_021.ForwardMeteredData.V1.Model.EnergyObservation(
+                        Position: expectedPosition,
+                        EnergyQuantity: expectedEnergyQuantity,
+                        QuantityQuality: expectedQuantityQuality)
+                ]),
+            messageId: expectedTransactionId);
+
+        actualCommand.Should()
+            .NotBeNull()
+            .And.BeEquivalentTo(expectedCommand);
+    }
 }