private static void WriteMarketDocument(Utf8JsonWriter writer, RsmHeader header)
{
writer.WriteStartObject("MarketDocument");
writer.WriteString("mRID", header.Identification);
writer.WriteString("Type", header.DocumentType);
writer.WriteString("CreatedDateTime", header.Creation.ToString());
WriteMarketParticipant(
writer,
"SenderMarketParticipant",
header.SenderIdentification,
"VA",
header.EnergyBusinessProcessRole);
WriteMarketParticipant(
writer,
"RecipientMarketParticipant",
header.RecipientIdentification,
"VA",
null);
writer.WriteString("ProcessType", header.EnergyBusinessProcess);
writer.WriteString("MarketServiceCategory_Kind", header.EnergyIndustryClassification);
writer.WriteEndObject();
}
private static async ValueTask ParseRsmHeaderAsync(XmlReader reader, RsmHeader header)
{
string rootElement = string.Empty;
string ns = string.Empty;
while (await reader.ReadAsync().ConfigureAwait(false))
{
if (RootElementNotFound(reader, rootElement, ns))
{
continue;
}
if (IfRootElementIsNotAssigned(rootElement, ns))
{
rootElement = reader.LocalName;
ns = reader.NamespaceURI;
}
else if (reader.Is("HeaderEnergyDocument", ns))
{
await ReadHeaderEnergyDocumentAsync(reader, header, ns).ConfigureAwait(false);
}
else if (reader.Is("ProcessEnergyContext", ns))
{
await ReadProcessEnergyContextAsync(reader, header, ns).ConfigureAwait(false);
}
if (reader.Is("ProcessEnergyContext", ns, XmlNodeType.EndElement))
{
break;
}
}
}
private static async ValueTask ParseMessageContainerAsync(XmlReader reader, RsmHeader header)
{
while (await reader.ReadAsync().ConfigureAwait(false))
{
if (reader.Is("MessageReference", B2BNamespace))
{
header.MessageReference = await reader.ReadElementContentAsStringAsync().ConfigureAwait(false);
break; // We do not need further values
}
}
}
public async ValueTask ConvertAsync(Stream input, Stream output, string correlationId)
{
if (input == null)
{
throw new ArgumentNullException(nameof(input));
}
if (output == null)
{
throw new ArgumentNullException(nameof(output));
}
using (var reader = XmlReader.Create(input, new XmlReaderSettings {
Async = true
}))
{
var header = new RsmHeader();
var writer = new Utf8JsonWriter(output);
try
{
reader.ReadToFollowing("MessageContainer", B2BNamespace);
await ParseMessageContainerAsync(reader, header).ConfigureAwait(false);
reader.ReadToFollowing("Payload", B2BNamespace);
await ParseRsmHeaderAsync(reader, header).ConfigureAwait(false);
await ConvertPayloadAsync(reader, header, writer, correlationId).ConfigureAwait(false);
await writer.FlushAsync().ConfigureAwait(false);
}
finally
{
output.Position = 0;
await writer.DisposeAsync().ConfigureAwait(false);
}
}
}
protected override async ValueTask ConvertPayloadAsync(
XmlReader reader,
RsmHeader header,
Utf8JsonWriter writer,
string correlationId)
{
if (reader == null)
{
throw new ArgumentNullException(nameof(reader));
}
if (header == null)
{
throw new ArgumentNullException(nameof(header));
}
if (writer == null)
{
throw new ArgumentNullException(nameof(writer));
}
writer.WriteStartArray();
while (await reader.ReadAsync().ConfigureAwait(false))
{
if (reader.Is("PayloadEnergyTimeSeries", B2BNamespace))
{
await ProcessPayloadEnergyTimeSeriesAsync(reader, header, writer, correlationId)
.ConfigureAwait(false);
}
if (reader.Is("DK_MeteredDataTimeSeries", B2BNamespace, XmlNodeType.EndElement))
{
break;
}
}
writer.WriteEndArray();
}
protected override async ValueTask ConvertPayloadAsync(
XmlReader reader,
RsmHeader header,
Utf8JsonWriter writer,
string correlationId)
{
if (reader == null)
{
throw new ArgumentNullException(nameof(reader));
}
if (header == null)
{
throw new ArgumentNullException(nameof(header));
}
if (writer == null)
{
throw new ArgumentNullException(nameof(writer));
}
writer.WriteStartArray();
while (await reader.ReadAsync().ConfigureAwait(false))
{
if (reader.Is("DK_RequestChangeOfSupplier", B2BNamespace, XmlNodeType.EndElement))
{
break;
}
else if (reader.Is("PayloadMPEvent", B2BNamespace))
{
await ProcessPayloadMpEventAsync(reader, header, writer, correlationId).ConfigureAwait(false);
}
}
writer.WriteEndArray();
}
public async Task Parser_should_fill_header()
{
await using var fs = File.OpenRead("Assets/Rsm001CPR.xml");
var sut = new RsmValidationParser();
Context actual = await sut.ParseAsync(fs).ConfigureAwait(false);
Assert.NotNull(actual);
var expected = new RsmHeader
{
Creation = Instant.FromUtc(2020, 02, 20, 10, 56, 46),
Identification = "MsgId-0.58755000-1582196206",
DocumentType = "392",
RecipientIdentification = "5790001330552",
SenderIdentification = "5790002263057",
EnergyBusinessProcess = "E03",
EnergyIndustryClassification = "23",
EnergyBusinessProcessRole = "DDQ",
MessageReference = null,
};
Assert.Equal(expected, actual.RsmHeader);
}
private static async ValueTask ProcessPayloadEnergyTimeSeriesAsync(
XmlReader reader,
RsmHeader header,
Utf8JsonWriter writer,
string correlationId)
{
var fragments = new RSM012Fragments();
do
{
if (reader.NodeType != XmlNodeType.Element && reader.NodeType != XmlNodeType.EndElement)
{
continue;
}
if (reader.Is("PayloadEnergyTimeSeries", B2BNamespace))
{
writer.WriteStartObject();
writer.WriteString("CorrelationId", correlationId);
}
else if (reader.Is("Identification", B2BNamespace))
{
fragments.PayloadEnergyTimeSeriesIdentification = await reader.ReadElementContentAsStringAsync()
.ConfigureAwait(false);
}
else if (reader.Is("Function", B2BNamespace))
{
fragments.Function = await reader.ReadElementContentAsStringAsync()
.ConfigureAwait(false);
}
else if (reader.Is("ObservationTimeSeriesPeriod", B2BNamespace))
{
fragments.ObservationTimeSeriesPeriod = await ProcessObservationTimeSeriesPeriodAsync(reader)
.ConfigureAwait(false);
}
else if (reader.Is("IncludedProductCharacteristic", B2BNamespace))
{
fragments.IncludedProductCharacteristic = await ProcessIncludedProductCharacteristicAsync(reader)
.ConfigureAwait(false);
}
else if (reader.Is("DetailMeasurementMeteringPointCharacteristic", B2BNamespace))
{
fragments.DetailMeasurementMeteringPointCharacteristic = await ProcessDetailMeasurementMeteringPointCharacteristicAsync(reader)
.ConfigureAwait(false);
}
else if (reader.Is("MeteringPointDomainLocation", B2BNamespace))
{
fragments.MeteringPointDomainLocationIdentification = await GetChildIdentificationAsync(reader)
.ConfigureAwait(false);
/* 2020-12-22 - XMDJE - At this point we have all the necessary information to write everything to the stream up until points.
* Points are specifically written immediately to the stream in the effort to save memory.
* This means we will write everything up to that segment to the stream to be ready */
WriteTimeSeriesUpUntilIndividualPoints(writer, fragments, header);
}
else if (reader.Is("IntervalEnergyObservation", B2BNamespace))
{
// Notice: We write each point to the stream immediately, unlike the rest of the parsing
var point = await ProcessPointsAsync(reader)
.ConfigureAwait(false);
WriteTimeSeriesPoint(writer, point, fragments);
}
else if (reader.Is("PayloadEnergyTimeSeries", B2BNamespace, XmlNodeType.EndElement))
{
// We have now parsed all the points and can write the remaining parts of the document
WriteTimeSeriesFromAfterPoints(writer, fragments);
writer.WriteEndObject();
}
}while (await reader.ReadAsync().ConfigureAwait(false));
}
private static void WriteIdentifications(Utf8JsonWriter writer, RsmHeader header, RSM012Fragments fragments)
{
writer.WriteString("mRID", fragments.PayloadEnergyTimeSeriesIdentification);
writer.WriteString("MessageReference", header.MessageReference);
}
private static void WriteTimeSeriesUpUntilIndividualPoints(Utf8JsonWriter writer, RSM012Fragments fragments, RsmHeader header)
{
WriteIdentifications(writer, header, fragments);
WriteMarketDocument(writer, header);
WriteActivityRecordStatus(writer, fragments);
WriteCharacteristics(writer, fragments);
WriteMarketEvaluationPointMRID(writer, fragments);
WritePeriodUpToPoints(writer, fragments);
}
private static async ValueTask ProcessConsumerPartyAsync(
XmlReader reader,
RsmHeader header,
Utf8JsonWriter writer)
{
if (reader == null)
{
throw new ArgumentNullException(nameof(reader));
}
if (header == null)
{
throw new ArgumentNullException(nameof(header));
}
if (writer == null)
{
throw new ArgumentNullException(nameof(writer));
}
string?cpr = null;
string?cvr = null;
string?qualifier = null;
string?name = null;
while (await reader.ReadAsync().ConfigureAwait(false))
{
if (reader.Is("ConsumerConsumerParty", B2BNamespace, XmlNodeType.EndElement))
{
break;
}
if (reader.Is("CPR", B2BNamespace) && cpr == null)
{
cpr = await reader.ReadElementContentAsStringAsync().ConfigureAwait(false);
qualifier = "ARR";
}
else if (reader.Is("CVR", B2BNamespace) && cvr == null)
{
cvr = await reader.ReadElementContentAsStringAsync().ConfigureAwait(false);
qualifier = "VA";
}
else if (reader.Is("Name", B2BNamespace))
{
name = await reader.ReadElementContentAsStringAsync().ConfigureAwait(false);
}
}
if ((cvr != null && cpr != null) || (cvr == null && cpr == null))
{
throw new Exception("Inconsistency in CVR or CPR");
}
writer.WriteStartObject("Consumer");
writer.WriteString("mRID", cvr ?? cpr);
writer.WriteString("qualifier", qualifier);
if (name != null)
{
writer.WriteString("name", name);
}
writer.WriteEndObject();
}
private static async ValueTask ProcessPayloadMpEventAsync(
XmlReader reader,
RsmHeader header,
Utf8JsonWriter writer,
string correlationId)
{
do
{
if (reader.NodeType != XmlNodeType.Element && reader.NodeType != XmlNodeType.EndElement)
{
continue;
}
if (reader.Is("PayloadMPEvent", B2BNamespace))
{
writer.WriteStartObject();
writer.WriteString("CorrelationId", correlationId);
}
else if (reader.Is("PayloadMPEvent", B2BNamespace, XmlNodeType.EndElement))
{
writer.WriteEndObject();
}
else if (reader.Is("Identification", B2BNamespace))
{
writer.WriteStartObject("Transaction");
writer.WriteString("mRID", await reader.ReadElementContentAsStringAsync().ConfigureAwait(false));
writer.WriteEndObject();
}
else if (reader.Is("StartOfOccurrence", B2BNamespace))
{
var instantResult = InstantPattern.ExtendedIso.Parse(
await reader.ReadElementContentAsStringAsync().ConfigureAwait(false));
if (instantResult.Success)
{
writer.WriteString("StartDate", instantResult.Value.ToString());
}
}
else if (reader.Is("MeteringPointDomainLocation", B2BNamespace))
{
writer.WriteStartObject("MarketEvaluationPoint");
writer.WriteString("mRID", await GetChildIdentificationAsync(reader).ConfigureAwait(false));
writer.WriteEndObject();
}
else if (reader.Is("BalanceSupplierEnergyParty", B2BNamespace))
{
writer.WriteStartObject("EnergySupplier");
writer.WriteString("mRID", await GetChildIdentificationAsync(reader).ConfigureAwait(false));
writer.WriteEndObject();
}
else if (reader.Is("BalanceResponsiblePartyEnergyParty", B2BNamespace))
{
writer.WriteStartObject("BalanceResponsibleParty");
writer.WriteString("mRID", await GetChildIdentificationAsync(reader).ConfigureAwait(false));
writer.WriteEndObject();
}
else if (reader.Is("ConsumerConsumerParty", B2BNamespace))
{
await ProcessConsumerPartyAsync(reader, header, writer).ConfigureAwait(false);
}
}while (await reader.ReadAsync().ConfigureAwait(false));
}
protected abstract ValueTask ConvertPayloadAsync(XmlReader reader, RsmHeader header, Utf8JsonWriter writer, string correlationId);
private static async ValueTask ReadProcessEnergyContextAsync(XmlReader reader, RsmHeader rsmHeader, string ns)
{
while (await reader.ReadAsync().ConfigureAwait(false))
{
if (reader.Is("ProcessEnergyContext", ns, XmlNodeType.EndElement))
{
return;
}
if (reader.Is("EnergyBusinessProcess", ns))
{
rsmHeader.EnergyBusinessProcess = await reader.ReadElementContentAsStringAsync().ConfigureAwait(false);
}
else if (reader.Is("EnergyBusinessProcessRole", ns))
{
rsmHeader.EnergyBusinessProcessRole = await reader.ReadElementContentAsStringAsync().ConfigureAwait(false);
}
else if (reader.Is("EnergyIndustryClassification", ns))
{
rsmHeader.EnergyIndustryClassification = await reader.ReadElementContentAsStringAsync().ConfigureAwait(false);
}
}
}
private static async ValueTask ReadHeaderEnergyDocumentAsync(XmlReader reader, RsmHeader rsmHeader, string ns)
{
while (await reader.ReadAsync().ConfigureAwait(false))
{
if (reader.LocalName == "HeaderEnergyDocument" && reader.NodeType == XmlNodeType.EndElement)
{
return;
}
else if (reader.Is("Identification", ns))
{
var content = await reader.ReadElementContentAsStringAsync().ConfigureAwait(false);
rsmHeader.Identification = content;
}
else if (reader.Is("DocumentType", ns))
{
rsmHeader.DocumentType = await reader.ReadElementContentAsStringAsync().ConfigureAwait(false);
}
else if (reader.Is("Creation", ns))
{
rsmHeader.Creation = Instant.FromDateTimeUtc(reader.ReadElementContentAsDateTime());
}
else if (reader.Is("SenderEnergyParty", ns))
{
rsmHeader.SenderIdentification = await ReadIdentificationAsync(reader, ns).ConfigureAwait(false);
}
else if (reader.Is("RecipientEnergyParty", ns))
{
rsmHeader.RecipientIdentification = await ReadIdentificationAsync(reader, ns).ConfigureAwait(false);
}
}
}
