private BenchmarkingData GetBenchmarkingData(ErfassungsPeriod closedPeriod, MandantDetails mandantDetails, decimal wvl, decimal wbw, decimal laengeSum, decimal flaecheSum)
{
var benchmarkingData = new BenchmarkingData
{
CalculatedAt = timeService.Now,
NeedsRecalculation = false,
GesamtlaengeDesStrassennetzesProSiedlungsflaeche = Divide(ToKiloMeter(laengeSum), (mandantDetails.Siedlungsflaeche ?? 0)),
GesamtlaengeDesStrassennetzesProEinwohner = Divide(laengeSum, mandantDetails.Einwohner ?? 0),
FahrbahnflaecheProSiedlungsflaeche = Divide(flaecheSum, (mandantDetails.Siedlungsflaeche ?? 0)),
FahrbahnflaecheProEinwohner = Divide(flaecheSum, mandantDetails.Einwohner ?? 0),
GesamtstrassenflaecheProSiedlungsflaeche = Percent(flaecheSum, ToSquareMeter(mandantDetails.Siedlungsflaeche ?? 0)),
GesamtstrassenflaecheProEinwohner = Divide(flaecheSum, mandantDetails.Einwohner ?? 0),
WiederbeschaffungswertProFahrbahn = Divide(wbw, flaecheSum),
WiederbeschaffungswertProEinwohner = Divide(wbw, mandantDetails.Einwohner ?? 0),
WertverlustProFahrbahn = Divide(wvl, flaecheSum),
WertverlustProEinwohner = Divide(wvl, mandantDetails.Einwohner ?? 0),
Mandant = closedPeriod.Mandant,
ErfassungsPeriod = closedPeriod
};
benchmarkingData.BenchmarkingDataDetails = belastungskategorieService.AlleBelastungskategorie.Select(b =>
new BenchmarkingDataDetail
{
Belastungskategorie = b,
BenchmarkingData = benchmarkingData
}).ToList();
return(benchmarkingData);
}
public List <Mandant> GetAenlicheMandanten(DateTime erfassungsJahr, List <BenchmarkingGruppenTyp> benchmarkingGruppenTypList)
{
var currentMandantDetails = mandantDetailsService.GetMandantDetailsByJahr(erfassungsJahr);
MandantDetails mandantDetails = null;
Mandant mandant = null;
ErfassungsPeriod erfassungsPeriod = null;
var queryOver = transactionScopeProvider.CurrentTransactionScope.Session
.QueryOver(() => mandantDetails)
.JoinAlias(() => mandantDetails.ErfassungsPeriod, () => erfassungsPeriod)
.Where(() => mandantDetails.IsCompleted)
.Where(() => erfassungsPeriod.IsClosed)
.Where(() => erfassungsPeriod.Erfassungsjahr == erfassungsJahr);
queryOver = BuildGroupping(queryOver, benchmarkingGruppenTypList, currentMandantDetails);
var aenlicheMandanten = queryOver.Select(md => md.Mandant).List <Mandant>().ToList();
var kengrosseMandantId = transactionScopeProvider.Queryable <KenngroessenFruehererJahre>()
.Where(k => k.Jahr == erfassungsJahr.Year).Select(k => k.Mandant.Id).ToList();
queryOver = transactionScopeProvider.CurrentTransactionScope.Session
.QueryOver(() => mandantDetails)
.JoinAlias(() => mandantDetails.ErfassungsPeriod, () => erfassungsPeriod)
.JoinAlias(() => mandantDetails.Mandant, () => mandant)
.Where(() => mandantDetails.IsCompleted) // Safety check
.Where(() => !erfassungsPeriod.IsClosed) // You can only get the data from the current erfassungsPeriod is calculation with KenngroessenFruehererJahre
.WhereRestrictionOn(() => mandant.Id).IsIn(kengrosseMandantId);
queryOver = BuildGroupping(queryOver, benchmarkingGruppenTypList, currentMandantDetails);
aenlicheMandanten.AddRange(queryOver.Select(md => md.Mandant).List <Mandant>().ToList());
return(aenlicheMandanten);
}
public void CopyMandantenDetailsData(ErfassungsPeriod closedPeriod)
{
mandantDetailsService.CreateCopy(closedPeriod);
MandantDetails mandantDetails = mandantDetailsService.GetEntitiesBy(closedPeriod).Single();
switch (closedPeriod.NetzErfassungsmodus)
{
case NetzErfassungsmodus.Summarisch:
mandantDetails.NetzLaenge = netzSummarischDetailService.GetEntitiesBy(closedPeriod).Sum(nsd => nsd.Fahrbahnlaenge);
break;
case NetzErfassungsmodus.Tabellarisch:
mandantDetails.NetzLaenge = strassenabschnittService.GetEntitiesBy(closedPeriod).Sum(sa => (decimal?)sa.Laenge) ?? 0;
break;
case NetzErfassungsmodus.Gis:
mandantDetails.NetzLaenge = strassenabschnittGISService.GetEntitiesBy(closedPeriod).Sum(sa => (decimal?)sa.Laenge) ?? 0;
break;
default:
throw new ArgumentOutOfRangeException();
}
//NetzLaenge's unit is km
mandantDetails.NetzLaenge /= 1000m;
transactionScopeProvider.Update(mandantDetails);
}
public BenchmarkingData CalculateRealisierteMassnahmenBenchmarkingData <TEntity, TStrassenEntity>(
ErfassungsPeriod closedPeriod,
BenchmarkingData benchmarkingData,
MandantDetails mandantDetails,
List <TEntity> realisierteMassnahmenEntities, List <TStrassenEntity> strassenEntities)
where TEntity : IBelastungskategorieHolder, IRealisierteFlaecheHolder, IRealisierteMassnahmeKostenHolder
where TStrassenEntity : IBelastungskategorieHolder, IFlaecheFahrbahnUndTrottoirHolder
{
var realisierteMassnahmenDataProBelastungskategorie = belastungskategorieService.AlleBelastungskategorie.ToDictionary(b => b, b => new RealisierteMassnahmeData {
Fleache = 0m, Wbw = 0m, Wertverlust = 0m, Kosten = 0m
});
foreach (var entity in strassenEntities)
{
var bk = realisierteMassnahmenDataProBelastungskategorie.Keys.Single(b => b.Id == entity.Belastungskategorie.Id);
var wieder = GetWieder(bk, closedPeriod);
var wiederbeschaffungswert = GetWiederbeschaffungswert(entity, wieder);
var wertverlustII = wiederbeschaffungswert * wieder.AlterungsbeiwertII / 100;
realisierteMassnahmenDataProBelastungskategorie[bk].Wbw += wiederbeschaffungswert;
realisierteMassnahmenDataProBelastungskategorie[bk].Wertverlust += wertverlustII;
}
foreach (var entity in realisierteMassnahmenEntities)
{
var bk = realisierteMassnahmenDataProBelastungskategorie.Keys.Single(b => b.Id == entity.Belastungskategorie.Id);
realisierteMassnahmenDataProBelastungskategorie[bk].Fleache += entity.RealisierteFlaeche;
realisierteMassnahmenDataProBelastungskategorie[bk].Kosten += entity.Kosten;
realisierteMassnahmenDataProBelastungskategorie[bk].WbwKosten += entity.WbwKosten;
}
decimal sumKosten = realisierteMassnahmenDataProBelastungskategorie.Values.Sum(r => r.Kosten);
decimal sumFleache = realisierteMassnahmenDataProBelastungskategorie.Values.Sum(r => r.Fleache);
decimal sumWbw = realisierteMassnahmenDataProBelastungskategorie.Values.Sum(r => r.Wbw);
decimal sumWertverlust = realisierteMassnahmenDataProBelastungskategorie.Values.Sum(r => r.Wertverlust);
benchmarkingData.RealisierteMassnahmenProFahrbahn = Divide(sumKosten, sumFleache);
benchmarkingData.RealisierteMassnahmenProEinwohner = Divide(sumKosten, mandantDetails.Einwohner ?? 0);
benchmarkingData.RealisierteMassnahmenProWertverlustNetz = Percent(sumKosten, sumWertverlust);
benchmarkingData.RealisierteMassnahmenProWiederbeschaffungswertNetz = Percent(sumKosten, sumWbw);
foreach (var bdd in benchmarkingData.BenchmarkingDataDetails)
{
var r = realisierteMassnahmenDataProBelastungskategorie.Single(f => f.Key.Id == bdd.Belastungskategorie.Id);
bdd.RealisierteMassnahmenProWiederbeschaffungswertNetz = Percent(r.Value.WbwKosten, r.Value.Wbw);
}
return(benchmarkingData);
}
public RangeModel GetRange(BenchmarkingGruppenTyp benchmarkingGruppenTyp, MandantDetails currentMandantDetails)
{
var dataBaseEigenschaftTyp = benchmarkingGruppenTyp.ToDataBaseEigenschaftTyp();
var wert = GetBenchmarkingGruppenWert(currentMandantDetails, benchmarkingGruppenTyp);
var benchmarkingGruppenConfigurations = transactionScopeProvider.Queryable <BenchmarkingGruppenConfiguration>().Where(bgc => bgc.EigenschaftTyp == dataBaseEigenschaftTyp);
return(new RangeModel
{
BenchmarkingGruppen = benchmarkingGruppenTyp,
UntereInclusieveGrenzwert = benchmarkingGruppenConfigurations.Where(bgc => bgc.Grenzwert <= wert).OrderByDescending(bgc => bgc.Grenzwert).Select(bgc => (decimal?)bgc.Grenzwert).FirstOrDefault(),
ObereExclusiveGrenzwert = benchmarkingGruppenConfigurations.Where(bgc => bgc.Grenzwert > wert).OrderBy(bgc => bgc.Grenzwert).Select(bgc => (decimal?)bgc.Grenzwert).FirstOrDefault(),
});
}
private decimal GetBenchmarkingGruppenWert(MandantDetails mandantDetailsModel, BenchmarkingGruppenTyp benchmarkingGruppenTyp)
{
switch (benchmarkingGruppenTyp)
{
case BenchmarkingGruppenTyp.NetzGroesse:
return(mandantDetailsModel.NetzLaenge);
case BenchmarkingGruppenTyp.EinwohnerGroesse:
return(mandantDetailsModel.Einwohner ?? 0);
case BenchmarkingGruppenTyp.MittlereHoehenlageSiedlungsgebieteGroesse:
return(mandantDetailsModel.MittlereHoehenlageSiedlungsgebiete ?? 0);
case BenchmarkingGruppenTyp.SteuerertragGroesse:
return(mandantDetailsModel.Steuerertrag ?? 0);
default:
throw new ArgumentOutOfRangeException("benchmarkingGruppenTyp");
}
}
public BenchmarkingData CalculateInventarBenchmarkingData <TEntity>(ErfassungsPeriod closedPeriod, MandantDetails mandantDetails, List <TEntity> strassenEntities, Func <TEntity, decimal> getLaenge)
where TEntity : IBelastungskategorieHolder, IFlaecheFahrbahnUndTrottoirHolder
{
var flaecheProBelastungskategorie = belastungskategorieService.AlleBelastungskategorie.ToDictionary(b => b, b => 0m);
decimal wbw = 0m;
decimal wvl = 0m;
foreach (var entity in strassenEntities)
{
var bk = flaecheProBelastungskategorie.Keys.Single(b => b.Id == entity.Belastungskategorie.Id);
flaecheProBelastungskategorie[bk] += entity.FlaecheFahrbahn;
var wieder = GetWieder(bk, closedPeriod);
var wiederbeschaffungswert = GetWiederbeschaffungswert(entity, wieder);
var wertverlustII = wiederbeschaffungswert * wieder.AlterungsbeiwertII / 100;
wbw += wiederbeschaffungswert;
wvl += wertverlustII;
}
decimal laengeSum = strassenEntities.Sum(getLaenge);
decimal flaecheSum = strassenEntities.Sum(e => e.FlaecheFahrbahn);
var benchmarkingData = GetBenchmarkingData(closedPeriod, mandantDetails, wvl, wbw, laengeSum, flaecheSum);
foreach (var bdd in benchmarkingData.BenchmarkingDataDetails)
{
var value = flaecheProBelastungskategorie.Single(f => f.Key.Id == bdd.Belastungskategorie.Id);
bdd.FahrbahnflaecheAnteil = Percent(value.Value, flaecheSum);
}
return(benchmarkingData);
}
private BenchmarkingData CalculateBenchmarkingDataForStrassenModus <TStrassenabschnittEntity, TZustandsabschnittEntity, TRealisierteMassnahmeEntity>(ErfassungsPeriod closedPeriod, MandantDetails mandantDetails, IQueryable <TStrassenabschnittEntity> strassenabschnitten, IQueryable <TZustandsabschnittEntity> zustandsabschnitten, IQueryable <TRealisierteMassnahmeEntity> realisierteMassnahmen)
where TStrassenabschnittEntity : StrassenabschnittBase
where TZustandsabschnittEntity : ZustandsabschnittBase
where TRealisierteMassnahmeEntity : RealisierteMassnahmeBase
{
BenchmarkingData benchmarkingData = CalculateInventarBenchmarkingData(closedPeriod, mandantDetails, strassenabschnitten.ToList(), sa => sa.Laenge);
CalculateZustandsBenchmarkingData(benchmarkingData, zustandsabschnitten.ToList(), za => za.Aufnahmedatum, za => za.Zustandsindex);
CalculateRealisierteMassnahmenBenchmarkingData(closedPeriod, benchmarkingData, mandantDetails, realisierteMassnahmen.ToList(), strassenabschnitten.ToList());
return(benchmarkingData);
}
public BenchmarkingData CalculateBenchmarkingDataForGisModus(ErfassungsPeriod closedPeriod, MandantDetails mandantDetails)
{
var strassenabschnittenGis = strassenabschnittGISService.GetEntitiesBy(closedPeriod, mandantDetails.Mandant).Where(sa => sa.Strasseneigentuemer == EigentuemerTyp.Gemeinde);
var zustandsabschnittenGis = zustandsabschnittGISService.GetEntitiesBy(closedPeriod, mandantDetails.Mandant).Where(za => za.StrassenabschnittGIS.Strasseneigentuemer == EigentuemerTyp.Gemeinde);
var realisierteMassnahmenGis = realisierteMassnahmeGISModelService.GetEntitiesBy(closedPeriod, mandantDetails.Mandant);
return(CalculateBenchmarkingDataForStrassenModus(closedPeriod, mandantDetails, strassenabschnittenGis, zustandsabschnittenGis, realisierteMassnahmenGis));
}
public BenchmarkingData CalculateBenchmarkingDataForTabellarischeModus(ErfassungsPeriod closedPeriod, MandantDetails mandantDetails)
{
var strassenabschnitten = strassenabschnittService.GetEntitiesBy(closedPeriod, mandantDetails.Mandant).Where(sa => sa.Strasseneigentuemer == EigentuemerTyp.Gemeinde);
var zustandsabschnitten = zustandsabschnittService.GetEntitiesBy(closedPeriod, mandantDetails.Mandant).Where(za => za.Strassenabschnitt.Strasseneigentuemer == EigentuemerTyp.Gemeinde);
var realisierteMassnahmen = realisierteMassnahmeService.GetEntitiesBy(closedPeriod, mandantDetails.Mandant);
return(CalculateBenchmarkingDataForStrassenModus(closedPeriod, mandantDetails, strassenabschnitten, zustandsabschnitten, realisierteMassnahmen));
}
public BenchmarkingData CalculateBenchmarkingDataForSummarischeModus(ErfassungsPeriod closedPeriod, MandantDetails mandantDetails)
{
var netzSummarischDetails = netzSummarischDetailService.GetEntitiesBy(closedPeriod, mandantDetails.Mandant).Fetch(nsd => nsd.NetzSummarisch).ToList();
var realisierteMassnahmeSummarsichen = realisierteMassnahmeSummarsichService.GetEntitiesBy(closedPeriod, mandantDetails.Mandant).ToList();
BenchmarkingData benchmarkingData = CalculateInventarBenchmarkingData(closedPeriod, mandantDetails, netzSummarischDetails, nsd => nsd.Fahrbahnlaenge);
CalculateZustandsBenchmarkingData(benchmarkingData, netzSummarischDetails.ToList(), nsd => nsd.NetzSummarisch.MittleresErhebungsJahr, za => za.MittlererZustand);
CalculateRealisierteMassnahmenBenchmarkingData(closedPeriod, benchmarkingData, mandantDetails, realisierteMassnahmeSummarsichen.ToList(), netzSummarischDetails);
return(benchmarkingData);
}
private IQueryOver <MandantDetails, MandantDetails> BuildGroupping(IQueryOver <MandantDetails, MandantDetails> queryOver, IEnumerable <BenchmarkingGruppenTyp> benchmarkingGruppenTypList, MandantDetails currentMandantDetails)
{
foreach (var benchmarkingGruppenTyp in benchmarkingGruppenTypList)
{
switch (benchmarkingGruppenTyp)
{
case BenchmarkingGruppenTyp.NetzGroesse:
queryOver = BuildQueryOver(md => md.NetzLaenge, queryOver, benchmarkingGruppenTyp, currentMandantDetails);
break;
case BenchmarkingGruppenTyp.EinwohnerGroesse:
queryOver = BuildQueryOver(md => md.Einwohner, queryOver, benchmarkingGruppenTyp, currentMandantDetails);
break;
case BenchmarkingGruppenTyp.Gemeinde:
queryOver = queryOver.Where(md => md.Gemeindetyp == currentMandantDetails.Gemeindetyp);
break;
case BenchmarkingGruppenTyp.MittlereHoehenlageSiedlungsgebieteGroesse:
queryOver = BuildQueryOver(md => md.MittlereHoehenlageSiedlungsgebiete, queryOver,
benchmarkingGruppenTyp, currentMandantDetails);
break;
case BenchmarkingGruppenTyp.OeffentlicheVerkehrsmittel:
queryOver =
queryOver.Where(
md => md.OeffentlicheVerkehrsmittel == currentMandantDetails.OeffentlicheVerkehrsmittel);
break;
case BenchmarkingGruppenTyp.SteuerertragGroesse:
queryOver = BuildQueryOver(md => md.Steuerertrag, queryOver, benchmarkingGruppenTyp, currentMandantDetails);
break;
default:
throw new ArgumentOutOfRangeException();
}
}
return(queryOver);
}
private IQueryOver <MandantDetails, MandantDetails> BuildQueryOver <TProperty>(Expression <Func <MandantDetails, TProperty> > expression, IQueryOver <MandantDetails, MandantDetails> queryOver, BenchmarkingGruppenTyp benchmarkingGruppenTyp, MandantDetails currentMandantDetails)
{
string propertyName = ExpressionHelper.GetPropertyName(expression);
var rangeModel = benchmarkingGruppenConfigurationService.GetRange(benchmarkingGruppenTyp, currentMandantDetails);
if (rangeModel.UntereInclusieveGrenzwert.HasValue)
{
queryOver = queryOver.Where(Restrictions.Ge(propertyName, Convert <TProperty>(rangeModel.UntereInclusieveGrenzwert.Value)));
}
if (rangeModel.ObereExclusiveGrenzwert.HasValue)
{
queryOver = queryOver.Where(Restrictions.Lt(propertyName, Convert <TProperty>(rangeModel.ObereExclusiveGrenzwert.Value)));
}
return(queryOver);
}
public static Mandant CreateMandant(ISession session, string mandantName, string ownerId, NetzErfassungsmodus netzErfassungsmodus = NetzErfassungsmodus.Summarisch, MandantDetails mandantDetails = null, string mandantBezeichnung = null)
{
var mandant = new Mandant
{
MandantBezeichnung = mandantBezeichnung ?? mandantName,
MandantName = mandantName,
OwnerId = ownerId
};
session.Save(mandant);
var erfassungsPeriod = CreateErfassungsPeriod(session, mandant, netzErfassungsmodus);
var netzSummarisch = new NetzSummarisch
{
ErfassungsPeriod = erfassungsPeriod,
MittleresErhebungsJahr = null,
Mandant = erfassungsPeriod.Mandant
};
session.Save(netzSummarisch);
foreach (Belastungskategorie belastungskategorie in session.Query <Belastungskategorie>())
{
session.Save(new NetzSummarischDetail
{
NetzSummarisch = netzSummarisch,
Belastungskategorie = belastungskategorie
});
}
foreach (GlobalWiederbeschaffungswertKatalog globalWiederbeschaffungswertKatalog in session.Query <GlobalWiederbeschaffungswertKatalog>())
{
session.Save(new WiederbeschaffungswertKatalog
{
AlterungsbeiwertI = globalWiederbeschaffungswertKatalog.AlterungsbeiwertI,
AlterungsbeiwertII = globalWiederbeschaffungswertKatalog.AlterungsbeiwertII,
GesamtflaecheFahrbahn = globalWiederbeschaffungswertKatalog.GesamtflaecheFahrbahn,
FlaecheTrottoir = globalWiederbeschaffungswertKatalog.FlaecheTrottoir,
FlaecheFahrbahn = globalWiederbeschaffungswertKatalog.FlaecheFahrbahn,
IsCustomized = false,
Belastungskategorie = globalWiederbeschaffungswertKatalog.Belastungskategorie,
ErfassungsPeriod = erfassungsPeriod,
Mandant = mandant,
});
}
foreach (string globalMassnahmenvorschlagKatalogtyp in session.Query <GlobalMassnahmenvorschlagKatalog>().Select(gmvk => gmvk.Parent.Typ).Distinct())
{
foreach (GlobalMassnahmenvorschlagKatalog globalMassnahmenvorschlagKatalog in session.Query <GlobalMassnahmenvorschlagKatalog>().Where(gmvk => gmvk.Parent.Typ == globalMassnahmenvorschlagKatalogtyp))
{
session.Save(new MassnahmenvorschlagKatalog
{
DefaultKosten = globalMassnahmenvorschlagKatalog.DefaultKosten,
IsCustomized = false,
Belastungskategorie = globalMassnahmenvorschlagKatalog.Belastungskategorie,
Parent = globalMassnahmenvorschlagKatalog.Parent,
ErfassungsPeriod = erfassungsPeriod,
Mandant = mandant,
});
}
}
if (mandantDetails == null)
{
session.Save(new MandantDetails
{
DifferenzHoehenlageSiedlungsgebiete = 10,
Einwohner = 2000,
Gemeindeflaeche = 30000,
Gemeindetyp = session.Query <GemeindeKatalog>().FirstOrDefault(),
MittlereHoehenlageSiedlungsgebiete = 400,
OeffentlicheVerkehrsmittel = session.Query <OeffentlicheVerkehrsmittelKatalog>().FirstOrDefault(),
Siedlungsflaeche = 500000,
Steuerertrag = 7,
NetzLaenge = 0,
IsCompleted = true,
Mandant = mandant,
ErfassungsPeriod = erfassungsPeriod
});
}
else
{
mandantDetails.Mandant = mandant;
mandantDetails.ErfassungsPeriod = erfassungsPeriod;
session.Save(mandantDetails);
}
return(mandant);
}
