private static UsagePointLieferant LoadTafFile(string filename)
{
try
{
var xml = XDocument.Load(filename);
Ar2418Validation.ValidateSchema(xml);
var model = XmlModelParser.ParseSupplierModel(xml.Root?.Descendants());
ModelValidation.ValidateSupplierModel(model);
return(model);
}
catch (AggregateException ex)
{
foreach (var err in ex.InnerExceptions)
{
Console.WriteLine(err.Message);
}
return(null);
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
return(null);
}
}
private static UsagePointAdapterTRuDI LoadDataFile(string filename)
{
try
{
var xml = XDocument.Load(filename);
Ar2418Validation.ValidateSchema(xml);
var model = XmlModelParser.ParseHanAdapterModel(xml.Root?.Descendants());
ModelValidation.ValidateHanAdapterModel(model);
ContextValidation.ValidateContext(model, null);
return(model);
}
catch (AggregateException ex)
{
foreach (var err in ex.InnerExceptions)
{
Console.WriteLine(err.Message);
}
return(null);
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
return(null);
}
}
private static UsagePointAdapterTRuDI RunValidations(XDocument xml, AdapterContext ctx)
{
Ar2418Validation.ValidateSchema(xml);
var model = XmlModelParser.ParseHanAdapterModel(xml.Root?.Descendants());
ModelValidation.ValidateHanAdapterModel(model);
ContextValidation.ValidateContext(model, ctx);
return(model);
}
private void UpdateRegisterValuesFromXml(XDocument raw, AdapterContext ctx)
{
Log.Information("Adding the current register value to the XML result file.");
this.LastErrorMessages.Clear();
UsagePointAdapterTRuDI model;
try
{
Log.Information("Validating XSD schema");
Ar2418Validation.ValidateSchema(raw);
Log.Information("Parsing model");
model = XmlModelParser.ParseHanAdapterModel(raw?.Root?.Descendants());
Log.Information("Validating model");
ModelValidation.ValidateHanAdapterModel(model);
}
catch (AggregateException ex)
{
foreach (var err in ex.InnerExceptions)
{
Log.Error(err, err.Message);
this.LastErrorMessages.Add(err.Message);
}
throw;
}
catch (Exception ex)
{
Log.Error(ex, "Loading XML data with current values failed: {0}", ex.Message);
this.LastErrorMessages.Add(ex.Message);
throw;
}
model.MeterReadings.Sort((a, b) => string.Compare(a.ReadingType.ObisCode, b.ReadingType.ObisCode, StringComparison.InvariantCultureIgnoreCase));
this.CurrentDataResult.MeterReadings = model.MeterReadings;
this.CurrentDataResult.Begin = model.MeterReadings.FirstOrDefault()?.IntervalBlocks?.FirstOrDefault()?.Interval?.Start;
var usagePoint = this.CurrentDataResult.Raw.Root.Elements().FirstOrDefault();
var readings = raw?.Root?.Elements().FirstOrDefault().Elements().Where(e => e.Name.LocalName == "MeterReading");
usagePoint.Add(readings);
if (this.CurrentDataResult.Begin != null)
{
var duration = model.MeterReadings.FirstOrDefault()?.IntervalBlocks?.FirstOrDefault()?.Interval?.Duration;
if (duration != null)
{
this.CurrentDataResult.End = this.CurrentDataResult.Begin + TimeSpan.FromSeconds(duration.Value);
}
}
}
public override int Run()
{
var connectResult = this.Connect();
if (connectResult.error != null)
{
Console.WriteLine("Connect failed: {0}", connectResult.error);
return(2);
}
var hanAdapter = this.CommonCommunicationConfiguration.HanAdapter;
var contractsResult = hanAdapter.LoadAvailableContracts(
this.CommonCommunicationConfiguration.CreateCancellationToken(),
this.ProgressCallback).Result;
if (contractsResult.error != null)
{
Console.WriteLine("LoadAvailableContracts failed: {0}", contractsResult.error);
return(2);
}
var contract = contractsResult.contracts.FirstOrDefault(
c =>
{
if (!string.IsNullOrWhiteSpace(this.currentRegistersConfiguration.UsagePointId))
{
if (this.currentRegistersConfiguration.UsagePointId != c.MeteringPointId)
{
return(false);
}
}
if (c.TafId == TafId.Taf6)
{
return(false);
}
return(this.currentRegistersConfiguration.TariffName == c.TafName);
});
if (contract == null)
{
Console.WriteLine("Es wurde kein passender TAF gefunden.");
return(2);
}
var currentRegisterResult = hanAdapter.GetCurrentRegisterValues(
contract,
this.CommonCommunicationConfiguration.CreateCancellationToken(),
this.ProgressCallback).Result;
if (currentRegisterResult.error != null)
{
Console.WriteLine("GetCurrentRegisterValues failed: {0}", currentRegisterResult.error);
return(2);
}
try
{
if (this.currentRegistersConfiguration.SkipValidation)
{
Ar2418Validation.ValidateSchema(currentRegisterResult.trudiXml);
var model = XmlModelParser.ParseHanAdapterModel(currentRegisterResult.trudiXml.Root?.Descendants());
ModelValidation.ValidateHanAdapterModel(model);
ContextValidation.ValidateContext(model, null);
}
}
catch (AggregateException ex)
{
foreach (var err in ex.InnerExceptions)
{
Console.WriteLine(err.Message);
}
return(2);
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
return(2);
}
if (string.IsNullOrWhiteSpace(this.CommonOptions.OutputFile))
{
return(0);
}
currentRegisterResult.trudiXml.Save(this.CommonOptions.OutputFile);
return(0);
}
private void LoadDataFromXml(XDocument raw, AdapterContext ctx)
{
Log.Information("Loading XML file");
this.LastErrorMessages.Clear();
try
{
this.CurrentDataResult = new XmlDataResult {
Raw = raw
};
Log.Information("Validating XSD schema");
Ar2418Validation.ValidateSchema(raw);
Log.Information("Parsing model");
this.CurrentDataResult.Model = XmlModelParser.ParseHanAdapterModel(this.CurrentDataResult?.Raw?.Root?.Descendants());
Log.Information("Validating model");
ModelValidation.ValidateHanAdapterModel(this.CurrentDataResult.Model);
Log.Information("Validating model using the adapter context");
ContextValidation.ValidateContext(this.CurrentDataResult.Model, ctx);
if (this.CurrentSupplierFile?.Model != null)
{
Log.Information("Validating model using supplier file model");
ContextValidation.ValidateContext(this.CurrentDataResult.Model, this.CurrentSupplierFile.Model, ctx);
Log.Information("Loading TAF adapter: {0}", this.CurrentSupplierFile.Model.AnalysisProfile.TariffUseCase);
var tafAdapter = TafAdapterRepository.LoadAdapter(this.CurrentSupplierFile.Model.AnalysisProfile.TariffUseCase);
this.CurrentSupplierFile.TafData = tafAdapter.Calculate(this.CurrentDataResult.Model, this.CurrentSupplierFile.Model);
}
}
catch (UnknownTafAdapterException ex)
{
Log.Error(ex, "Unknown TAF adapter: {0}", ex.TafId);
this.LastErrorMessages.Add($"Die Berechnung des Tarifanwendungsfall {ex.TafId} wird nicht unterstützt.");
throw;
}
catch (AggregateException ex)
{
foreach (var err in ex.InnerExceptions)
{
Log.Error(err, err.Message);
this.LastErrorMessages.Add(err.Message);
}
throw;
}
catch (Exception ex)
{
Log.Error(ex, "Loading XML data failed: {0}", ex.Message);
this.LastErrorMessages.Add(ex.Message);
throw;
}
var originalValueLists =
this.CurrentDataResult.Model.MeterReadings.Where(mr => mr.IsOriginalValueList()).Select(mr => new OriginalValueList(mr, this.CurrentDataResult.Model.ServiceCategory.Kind ?? Kind.Electricity)).ToList();
var meterReadings = this.CurrentDataResult.Model.MeterReadings.Where(mr => !mr.IsOriginalValueList()).ToList();
meterReadings.Sort((a, b) => string.Compare(a.ReadingType.ObisCode, b.ReadingType.ObisCode, StringComparison.InvariantCultureIgnoreCase));
var ovlRegisters = originalValueLists.Where(ovl => ovl.MeterReading?.IntervalBlocks?.FirstOrDefault()?.Interval.Duration == 0).ToList();
meterReadings.AddRange(ovlRegisters.Select(ovl => ovl.MeterReading));
if (ovlRegisters.Count < originalValueLists.Count)
{
ovlRegisters.ForEach(ovl => originalValueLists.Remove(ovl));
}
foreach (var ovl in originalValueLists)
{
Log.Information("Original value list: meter: {0}, OBIS: {1}, {2} values", ovl.Meter, ovl.Obis, ovl.ValueCount);
}
foreach (var mr in meterReadings)
{
Log.Information("Meter reading: {@Meters}, OBIS: {1}", mr.Meters, mr.ReadingType.ObisCode);
}
this.CurrentDataResult.OriginalValueLists = originalValueLists;
this.CurrentDataResult.MeterReadings = meterReadings;
this.CurrentDataResult.Begin = meterReadings.FirstOrDefault()?.IntervalBlocks?.FirstOrDefault()?.Interval?.Start;
if (this.CurrentDataResult.Begin != null)
{
var duration = meterReadings.FirstOrDefault()?.IntervalBlocks?.FirstOrDefault()?.Interval?.Duration;
if (duration != null)
{
this.CurrentDataResult.End = this.CurrentDataResult.Begin + TimeSpan.FromSeconds(duration.Value);
}
}
// If the analysis profile is missing, add it based on the contract info
if (this.CurrentDataResult.Model.AnalysisProfile == null && ctx?.Contract != null)
{
this.AddAnalysisProfile(ctx);
}
}
public override int Run()
{
var connectResult = this.Connect();
if (connectResult.error != null)
{
Console.WriteLine("Connect failed: {0}", connectResult.error);
return(2);
}
var hanAdapter = this.CommonCommunicationConfiguration.HanAdapter;
var contractsResult = hanAdapter.LoadAvailableContracts(
this.CommonCommunicationConfiguration.CreateCancellationToken(),
this.ProgressCallback).Result;
if (contractsResult.error != null)
{
Console.WriteLine("LoadAvailableContracts failed: {0}", contractsResult.error);
return(2);
}
var ctx = new AdapterContext();
ctx.WithLogdata = true;
ctx.Contract = contractsResult.contracts.FirstOrDefault(
c =>
{
if (!string.IsNullOrWhiteSpace(this.loadDataConfiguration.UsagePointId))
{
if (this.loadDataConfiguration.UsagePointId != c.MeteringPointId)
{
return(false);
}
}
if (this.loadDataConfiguration.UseTaf6 && c.TafId != TafId.Taf6)
{
return(false);
}
return(this.loadDataConfiguration.TariffName == c.TafName);
});
if (ctx.Contract == null)
{
Console.WriteLine("Es wurde kein passender TAF gefunden.");
return(2);
}
if (ctx.Contract.TafId != TafId.Taf7)
{
if (ctx.Contract.BillingPeriods == null || ctx.Contract.BillingPeriods.Count
<= this.loadDataConfiguration.BillingPeriodIndex)
{
Console.WriteLine("Angegebene Abrechnungsperiode nicht gefunden.");
return(2);
}
ctx.BillingPeriod = ctx.Contract.BillingPeriods[this.loadDataConfiguration.BillingPeriodIndex];
if (this.loadDataConfiguration.Start != null)
{
ctx.Start = this.loadDataConfiguration.Start.Value;
}
else
{
ctx.Start = ctx.BillingPeriod.Begin;
}
if (this.loadDataConfiguration.End != null)
{
ctx.End = this.loadDataConfiguration.End.Value;
}
else if (ctx.BillingPeriod.End != null)
{
ctx.End = ctx.BillingPeriod.End.Value;
}
else
{
ctx.End = DateTime.Now;
}
}
else
{
if (this.loadDataConfiguration.Start == null || this.loadDataConfiguration.End == null)
{
Console.WriteLine("Bei TAF-7 muss ein Start- und End-Zeitpunkt angegeben werden.");
return(2);
}
ctx.Start = this.loadDataConfiguration.Start.Value;
ctx.End = this.loadDataConfiguration.End.Value;
}
var loadDataResult = hanAdapter.LoadData(
ctx,
this.CommonCommunicationConfiguration.CreateCancellationToken(),
this.ProgressCallback).Result;
if (loadDataResult.error != null)
{
Console.WriteLine("LoadData failed: {0}", loadDataResult.error);
return(2);
}
try
{
if (this.loadDataConfiguration.SkipValidation)
{
Ar2418Validation.ValidateSchema(loadDataResult.trudiXml);
var model = XmlModelParser.ParseHanAdapterModel(loadDataResult.trudiXml.Root?.Descendants());
ModelValidation.ValidateHanAdapterModel(model);
ContextValidation.ValidateContext(model, ctx);
}
}
catch (AggregateException ex)
{
foreach (var err in ex.InnerExceptions)
{
Console.WriteLine(err.Message);
}
return(2);
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
return(2);
}
if (string.IsNullOrWhiteSpace(this.CommonOptions.OutputFile))
{
return(0);
}
loadDataResult.trudiXml.Save(this.CommonOptions.OutputFile);
return(0);
}
