private IQuery getZabGisQuery(ErfassungsPeriod closedPeriod)
{
string zabGisQueryString = String.Format("insert into {0} ({1}, {2}, {3}, {4}, {5}, {6}, {7}, {8}, {9}, {10}, {11}, {12}, " +
"{13}, {14}, {15}, {16}, {17}, {18}, {19}, {20}, {21}, {22}, {23}, {24}, {25}) " +
"Select guid(),zsg.{2}, zsg.{3}, zsg.{4}, zsg.{5}, zsg.{6}, zsg.{7}, zsg.{8}, zsg.{9}, zsg.{10}, zsg.{11}, zsg.{12}, " +
"zsg.{13}, zsg.{14}, zsg.{15}, zsg.{16}, zsg.{17}, zsg.{18}, zsg.{19}, zsg.{20}, zsg.{21}, zsg.{22}, stg, rfg, zsg " +
"From {0} zsg, {26} stg, {27} rfg " +
"Where zsg.{23} = stg.{28} and zsg.{24} = rfg.{29} and zsg.{23}.{30}=:oldErfPeriod",
new string[]
{
zabGisTypeName, zabGisIdPropName, zabGisIndexPropName, zabGisBezVonPropName,
zabGisBezBisPropName, zabGisErfssungsMPropName, zabGisLaengePropName, zabGisAufnahmeDatPropName,
zabGisAufnahmeTeamPropName, zabGisWetterPropName, zabGisBemerkungPropName, zabGisZstIndTrLPropName,
zabGisZstIndTrRPropName, zabGisFBKostenPropName, zabGisFBDringlichPropName, zabGisTrRKostenPropName,
zabGisTrRDringlichPropName, zabGisTrLKostenPropName, zabGisTrLDringlichPropName, zabGisShapePropName,
zabGisMvkFbPropName, zabGisMvkTrRPropName, zabGisMvkTrLPropName, zabGisStrabPropName,
zabGisRefGruppePropName, zabGisCopyFromPropName, straGisTypeName, refGruppeTypeName,
straGisCopyFromPropName, refGruppeCopyFromPropName, straGisErfPeriodPropName
});
var zabGisQuery = CurrentSession.CreateQuery(zabGisQueryString);
zabGisQuery.SetParameter("oldErfPeriod", closedPeriod);
return(zabGisQuery);
}
public JahresInterval CalculateFromErfassungsPeriodList(ErfassungsPeriod currentPeriod, List <ErfassungsPeriod> erfassungsPeriodList)
{
var index = erfassungsPeriodList.IndexOf(currentPeriod);
var erfassungsJahrVon = currentPeriod.IsClosed ? currentPeriod.Erfassungsjahr.Year : Math.Max(timeService.Now.Year, currentPeriod.Erfassungsjahr.Year);
int erfassungsJahrBis;
if (currentPeriod == erfassungsPeriodList.Last())
{
if (!currentPeriod.IsClosed)
{
erfassungsJahrBis = Math.Max(timeService.Now.Year, currentPeriod.Erfassungsjahr.Year);
}
else
{
erfassungsJahrBis = erfassungsJahrVon;
}
}
else
{
erfassungsJahrBis = erfassungsPeriodList[index + 1].Erfassungsjahr.Year - 1;
}
return(new JahresInterval(erfassungsJahrVon, erfassungsJahrBis));
}
public static void GenerateSummarichDaten(ISession session, ErfassungsPeriod currentPeriod)
{
var netzSummarisch = session.Query <NetzSummarisch>().Single(m => m.ErfassungsPeriod == currentPeriod);
netzSummarisch.MittleresErhebungsJahr = DateTime.Now;
netzSummarisch.NetzSummarischDetails.ToList().ForEach(n => netzSummarisch.NetzSummarischDetails.Remove(n));
session.Flush();
var belastungskategories = session.Query <Belastungskategorie>().ToList();
var randomItemPicker = new RandomItemPicker <Belastungskategorie>(belastungskategories, new UniqueRandomGenerator());
var detailBuilder = Builder <NetzSummarischDetail> .CreateListOfSize(belastungskategories.Count)
.All()
.With(d => d.NetzSummarisch = netzSummarisch)
.With(d => d.Belastungskategorie = randomItemPicker.Pick());
foreach (var netzSummarischDetail in detailBuilder.Build())
{
netzSummarisch.NetzSummarischDetails.Add(netzSummarischDetail);
session.Save(netzSummarischDetail);
}
var realisierteMassnahmenBuilder = Builder <RealisierteMassnahmeSummarsich> .CreateListOfSize(RealisierteMassnahmeSummarsichCount)
.All()
.With(d => d.Mandant = currentPeriod.Mandant)
.With(d => d.ErfassungsPeriod = currentPeriod)
.With(d => d.Belastungskategorie = Pick <Belastungskategorie> .RandomItemFrom(belastungskategories));
foreach (var realisierteMassnahmeSummarsich in realisierteMassnahmenBuilder.Build())
{
session.Save(realisierteMassnahmeSummarsich);
}
}
public void CalculateBenchmarkingData(ErfassungsPeriod closedPeriod)
{
var mandantDetails = mandantDetailsService.GetEntitiesBy(closedPeriod).Single();
BenchmarkingData benchmarkingData;
switch (closedPeriod.NetzErfassungsmodus)
{
case NetzErfassungsmodus.Summarisch:
benchmarkingData = CalculateBenchmarkingDataForSummarischeModus(closedPeriod, mandantDetails);
break;
case NetzErfassungsmodus.Tabellarisch:
benchmarkingData = CalculateBenchmarkingDataForTabellarischeModus(closedPeriod, mandantDetails);
break;
case NetzErfassungsmodus.Gis:
benchmarkingData = CalculateBenchmarkingDataForGisModus(closedPeriod, mandantDetails);
break;
default:
throw new ArgumentOutOfRangeException();
}
transactionScopeProvider.Create(benchmarkingData);
}
private static void GenerateStrassenabschnitt(ISession session, ErfassungsPeriod currentPeriod)
{
var belastungskategories = session.Query <Belastungskategorie>().ToList();
var strassenabschnittBuilder = Builder <Strassenabschnitt> .CreateListOfSize(StrassenabschnittCount)
.All()
.With(s => s.Belastungskategorie = Pick <Belastungskategorie> .RandomItemFrom(belastungskategories))
.With(s => s.Mandant = currentPeriod.Mandant)
.With(s => s.ErfassungsPeriod = currentPeriod);
var zustandsabschnitten = Builder <Zustandsabschnitt> .CreateListOfSize(StrassenabschnittCount * 2)
.All()
.With(z => z.Erfassungsmodus = ZustandsErfassungsmodus.Manuel)
.With(z => z.Zustandsindex = Pick <decimal> .RandomItemFrom(new List <decimal> {
0.0m, 0.25m, 0.5m, 0.75m, 1, 1.5m, 2, 2.5m, 3, 3.5m, 4, 4.5m, 5
}))
.Build();
var index = 0;
var pageSize = 2;
foreach (var strassenabschnitt in strassenabschnittBuilder.Build())
{
session.Save(strassenabschnitt);
foreach (var zustandsabschnitt in zustandsabschnitten.Skip(index * pageSize).Take(pageSize))
{
zustandsabschnitt.Strassenabschnitt = strassenabschnitt;
strassenabschnitt.Zustandsabschnitten.Add(zustandsabschnitt);
session.Save(zustandsabschnitt);
}
index++;
}
}
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 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 MandantDetails CreateCopy(ErfassungsPeriod closedPeriod)
{
var mandantDetailsToCopy = GetEntitiesBy(closedPeriod).Single();
var copiedMandantDetails = entityServiceMappingEngine.Translate <MandantDetails, MandantDetails>(mandantDetailsToCopy);
return(CreateEntity(copiedMandantDetails));
}
public static void GenerateRealisierteMassnahmeGIS(ISession session, ErfassungsPeriod currentPeriod)
{
var achsensegmente = session.Query <AchsenSegment>().ToList();
achsensegmente = achsensegmente.Where(r => r.ErfassungsPeriod == currentPeriod).Take(RealisierteMassnahmeGISCount).ToList();
int achsensegmente_count = achsensegmente.Count;
var generator = new RandomGenerator();
var massnahmenvorschlagBuilder = Builder <RealisierteMassnahmeGIS> .CreateListOfSize(achsensegmente_count)
.All()
.With(s => s.Mandant = currentPeriod.Mandant)
.With(s => s.Beschreibung = generator.Phrase(20))
.With(s => s.Projektname = generator.Phrase(20));
var realisierteMassnahmenList = massnahmenvorschlagBuilder.Build();
var index = 0;
foreach (var realisierteMassnahme in realisierteMassnahmenList)
{
realisierteMassnahme.Shape = achsensegmente[index].Shape;
realisierteMassnahme.ReferenzGruppe = new ReferenzGruppe();
realisierteMassnahme.ReferenzGruppe.Erfassungsperiod = currentPeriod;
realisierteMassnahme.ReferenzGruppe.Mandant = currentPeriod.Mandant;
realisierteMassnahme.ReferenzGruppe.RealisierteMassnahmeGISList.Add(realisierteMassnahme);
var ar = new AchsenReferenz();
ar.Mandandt = currentPeriod.Mandant;
ar.Shape = achsensegmente[index].Shape;
ar.AchsenSegment = achsensegmente[index];
ar.ReferenzGruppe = realisierteMassnahme.ReferenzGruppe;
realisierteMassnahme.ReferenzGruppe.AchsenReferenzen.Add(ar);
realisierteMassnahme.Shape = achsensegmente[index].Shape;
session.Save(realisierteMassnahme);
index++;
}
}
private void DeleteEntitesByErfassungsPeriod <T>(ISession session, ErfassungsPeriod erfassungsPeriod) where T : IErfassungsPeriodDependentEntity
{
var typeName = typeof(T).Name;
var queryString = string.Format("delete {0} c where c.ErfassungsPeriod = :ep", typeName);
session.CreateQuery(queryString).SetParameter("ep", erfassungsPeriod).ExecuteUpdate();
}
protected override void DbInit()
{
using (var scope = new NHibernateTestScope())
{
var mandant = DbHandlerUtils.CreateMandant(scope.Session, TestMandantName, "0", Erfassungmodus);
closedErfassungPeriod = DbHandlerUtils.CreateErfassungsPeriod(scope.Session, mandant, Erfassungmodus);
closedErfassungPeriod.IsClosed = true;
closedErfassungPeriod.Erfassungsjahr = new DateTime(2010, 1, 1);
DbHandlerUtils.CreateMandant(scope.Session, OtherTestMandantName, "0", Erfassungmodus);
DbHandlerUtils.CreateTestUser(scope.Session, TestUserName, new[] { mandant }, new List <Rolle> {
Rolle.DataManager, Rolle.DataReader, Rolle.Benutzeradministrator, Rolle.Benchmarkteilnehmer
});
}
using (var scope = new NHibernateTestScope())
{
currentErfassungsPeriod = scope.Session.Query <ErfassungsPeriod>().Single(m => !m.IsClosed && m.Mandant.MandantName == TestMandantName);
currentErfassungsPeriod.Erfassungsjahr = new DateTime(2012, 1, 1);
otherErfassungPeriod = scope.Session.Query <ErfassungsPeriod>().Single(m => !m.IsClosed && m.Mandant.MandantName == OtherTestMandantName);
otherErfassungPeriod.Erfassungsjahr = new DateTime(2012, 1, 1);
}
Init();
}
private void DeleteAllDataFromCurrentPeriod(ErfassungsPeriod currentPeriod, ErfassungsPeriod lastClosedPeriod)
{
var session = transactionScopeProvider.CurrentTransactionScope.Session;
//Summarsich
DeleteEntitesByErfassungsPeriod <RealisierteMassnahmeSummarsich>(session, currentPeriod);
DeleteEntitesByErfassungsPeriod <NetzSummarischDetail, NetzSummarisch>(session, currentPeriod, n => n.NetzSummarisch);
DeleteEntitesByErfassungsPeriod <NetzSummarisch>(session, currentPeriod);
//Tabellarisch
DeleteEntitesByErfassungsPeriod <RealisierteMassnahme>(session, currentPeriod);
DeleteEntitesByErfassungsPeriod <Schadengruppe, Zustandsabschnitt, Strassenabschnitt>(session, currentPeriod, s => s.Zustandsabschnitt, z => z.Strassenabschnitt);
DeleteEntitesByErfassungsPeriod <Schadendetail, Zustandsabschnitt, Strassenabschnitt>(session, currentPeriod, s => s.Zustandsabschnitt, z => z.Strassenabschnitt);
DeleteEntitesByErfassungsPeriod <Zustandsabschnitt, Strassenabschnitt>(session, currentPeriod, n => n.Strassenabschnitt);
DeleteEntitesByErfassungsPeriod <Strassenabschnitt>(session, currentPeriod);
//GIS
DeleteGisEntities(session, currentPeriod);
//Benchmarking: needs to be deleted from the previous period because it is calculated during thee Jahresabschluss
DeleteEntitesByErfassungsPeriod <BenchmarkingDataDetail, BenchmarkingData>(session, lastClosedPeriod, b => b.BenchmarkingData);
DeleteEntitesByErfassungsPeriod <BenchmarkingData>(session, lastClosedPeriod);
//Other
DeleteEntitesByErfassungsPeriod <MandantDetails>(session, currentPeriod);
DeleteEntitesByErfassungsPeriod <AchsenUpdateConflict>(session, currentPeriod);
//Katalogs
DeleteEntitesByErfassungsPeriod <WiederbeschaffungswertKatalog>(session, currentPeriod);
DeleteEntitesByErfassungsPeriod <MassnahmenvorschlagKatalog>(session, currentPeriod);
//ErfassungsPeriod
session.Delete(currentPeriod);
}
public static InspektionsRouteGIS GetInspektionsRouteGIS(ErfassungsPeriod erfassungsPeriod, string bezeichnung, DateTime?inInspektionBis, StrassenabschnittGIS strassenabschnittGISOne)
{
var inspektionsRouteGIS = new InspektionsRouteGIS
{
Bezeichnung = bezeichnung,
Bemerkungen = "Bemerkungen",
Beschreibung = "Beschreibung",
ErfassungsPeriod = erfassungsPeriod,
InInspektionBei = bezeichnung.GetInInspektionBei(),
InInspektionBis = inInspektionBis,
Mandant = erfassungsPeriod.Mandant
};
inspektionsRouteGIS.StatusverlaufList = new List <InspektionsRouteStatusverlauf>
{
new InspektionsRouteStatusverlauf
{
Status = InspektionsRouteStatus.NeuErstellt,
InspektionsRouteGIS = inspektionsRouteGIS,
Datum = DateTime.Now
}
};
inspektionsRouteGIS.InspektionsRtStrAbschnitteList = new List <InspektionsRtStrAbschnitte>
{
new InspektionsRtStrAbschnitte
{
InspektionsRouteGIS = inspektionsRouteGIS,
StrassenabschnittGIS = strassenabschnittGISOne
}
};
return(inspektionsRouteGIS);
}
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 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);
}
public void DeleteUnusedData(ErfassungsPeriod closedPeriod)
{
foreach (var zustandsabschnittBase in GetAllByErfassungsPeriod(closedPeriod))
{
switch (zustandsabschnittBase.StrassenabschnittBase.Trottoir)
{
case TrottoirTyp.NochNichtErfasst:
case TrottoirTyp.KeinTrottoir:
CleanUpTrottoirLinks(zustandsabschnittBase);
CleanUpTrottoirRechts(zustandsabschnittBase);
break;
case TrottoirTyp.Links:
CleanUpTrottoirRechts(zustandsabschnittBase);
break;
case TrottoirTyp.Rechts:
CleanUpTrottoirLinks(zustandsabschnittBase);
break;
case TrottoirTyp.BeideSeiten:
//NOP
break;
default:
throw new ArgumentOutOfRangeException();
}
}
}
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 AchsenAutoUpdate(ISession session, Mandant mandant, ErfassungsPeriod erfassungsPeriod, string owner)
: base(session,
mandant,
erfassungsPeriod,
owner,
GetLastImpNr(session, mandant))
{
}
public static ErfassungsPeriod CreateErfassungsPeriod(this NHibernateTestScope scope, int year, NetzErfassungsmodus mode, string mandantName, bool isClosed = true)
{
var erfassungsPeriod = new ErfassungsPeriod {
Erfassungsjahr = new DateTime(year, 01, 01), IsClosed = isClosed, NetzErfassungsmodus = mode, Mandant = scope.GetMandant(mandantName)
};
erfassungsPeriod.Id = scope.Save(erfassungsPeriod);
return(erfassungsPeriod);
}
public static NetzSummarisch GetNetzSummarisch(ErfassungsPeriod erfassungsPeriod)
{
return(new NetzSummarisch
{
ErfassungsPeriod = erfassungsPeriod,
Mandant = erfassungsPeriod.Mandant,
MittleresErhebungsJahr = DateTime.Parse("2012.01.01"),
});
}
public static T AddEntity <T>(this ErfassungsPeriod ep, NHibernateTestScope scope, T entity) where T : IErfassungsPeriodDependentEntity
{
entity.ErfassungsPeriod = ep;
entity.Mandant = ep.Mandant;
var id = scope.Save(entity);
entity.Id = id;
return(entity);
}
public static void ClearUpdateLog(ISession session, Mandant testMandant, ErfassungsPeriod erfPeriod)
{
var allEntries = session.QueryOver <AchsenUpdateLog>()
.Where(o => o.ErfassungsPeriod == erfPeriod)
.Where(o => o.Mandant == testMandant)
.List();
allEntries.ToList().ForEach(o => session.Delete(o));
}
public static RealisierteMassnahme GetRealisierteMassnahme(ErfassungsPeriod erfassungsPeriod, string projektName, string beschreibung)
{
return(new RealisierteMassnahme
{
Projektname = projektName,
Beschreibung = beschreibung,
Mandant = erfassungsPeriod.Mandant,
ErfassungsPeriod = erfassungsPeriod,
});
}
public static KoordinierteMassnahmeGIS GetKoordinierteMassnahmeGIS(ErfassungsPeriod erfassungsPeriod, string projektName, StatusTyp status, DateTime?ausfuehrungsAnfangdateTime)
{
return(new KoordinierteMassnahmeGIS
{
Projektname = projektName,
Mandant = erfassungsPeriod.Mandant,
Status = status,
AusfuehrungsAnfang = ausfuehrungsAnfangdateTime,
});
}
public static RealisierteMassnahmeGIS GetRealisierteMassnahmeGIS(ErfassungsPeriod erfassungsPeriod, string projektName, string leitendeOrganisation, string beschreibung)
{
return(new RealisierteMassnahmeGIS
{
Projektname = projektName,
Beschreibung = beschreibung,
Mandant = erfassungsPeriod.Mandant,
ErfassungsPeriod = erfassungsPeriod,
LeitendeOrganisation = leitendeOrganisation,
});
}
private void DeleteEntitesByErfassungsPeriod <TEntity, TParent>(ISession session,
ErfassungsPeriod erfassungsPeriod,
Expression <Func <TEntity, TParent> > parentSelector) where TParent : IErfassungsPeriodDependentEntity
{
var typeName = typeof(TEntity).Name;
var parentTypeName = typeof(TParent).Name;
var parentPropName = ExpressionHelper.GetPropertyName(parentSelector);
var queryString = string.Format("delete {0} c where c.{1}.Id in (select p.id from {2} p where p.ErfassungsPeriod = :ep)", typeName, parentPropName, parentTypeName);
session.CreateQuery(queryString).SetParameter("ep", erfassungsPeriod).ExecuteUpdate();
}
public AchsenUpdate(ISession session, Mandant mandant, ErfassungsPeriod erfassungsPeriod, string owner, int lastImpNr)
{
this.session = session;
this.mandant = mandant;
this.erfassungsPeriod = erfassungsPeriod;
this.owner = owner;
this.lastImpNr = lastImpNr;
this.maxImpNr = lastImpNr;
this.gisKopieMappingEngine = new GISKopieMappingEngine(new GISKopieMappingConfiguration(new IgnoreIdMappingRule(), new MLineStringTo2DMappingRule()));
}
private void CalculatePosForStrassenModus <T>(ErfassungsPeriod erfassungsPeriod, IQueryable <T> queryable, Parameter parameter, JahresInterval jahresInterval)
where T : StrassenabschnittBase
{
var strassenabschnittList = filtererFactory
.CreateFilterer <T>(parameter)
.Filter(queryable)
.Fetch(sa => sa.Belastungskategorie)
.ToList();
CalculatePosForJahr(erfassungsPeriod, strassenabschnittList, jahresInterval, GetWiederbeschaffungswert, sa => sa.Belastungskategorie, sa => sa.FlaecheFahrbahn);
}
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);
}
