public void TPH_BaseType()
{
using (var ctx = GetContext())
{
var mp = new MeteringPoint {
CreatedAt = DateTime.Now
};
ctx.Set <MeteringPoint>().Add(mp);
ctx.SaveChanges();
var contracts = new List <ContractBase>();
var c1 = new ContractFixed
{
AvpContractNr = "c_FIX",
PackageFixedId = 1,
PricesJson = "{}",
MeteringPointId = mp.Id,
ClientId = 5,
};
contracts.Add(c1);
var c2 = new ContractStock {
AvpContractNr = "c_STX", Margin = 0.001m, PackageStockId = 2, MeteringPointId = mp.Id
};
contracts.Add(c2);
var k1 = new ContractKomb1 {
AvpContractNr = "c_K1", PackageKomb1Id = 3, MeteringPointId = mp.Id
};
contracts.Add(k1);
var k2 = new ContractKomb2 {
AvpContractNr = "c_K2", PackageKomb2Id = 3, Part1Margin = 0.1m, MeteringPointId = mp.Id
};
contracts.Add(k2);
ctx.BulkInsert(contracts);
var c1db = ctx.FixedContracts.OrderByDescending(x => x.Id).First();
Assert.AreEqual(c1.AvpContractNr, c1db.AvpContractNr);
Assert.AreEqual(c1.PackageFixedId, c1db.PackageFixedId);
Assert.AreEqual(c1.PricesJson, c1db.PricesJson);
Assert.AreEqual(c1.MeteringPointId, c1db.MeteringPointId);
Assert.AreEqual(c1.ClientId, c1db.ClientId);
Assert.AreEqual(c1.ContractNr, c1db.ContractNr);
Assert.AreEqual(c1.ContractSignedAt, c1db.ContractSignedAt);
var k1db = ctx.K1Contracts.OrderByDescending(x => x.Id).First();
Assert.AreEqual(k1.AvpContractNr, k1db.AvpContractNr);
Assert.AreEqual(k1.PackageKomb1Id, k1db.PackageKomb1Id);
Assert.AreEqual(k1.AvpContractNr, k1db.AvpContractNr);
Assert.AreEqual(k1.MeteringPointId, k1db.MeteringPointId);
Assert.AreEqual(k1.ClientId, k1db.ClientId);
Assert.AreEqual(k1.ContractNr, k1db.ContractNr);
Assert.AreEqual(k1.ContractSignedAt, k1db.ContractSignedAt);
}
}
public void TPH_SubType_NotFirst()
{
using (var ctx = GetContext())
{
var mp = new MeteringPoint {
CreatedAt = DateTime.Now
};
ctx.Set <MeteringPoint>().Add(mp);
ctx.SaveChanges();
var contracts = new List <ContractKomb1>();
var k1 = new ContractKomb1 {
AvpContractNr = "c_K1", PackageKomb1Id = 3, MeteringPointId = mp.Id
};
contracts.Add(k1);
ctx.BulkInsert(contracts);
var k1db = ctx.K1Contracts.OrderByDescending(x => x.Id).First();
Assert.AreEqual(k1.AvpContractNr, k1db.AvpContractNr);
Assert.AreEqual(k1.PackageKomb1Id, k1db.PackageKomb1Id);
Assert.AreEqual(k1.AvpContractNr, k1db.AvpContractNr);
Assert.AreEqual(k1.MeteringPointId, k1db.MeteringPointId);
Assert.AreEqual(k1.ClientId, k1db.ClientId);
Assert.AreEqual(k1.ContractNr, k1db.ContractNr);
Assert.AreEqual(k1.ContractSignedAt, k1db.ContractSignedAt);
}
}
private async Task Seed(string energySupplierGlnNumber, string meteringPointGsrnNumber)
{
//TODO: Need to separate customers from energy suppliers - This does not make any sense at all
var customerId = "Unknown";
var customer = new EnergySupplier(new GlnNumber(customerId));
_energySupplierRepository.Add(customer);
var energySupplierGln = new GlnNumber(energySupplierGlnNumber);
var energySupplier = new EnergySupplier(energySupplierGln);
_energySupplierRepository.Add(energySupplier);
await _unitOfWorkCallback.CommitAsync().ConfigureAwait(false);
var meteringPoint =
MeteringPoint.CreateProduction(
GsrnNumber.Create(meteringPointGsrnNumber), true);
var systemTimeProvider = _serviceProvider.GetRequiredService <ISystemDateTimeProvider>();
meteringPoint.RegisterMoveIn(new MarketParticipantMrid(customerId), new MarketParticipantMrid(energySupplierGlnNumber), systemTimeProvider.Now().Minus(Duration.FromDays(365)));
meteringPoint.ActivateMoveIn(new MarketParticipantMrid(customerId), new MarketParticipantMrid(energySupplierGlnNumber));
_meteringPointRepository.Add(meteringPoint);
await _unitOfWorkCallback.CommitAsync().ConfigureAwait(false);
}
public async Task <MeteringPoint> GetByGsrnNumberAsync(GsrnNumber gsrnNumber)
{
if (gsrnNumber is null)
{
throw new ArgumentNullException(nameof(gsrnNumber));
}
var meteringPointQuery =
$"SELECT * FROM [dbo].[MarketEvaluationPoints]" +
"WHERE GsrnNumber = @GsrnNumber";
var meteringPoint =
await Connection.QueryFirstOrDefaultAsync <MarketEvaluationPointDataModel>(
meteringPointQuery,
new
{
GsrnNumber = gsrnNumber.Value,
}).ConfigureAwait(false);
if (meteringPoint is null)
{
return(null !);
}
var relationships = await GetRelationshipsDataModelAsync(meteringPoint.Id).ConfigureAwait(false);
return(MeteringPoint.CreateFrom(CreateMarketEvaluationPointSnapshot(meteringPoint, relationships)));
}
private static MarketEvaluationPointDataModel CreateDataModelFrom(MeteringPoint aggregate)
{
var snapshot = aggregate.GetSnapshot();
var relationships = snapshot.Relationships
.Select(r => new RelationshipDataModel(r.Id, snapshot.Id, r.MarketParticipantMrid, r.Type, r.EffectuationDate, r.State))
.ToList();
return(new MarketEvaluationPointDataModel(snapshot.Id, snapshot.GsrnNumber, snapshot.MeteringPointType, relationships, snapshot.IsProductionObligated, snapshot.PhysicalState, snapshot.Version));
}
public void Save(MeteringPoint meteringPoint)
{
if (meteringPoint is null)
{
throw new ArgumentNullException(nameof(meteringPoint));
}
var dataModel = CreateDataModelFrom(meteringPoint);
_unitOfWorkCallback.RegisterAmended(dataModel, this);
}
public void BulkInsertWithStreaming()
{
using (var ctx = GetContext())
{
var meteringPoint = new MeteringPoint {
CreatedAt = DateTime.Now
};
ctx.Set <MeteringPoint>().Add(meteringPoint);
ctx.SaveChanges();
var foos = new[] { new ContractStock {
Margin = 0.1m, MeteringPointId = meteringPoint.Id
} };
var options = new BulkInsertOptions
{
EnableStreaming = true,
};
ctx.BulkInsert(foos, options);
}
}
private RequestChangeOfSupplierResult CheckBusinessRules(RequestChangeOfSupplier command, MeteringPoint meteringPoint)
{
var validationResult =
meteringPoint.CanChangeSupplier(new MarketParticipantMrid(command.EnergySupplier.MRID !), command.StartDate, _systemTimeProvider);
return(validationResult.Success
? RequestChangeOfSupplierResult.Reject(validationResult.Errors)
: RequestChangeOfSupplierResult.Success());
}
private List <MeteringPoint> GetMeteringPointsFromEntityCollection(OrganizationServiceContext serviceContext, IQueryable <Entity> zahplunkts)
{
List <MeteringPoint> meteringPoints = new List <MeteringPoint>();
foreach (Entity zahplunkt in zahplunkts)
{
MeteringPoint meteringPoint = new MeteringPoint();
if (zahplunkt.Contains(MetadataDZählpunkt.METERING_POINT_ID))
{
meteringPoint.Id = zahplunkt.GetAttributeValue <Guid>(MetadataDZählpunkt.METERING_POINT_ID);
}
if (zahplunkt.Contains(MetadataDZählpunkt.NAME))
{
meteringPoint.Name = zahplunkt.GetAttributeValue <string>(MetadataDZählpunkt.NAME);
}
if (zahplunkt.Contains(MetadataDZählpunkt.ACCOUNT))
{
EntityReference linkedAccount = zahplunkt.GetAttributeValue <EntityReference>(MetadataDZählpunkt.ACCOUNT);
meteringPoint.CrmAccountId = linkedAccount.Id;
meteringPoint.CrmAccountName = linkedAccount.Name;
//GetBeitreibersByAccountId(linkedAccount.Id);
}
if (zahplunkt.Contains(MetadataDZählpunkt.ZAHLPUNKTBEZEICHNER))
{
meteringPoint.Zählpunktbezeichner = zahplunkt.GetAttributeValue <string>(MetadataDZählpunkt.ZAHLPUNKTBEZEICHNER);
}
if (zahplunkt.Contains(MetadataDZählpunkt.KURZEEZEICHNUNG))
{
meteringPoint.Kurzbezeichnung = zahplunkt.GetAttributeValue <string>(MetadataDZählpunkt.KURZEEZEICHNUNG);
}
if (zahplunkt.Contains(MetadataDZählpunkt.ANLAGENTYP))
{
meteringPoint.Anlagentyp = zahplunkt.GetAttributeValue <string>(MetadataDZählpunkt.ANLAGENTYP);
}
if (zahplunkt.Contains(MetadataDZählpunkt.PLZ))
{
meteringPoint.PLZ = zahplunkt.GetAttributeValue <string>(MetadataDZählpunkt.PLZ);
}
if (zahplunkt.Contains(MetadataDZählpunkt.STRASSE))
{
meteringPoint.Strasse = zahplunkt.GetAttributeValue <string>(MetadataDZählpunkt.STRASSE);
}
if (zahplunkt.Contains(MetadataDZählpunkt.ORT))
{
meteringPoint.Ort = zahplunkt.GetAttributeValue <string>(MetadataDZählpunkt.ORT);
}
if (zahplunkt.Contains(MetadataDZählpunkt.DATENVERSANDAKTIV))
{
meteringPoint.DatenversandAktiv = zahplunkt.GetAttributeValue <bool>(MetadataDZählpunkt.DATENVERSANDAKTIV) ? "Yes" : "No";
}
if (zahplunkt.Contains(MetadataDZählpunkt.ZAHLVERFAHREN))
{
string value = String.Empty;
int code = -1;
switch (zahplunkt.GetAttributeValue <OptionSetValue>(MetadataDZählpunkt.ZAHLVERFAHREN).Value)
{
case (int)MetadataDZählpunkt.OpSetZählverfahren.RLM:
code = (int)MetadataDZählpunkt.OpSetZählverfahren.RLM;
value = MetadataDZählpunkt.OpSetZählverfahren.RLM.ToString();
break;
case (int)MetadataDZählpunkt.OpSetZählverfahren.SLP:
code = (int)MetadataDZählpunkt.OpSetZählverfahren.SLP;
value = MetadataDZählpunkt.OpSetZählverfahren.SLP.ToString();
break;
}
meteringPoint.ZählverfahrenCode = code;
meteringPoint.ZählverfahrenValue = value;
}
if (zahplunkt.Contains(MetadataDZählpunkt.UMESSUNG))
{
int code; string value;
this.SetSetSpannungsebene(zahplunkt.GetAttributeValue <OptionSetValue>(MetadataDZählpunkt.UMESSUNG).Value,
out code, out value);
meteringPoint.UMessungCode = code;
meteringPoint.UMessungValue = value;
}
if (zahplunkt.Contains(MetadataDZählpunkt.UENTNAHME))
{
int code; string value;
this.SetSetSpannungsebene(zahplunkt.GetAttributeValue <OptionSetValue>(MetadataDZählpunkt.UENTNAHME).Value,
out code, out value);
meteringPoint.UEntnahmeCode = code;
meteringPoint.UEntnahmeValue = value;
}
if (zahplunkt.Contains(MetadataDZählpunkt.KUNDENRUCKMELDUNG))
{
meteringPoint.Kundenrückmeldung = zahplunkt.GetAttributeValue <string>(MetadataDZählpunkt.KUNDENRUCKMELDUNG);
}
if (zahplunkt.Contains(MetadataDZählpunkt.VNB))
{
EntityReference linkedVnb = zahplunkt.GetAttributeValue <EntityReference>(MetadataDZählpunkt.VNB);
meteringPoint.VNBId = linkedVnb.Id;
meteringPoint.VNBName = linkedVnb.Name;
}
if (zahplunkt.Contains(MetadataDZählpunkt.CODE))
{
meteringPoint.Code = zahplunkt.GetAttributeValue <string>(MetadataDZählpunkt.CODE);
}
#region "Threshold Values"
//Get the threshold for this metering point
IQueryable <Entity> grenzwerts = serviceContext.CreateQuery(EntityNames.Grenzwert).Where(g => g.GetAttributeValue <EntityReference>(MetadataGrenzwert.GrenzwerteZPID).Id == zahplunkt.Id);
List <MeteringPointThreshold> meteringPointThresholds = new List <MeteringPointThreshold>();
meteringPoint.MeteringCodeThresholds = new List <MeteringPointThreshold>();
if (grenzwerts != null)
{
Entity grenzwert = grenzwerts.ToList().FirstOrDefault();
if (grenzwert != null)
{
#region "System Threshold Values"
MeteringPointThreshold meteringPointThreshlodSystem = new MeteringPointThreshold {
Type = MeteringPointThresholdType.System
};
if (grenzwert.Contains(MetadataGrenzwert.Grenze))
{
meteringPointThreshlodSystem.GrenzwertBezeichner = String.Format("{0:F2}", grenzwert.GetAttributeValue <decimal>(MetadataGrenzwert.Grenze));
}
if (grenzwert.Contains(MetadataGrenzwert.GrenzwerteId))
{
meteringPointThreshlodSystem.Id = grenzwert.GetAttributeValue <Guid>(MetadataGrenzwert.GrenzwerteId);
}
if (grenzwert.Contains(MetadataGrenzwert.GültigAb))
{
meteringPointThreshlodSystem.GultingAb = grenzwert.GetAttributeValue <DateTime>(MetadataGrenzwert.GültigAb);
}
if (grenzwert.Contains(MetadataGrenzwert.GrenzwertMaxSystem))
{
meteringPointThreshlodSystem.MaximaGlobal = (grenzwert.GetAttributeValue <decimal>(MetadataGrenzwert.GrenzwertMaxSystem)).ToString();
}
if (grenzwert.Contains(MetadataGrenzwert.GrenzwertMinSystem))
{
meteringPointThreshlodSystem.MinimaGlobal = (grenzwert.GetAttributeValue <decimal>(MetadataGrenzwert.GrenzwertMinSystem)).ToString();
}
if (grenzwert.Contains(MetadataGrenzwert.GrenzwertSommerMaxSystem))
{
meteringPointThreshlodSystem.MaximaSommer = (grenzwert.GetAttributeValue <decimal>(MetadataGrenzwert.GrenzwertSommerMaxSystem)).ToString();
}
if (grenzwert.Contains(MetadataGrenzwert.GrenzwertSommerMinSystem))
{
meteringPointThreshlodSystem.MinimaSommer = (grenzwert.GetAttributeValue <decimal>(MetadataGrenzwert.GrenzwertSommerMinSystem)).ToString();
}
if (grenzwert.Contains(MetadataGrenzwert.GrenzwertWinterMaxSystem))
{
meteringPointThreshlodSystem.MaximaWinter = (grenzwert.GetAttributeValue <decimal>(MetadataGrenzwert.GrenzwertWinterMaxSystem)).ToString();
}
if (grenzwert.Contains(MetadataGrenzwert.GrenzwertWinterMinSystem))
{
meteringPointThreshlodSystem.MinimaWinter = (grenzwert.GetAttributeValue <decimal>(MetadataGrenzwert.GrenzwertWinterMinSystem)).ToString();
}
meteringPointThresholds.Add(meteringPointThreshlodSystem);
#endregion "System Threshold Values"
#region "User Threshold Values"
MeteringPointThreshold meteringPointThreshlodUser = new MeteringPointThreshold {
Type = MeteringPointThresholdType.User
};
if (grenzwert.Contains(MetadataGrenzwert.GrenzwerteId))
{
meteringPointThreshlodUser.Id = grenzwert.GetAttributeValue <Guid>(MetadataGrenzwert.GrenzwerteId);
}
if (grenzwert.Contains(MetadataGrenzwert.Grenze))
{
meteringPointThreshlodUser.GrenzwertBezeichner = String.Format("{0:F2}", grenzwert.GetAttributeValue <decimal>(MetadataGrenzwert.Grenze));
}
if (grenzwert.Contains(MetadataGrenzwert.GültigAb))
{
meteringPointThreshlodUser.GultingAb = grenzwert.GetAttributeValue <DateTime>(MetadataGrenzwert.GültigAb);
}
if (grenzwert.Contains(MetadataGrenzwert.GrenzwertMaxUser))
{
meteringPointThreshlodUser.MaximaGlobal = (grenzwert.GetAttributeValue <decimal>(MetadataGrenzwert.GrenzwertMaxUser)).ToString();
}
if (grenzwert.Contains(MetadataGrenzwert.GrenzwertMinUser))
{
meteringPointThreshlodUser.MinimaGlobal = (grenzwert.GetAttributeValue <decimal>(MetadataGrenzwert.GrenzwertMinUser)).ToString();
}
if (grenzwert.Contains(MetadataGrenzwert.GrenzwertSommerMaxUser))
{
meteringPointThreshlodUser.MaximaSommer = (grenzwert.GetAttributeValue <decimal>(MetadataGrenzwert.GrenzwertSommerMaxUser)).ToString();
}
if (grenzwert.Contains(MetadataGrenzwert.GrenzwertSommerMinUser))
{
meteringPointThreshlodUser.MinimaSommer = (grenzwert.GetAttributeValue <decimal>(MetadataGrenzwert.GrenzwertSommerMinUser)).ToString();
}
if (grenzwert.Contains(MetadataGrenzwert.GrenzwertWinterMaxUser))
{
meteringPointThreshlodUser.MaximaWinter = (grenzwert.GetAttributeValue <decimal>(MetadataGrenzwert.GrenzwertWinterMaxUser)).ToString();
}
if (grenzwert.Contains(MetadataGrenzwert.GrenzwertWinterMinUser))
{
meteringPointThreshlodUser.MinimaWinter = (grenzwert.GetAttributeValue <decimal>(MetadataGrenzwert.GrenzwertWinterMinUser)).ToString();
}
meteringPointThresholds.Add(meteringPointThreshlodUser);
#endregion "User Threshold Values"
meteringPoint.MeteringCodeThresholds = meteringPointThresholds;
}
#endregion "Threshold Values"
}
meteringPoints.Add(meteringPoint);
}
return(meteringPoints);
}
public ActionResult Edit(Guid id)
{
MeteringPoint meteringCode = this._meteringCodeService.GetMeteringPointsById(id);
return(View(meteringCode));
}
private BusinessRulesValidationResult CanChangeSupplier(MeteringPoint meteringPoint, Instant effectuationDate)
{
return(meteringPoint.CanChangeSupplier(CreateEnergySupplierId(), effectuationDate, _systemDateTimeProvider));
}
private BusinessRulesValidationResult CanChangeSupplier(MeteringPoint meteringPoint)
{
return(meteringPoint.CanChangeSupplier(CreateEnergySupplierId(), _systemDateTimeProvider.Now(), _systemDateTimeProvider));
}
