private void GenerateReport <TControler, TParameter, TPo>(int currentYear, string gruppen)
where TControler : BenchmarkauswertungControllerBase <TParameter, TPo>
where TParameter : EmsgReportParameter, new()
where TPo : new()
{
Guid currentYearId;
using (var nhScope = new NHibernateSpecflowScope())
{
var currentMandant = nhScope.Session.Query <Mandant>().Single(m => m.MandantName == currentMandantName);
SetMandant(currentMandant.Id);
var currentEp = nhScope.Session.Query <ErfassungsPeriod>().SingleOrDefault(e => e.Mandant == currentMandant && e.Erfassungsjahr.Year == currentYear);
currentYearId = currentEp != null ? currentEp.Id : nhScope.Session.Query <KenngroessenFruehererJahre>().Single(e => e.Mandant == currentMandant && e.Jahr == currentYear).Id;
}
//GetBenchmarkauswertungPreview
var nameValueCollection = new NameValueCollection();
nameValueCollection["JahrId"] = currentYearId.ToString();
var index = 0;
foreach (var gruppe in gruppen.Split(','))
{
nameValueCollection.Add(string.Format("BenchmarkingGruppenTypList[{0}]", index), gruppe);
index++;
}
BrowserDriver.InvokePostAction <TControler, TParameter>((c, r) => c.GetBenchmarkauswertungPreview(r), nameValueCollection);
reportsSteps.GeneratReports((EmsgReportParameter) new TParameter(), rp => BrowserDriver.InvokePostAction <TControler, TParameter>((c, r) => c.GetReport(r), (TParameter)rp, false));
}
private void SetupTestUserRole(Rolle rolle)
{
using (var scope = new NHibernateSpecflowScope())
{
DbHandlerUtils.SetupTestUserRole(scope.Session, DbHandlerUtils.IntegrationTestUserName, rolle);
}
}
public void GegebenSeiFolgendeEinstellungenExistieren(Table table)
{
var reader = GetObjectReaderConfigurationFor <MandantDetails>()
.ConverterFor(e => e.Mandant, (s, p) => new Mandant()
{
MandantName = s
})
.ConverterFor(e => e.Gemeindetyp, (s, p) => ScenarioContextWrapper.CurrentScope.Session.Query <GemeindeKatalog>().ToArray().Single(i => i.Typ == s))
.ConverterFor(e => e.OeffentlicheVerkehrsmittel, (s, p) => ScenarioContextWrapper.CurrentScope.Session.Query <OeffentlicheVerkehrsmittelKatalog>().Single(i => i.Typ == s))
.GetObjectReader();
using (var nhScope = new NHibernateSpecflowScope())
{
foreach (var row in reader.GetObjectListWithRow <MandantDetails>(table))
{
row.Item2.IsCompleted = true;
DbHandlerUtils.CreateMandant(nhScope.Session, row.Item1["Mandant"], null, mandantDetails: row.Item2);
}
}
using (var nhScope = new NHibernateSpecflowScope())
{
IQueryable <Mandant> mandanten = nhScope.Session.Query <Mandant>();
DbHandlerUtils.CreateTestUser(nhScope.Session, DbHandlerUtils.IntegrationTestUserName, mandanten, new List <Rolle>()
{
Rolle.Benutzeradministrator, Rolle.DataManager, Rolle.Benchmarkteilnehmer
});
}
}
public ReportFilters GetReportFilters(Table table)
{
var reportFilters = new ReportFilters();
var reportFilterRows = table.CreateSet <ReportFilterRow>();
foreach (var filterRow in reportFilterRows)
{
switch (filterRow.Filter)
{
case "Erfassungsperiode":
using (var nhScope = new NHibernateSpecflowScope())
{
var mandant = nhScope.GetCurrentMandant();
int year = int.Parse(filterRow.FilterWert);
var erfassungsPeriod = nhScope.GetClosedErfassungsperiods(mandant.MandantName).Single(e => e.Erfassungsjahr.Year == year);
reportFilters.ErfassungsPeriodId = erfassungsPeriod.Id;
LastGeneratedReportErfassungsPeriodIdFilter = reportFilters.ErfassungsPeriodId;
}
break;
case "Strasseneigentümer":
reportFilters.EigentuemerTyp = (EigentuemerTyp?)Enum.Parse(typeof(EigentuemerTyp), filterRow.FilterWert);
break;
}
}
return(reportFilters);
}
private void WennIchDieBenchmarkauswertungFurDasJahreUnterBerucksichtigungDerKlassen <TControler, TParameter, TPo>(int currentYear, string gruppen)
where TControler : BenchmarkauswertungControllerBase <TParameter, TPo>
where TParameter : EmsgReportParameter, new()
where TPo : new()
{
foreach (var entitesProModus in entitesProErfassungsmodus)
{
var years = entitesProModus.Value.SelectMany(e => e.Value).Select(m => m.ErfassungsPeriod.Erfassungsjahr.Year).Distinct().ToArray();
foreach (var year in years)
{
using (var nhScope = new NHibernateSpecflowScope())
{
foreach (var entity in entitesProModus.Value.SelectMany(e => e.Value).Where(m => m.ErfassungsPeriod.Erfassungsjahr.Year == year).ToArray())
{
entity.Mandant = nhScope.Session.Query <Mandant>().Single(m => m.MandantName == entity.Mandant.MandantName);
entity.ErfassungsPeriod = nhScope.Session.Query <ErfassungsPeriod>()
.Single(e => !e.IsClosed && e.Mandant == entity.Mandant);
entity.ErfassungsPeriod.NetzErfassungsmodus = entitesProModus.Key;
nhScope.Session.Save(entity);
}
}
foreach (var manadantId in entitesProModus.Value.SelectMany(e => e.Value).Select(m => m.Mandant.Id).Distinct())
{
CloseYear(year, manadantId);
}
}
}
GenerateReport <TControler, TParameter, TPo>(currentYear, gruppen);
}
public void AngenommenDieFolgendenKenngroessenFruehererJahreExistieren(Table table)
{
foreach (var item in table.Rows.GroupBy(i => new { Jahr = i["Jahr"], Madndat = i["Mandant"] }))
{
using (var nhScope = new NHibernateSpecflowScope())
{
var main = new KenngroessenFruehererJahre()
{
Jahr = int.Parse(item.Key.Jahr),
Mandant = nhScope.Session.Query <Mandant>().Single(m => m.MandantName == item.Key.Madndat),
};
if (item.First().ContainsKey("KostenFuerWerterhaltung"))
{
main.KostenFuerWerterhaltung = decimal.Parse(item.First()["KostenFuerWerterhaltung"]);
}
nhScope.Session.Save(main);
foreach (var row in item)
{
var d = new KenngroessenFruehererJahreDetail();
d.Belastungskategorie = nhScope.Session.Query <Belastungskategorie>().ToArray().Single(i => i.Typ == row["Belastungskategorie"]);
d.MittlererZustand = decimal.Parse(row["MittlererZustand"]);
d.Fahrbahnlaenge = decimal.Parse(row["Fahrbahnlaenge"]);
d.Fahrbahnflaeche = int.Parse(row["Fahrbahnflaeche"]);
d.KenngroessenFruehererJahre = main;
nhScope.Session.Save(d);
}
}
}
}
private void CreateTestUserWithRoles(string mandantName, List <Rolle> rollen)
{
using (var nhScope = new NHibernateSpecflowScope())
{
IQueryable <Mandant> mandanten = nhScope.Session.Query <Mandant>().Where(m => m.MandantName == mandantName);
DbHandlerUtils.CreateTestUser(nhScope.Session, DbHandlerUtils.IntegrationTestUserName, mandanten, rollen);
}
}
public void DannSindFurDenStrassenabschnittMitDerId1KeineZustandeUndMassnahmenImSystem(int strassenabschnittId)
{
using (NHibernateSpecflowScope scope = new NHibernateSpecflowScope())
{
var zustandsabschnitten = scope.Session.Query <Zustandsabschnitt>()
.Where(i => i.Strassenabschnitt.Id == StrassenabschnittSteps.StrassenabschnittIds[strassenabschnittId]);
CollectionAssert.IsEmpty(zustandsabschnitten.ToArray());
}
}
public void WennIchDieXLSX_DateiImportiere()
{
using (var scope = new NHibernateSpecflowScope())
{
var strassenabschnittService = SpecFlowTestConatainer.Resolve <IStrassenabschnittXlsxImportService>();
strassenabschnittService.ImportStrassenabschnitte(StrassenabschnittImportFileStream);
strassenabschnittService.CommitStrassenabschnittImport();
}
}
public void AngenommenFolgendeEinstellungenExistieren(Table table)
{
var einstellungenRows = table.CreateSet <EinstellungenRow>();
using (var nhScope = new NHibernateSpecflowScope())
{
foreach (var einstellungenRow in einstellungenRows)
{
DbHandlerUtils.CreateMandant(nhScope.Session, einstellungenRow.Mandant, null, GetModus(einstellungenRow.Modus));
}
}
}
public void DannSindFolgendeZustandsabschnitteImSystem(Table table)
{
if (HasFieldValidationError()) //don't assert if the previous save was unsuccessfull
{
return;
}
using (NHibernateSpecflowScope nHibernateSpecflowScope = new NHibernateSpecflowScope())
{
var strassenabschnittReader = GetZustandsabschnittReader();
var areObjectListWithTableEqual = strassenabschnittReader.ARe(nHibernateSpecflowScope.Session.Query <Zustandsabschnitt>().ToList(), table);
Assert.IsTrue(areObjectListWithTableEqual);
}
}
public void AngenommenFurMandantExistierenFolgendeNetzinformationen(string mandant, Table table)
{
using (NHibernateSpecflowScope scope = new NHibernateSpecflowScope())
{
var strassenabschnittReader = GetStrassenabschnittReader();
var strassenabschnitten = strassenabschnittReader.GetObjectList <Strassenabschnitt>(table);
foreach (var strassenabschnitt in strassenabschnitten)
{
strassenabschnitt.Mandant = scope.GetMandant(mandant);
strassenabschnitt.ErfassungsPeriod = scope.GetCurrentErfassungsperiod(mandant);
scope.Session.Save(strassenabschnitt);
}
}
}
public void AngenommenDieFolgendenStrassenabschnitteGUSExistieren(Table table)
{
using (var scope = new NHibernateSpecflowScope())
{
foreach (var currentErfassungsperiod in scope.Session.Query <ErfassungsPeriod>())
{
var achse = new Achse
{
VersionValidFrom = DateTime.Now,
ErfassungsPeriod = currentErfassungsperiod
};
var segment = new AchsenSegment();
segment.Achse = achse;
segment.ErfassungsPeriod = currentErfassungsperiod;
achse.AchsenSegmente.Add(segment);
scope.Session.Save(segment);
scope.Session.Save(achse);
}
}
var reader = GetObjectReaderConfigurationFor <StrassenabschnittGIS>()
.PropertyAliasFor(e => e.ErfassungsPeriod, "Jahr")
.ConverterFor(e => e.Belastungskategorie, (s, p) => ScenarioContextWrapper.CurrentScope.Session.Query <Belastungskategorie>().ToArray().Single(i => i.Typ == s))
.ConverterFor(e => e.Mandant, (s, p) => new Mandant {
MandantName = s
})
.ConverterFor(e => e.ErfassungsPeriod, (s, p) => new ErfassungsPeriod {
Erfassungsjahr = new DateTime(int.Parse(s), 1, 1)
});
using (var nhScope = new NHibernateSpecflowScope())
{
entitesProErfassungsmodus[NetzErfassungsmodus.Gis][typeof(StrassenabschnittGIS)] = reader.GetObjectReader().GetObjectList <StrassenabschnittGIS>(table);
foreach (StrassenabschnittGIS strassenabschnitt in entitesProErfassungsmodus[NetzErfassungsmodus.Gis][typeof(StrassenabschnittGIS)])
{
var segment =
nhScope.Session.Query <AchsenSegment>().First(a => !a.ErfassungsPeriod.IsClosed &&
a.ErfassungsPeriod.Mandant.MandantName == strassenabschnitt.Mandant.MandantName);
var achsenReferenz = new AchsenReferenz();
achsenReferenz.AchsenSegment = segment;
var referenzGruppe = new ReferenzGruppe();
strassenabschnitt.ReferenzGruppe = referenzGruppe;
referenzGruppe.StrassenabschnittGISList.Add(strassenabschnitt);
achsenReferenz.ReferenzGruppe = referenzGruppe;
referenzGruppe.AchsenReferenzen.Add(achsenReferenz);
}
}
}
public void DannSindFolgendeNetzinformationenImSystem(Table table)
{
if (HasFieldValidationError())
{
return;
}
using (NHibernateSpecflowScope nHibernateSpecflowScope = new NHibernateSpecflowScope())
{
var strassenabschnittReader = GetStrassenabschnittReader();
var strassenabschnitts = nHibernateSpecflowScope.Session.Query <Strassenabschnitt>().ToList();
var areObjectListWithTableEqual = strassenabschnittReader.AreObjectListWithTableEqual(strassenabschnitts, table);
Assert.IsTrue(areObjectListWithTableEqual);
}
}
public void AngenommenFurMandantMandant_1ExistierenFolgendeZustandsinformationen(string mandant, Table table)
{
using (NHibernateSpecflowScope scope = new NHibernateSpecflowScope())
{
var zustandsabschnittReader = GetZustandsabschnittReader();
currentMandant = scope.GetMandant(mandant);
var zustandsabschnitten = zustandsabschnittReader.GetObjectListWithRow <Zustandsabschnitt>(table);
foreach (var zustandsabschnitt in zustandsabschnitten)
{
Zustandsabschnitt za = zustandsabschnitt.Item2;
za.Aufnahmedatum = DateTime.Now;
scope.Session.Save(za);
}
}
}
public void WennIchMittleresAlterEingebe(string mittleresAlter)
{
BrowserDriver.InvokePostAction <StrassenmengeUndZustandController, ActionResult>((c, r) => c.Index(), null);
var netzSummarischModel = new NetzSummarischModel();
using (var nh = new NHibernateSpecflowScope())
{
NetzSummarisch netzSummarisch = nh.Session.Query <NetzSummarisch>().Single();
netzSummarischModel.Id = netzSummarisch.Id;
}
netzSummarischModel.MittleresErhebungsJahr = mittleresAlter.ParseNullableDateTime();
BrowserDriver.InvokePostAction <StrassenmengeUndZustandController, NetzSummarischModel>((c, r) => c.SaveMittleresErhebungsjahr(r), netzSummarischModel);
}
public void FuerMandantFolgendeSummarischeZustandsUndNetzinformationenExistieren(string mandantName, Table table)
{
using (var nhScope = new NHibernateSpecflowScope())
{
var rows = table.CreateSet <NetzSummarischRow>();
var mandant = nhScope.GetMandant(mandantName);
var erfassungsPeriod = nhScope.GetCurrentErfassungsperiod(mandantName);
foreach (var row in rows)
{
var netzSummarisch = nhScope.GetNetzSummarischDetail(row.Belastungskategorie, mandant, erfassungsPeriod);
netzSummarisch.MittlererZustand = row.MittlererZustandValue;
netzSummarisch.Fahrbahnlaenge = row.MengeGesamtlangeValue ?? 0;
netzSummarisch.Fahrbahnflaeche = (int)(row.MengeGesamtflacheValue ?? 0);
nhScope.Session.Update(netzSummarisch);
}
}
}
public void AngenommenDieFolgendenStrassenabschnitteExistieren(Table table)
{
var reader = GetObjectReaderConfigurationFor <Strassenabschnitt>()
.PropertyAliasFor(e => e.ErfassungsPeriod, "Jahr")
.ConverterFor(e => e.Belastungskategorie, (s, p) => ScenarioContextWrapper.CurrentScope.Session.Query <Belastungskategorie>().ToArray().Single(i => i.Typ == s))
.ConverterFor(e => e.Mandant, (s, p) => new Mandant()
{
MandantName = s
})
.ConverterFor(e => e.ErfassungsPeriod, (s, p) => new ErfassungsPeriod()
{
Erfassungsjahr = new DateTime(int.Parse(s), 1, 1)
});
using (var nhScope = new NHibernateSpecflowScope())
{
entitesProErfassungsmodus[NetzErfassungsmodus.Tabellarisch][typeof(Strassenabschnitt)] = reader.GetObjectReader().GetObjectList <Strassenabschnitt>(table);
}
}
public void DannSindFolgendeSummarischeZustandsUndNetzinformationenImSystem(Table table)
{
using (var nhScope = new NHibernateSpecflowScope())
{
var row = table.CreateSet <NetzSummarischRow>().Single();
var netzSummarischen = nhScope.Session.Query <NetzSummarischDetail>();
if (row.Belastungskategorie.IsNotNullOrEmpty())
{
netzSummarischen = netzSummarischen.Where(ns => ns.Belastungskategorie.Id == GetBelastungskategorieIdByTyp(row.Belastungskategorie));
}
if (row.MittlererZustand.IsNotNullOrEmpty())
{
netzSummarischen = netzSummarischen.Where(ns => ns.MittlererZustand == row.MittlererZustandValue);
}
if (row.MengeGesamtlänge.IsNotNullOrEmpty())
{
netzSummarischen = netzSummarischen.Where(ns => ns.Fahrbahnlaenge == row.MengeGesamtlangeValue);
}
if (row.MengeGesamtfläche.IsNotNullOrEmpty())
{
netzSummarischen = netzSummarischen.Where(ns => ns.Fahrbahnflaeche == row.MengeGesamtflacheValue);
}
int count;
if (row.Mandant.IsNotNullOrEmpty())
{
count = netzSummarischen.ToList().Count(ns => ns.Mandant.MandantName == row.Mandant);
}
else
{
count = netzSummarischen.Count();
}
Assert.AreEqual(1, count);
}
}
public void DannSindFolgendeMittlereAlterImSystem(Table table)
{
if (HasFieldValidationError())
{
return;
}
var row = table.CreateSet <MittleresAlterRow>().Single();
using (var nh = new NHibernateSpecflowScope())
{
var mittleresErhebungsjahr = nh.Session.Query <NetzSummarisch>().Single();
if (!string.IsNullOrEmpty(row.Mandant))
{
Assert.AreEqual(row.Mandant, mittleresErhebungsjahr.Mandant.MandantName);
}
Assert.AreEqual(row.MittleresAlterValue, mittleresErhebungsjahr.MittleresErhebungsJahr);
}
}
public void AngenommenFurMandantExistierenFolgendeNetzinformationen(string mandant, Table table)
{
using (NHibernateSpecflowScope scope = new NHibernateSpecflowScope())
{
var strassenabschnittReader = GetStrassenabschnittGISReader();
var strassenabschnitten = strassenabschnittReader.GetObjectList <StrassenabschnittGIS>(table);
ErfassungsPeriod currentErfassungsperiod = scope.GetCurrentErfassungsperiod(mandant);
var achse = new Achse
{
VersionValidFrom = DateTime.Now,
ErfassungsPeriod = currentErfassungsperiod
};
var segment = new AchsenSegment();
segment.Achse = achse;
segment.ErfassungsPeriod = currentErfassungsperiod;
achse.AchsenSegmente.Add(segment);
scope.Session.Save(segment);
scope.Session.Save(achse);
foreach (var strassenabschnitt in strassenabschnitten)
{
strassenabschnitt.Mandant = scope.GetMandant(mandant);
strassenabschnitt.ErfassungsPeriod = currentErfassungsperiod;
var achsenReferenz = new AchsenReferenz();
achsenReferenz.AchsenSegment = segment;
segment.AchsenReferenzen.Add(achsenReferenz);
scope.Session.Save(achsenReferenz);
var referenzGruppe = new ReferenzGruppe();
strassenabschnitt.ReferenzGruppe = referenzGruppe;
referenzGruppe.StrassenabschnittGISList.Add(strassenabschnitt);
achsenReferenz.ReferenzGruppe = referenzGruppe;
referenzGruppe.AchsenReferenzen.Add(achsenReferenz);
scope.Session.Save(referenzGruppe);
scope.Session.Save(strassenabschnitt);
}
}
}
public void AngenommenDieFolgendenDetailsZumNetzSummarischExistieren(Table table)
{
var reader = GetObjectReaderConfigurationFor <NetzSummarischDetail>()
.PropertyAliasFor(e => e.ErfassungsPeriod, "Jahr")
.PropertyAliasFor(e => e.NetzSummarisch, "MittleresErhebungsJahr")
.ConverterFor(e => e.ErfassungsPeriod, (s, p) => new ErfassungsPeriod())
.ConverterFor(e => e.Belastungskategorie, (s, p) => new Belastungskategorie())
.ConverterFor(e => e.Mandant, (s, p) => new Mandant())
.ConverterFor(e => e.NetzSummarisch, (s, p) => new NetzSummarisch()
{
MittleresErhebungsJahr = string.IsNullOrEmpty(s) ? (DateTime?)null : DateTime.Parse(s)
});
foreach (var item in reader.GetObjectReader().GetObjectListWithRow <NetzSummarischDetail>(table)
.GroupBy(i => new { Year = int.Parse(i.Item1["Jahr"]), Madndat = i.Item1["Mandant"] }))
{
Guid mandantId;
using (var nhScope = new NHibernateSpecflowScope())
{
var main =
nhScope.Session.Query <NetzSummarisch>().Single(
e => e.Mandant.MandantName == item.Key.Madndat && !e.ErfassungsPeriod.IsClosed);
mandantId = main.Mandant.Id;
main.MittleresErhebungsJahr = item.First().Item2.NetzSummarisch != null?item.First().Item2.NetzSummarisch.MittleresErhebungsJahr : null;
main.NetzSummarischDetails.Clear();
foreach (var d in item)
{
d.Item2.Belastungskategorie = nhScope.Session.Query <Belastungskategorie>().ToArray().Single(i => i.Typ == d.Item1["Belastungskategorie"]);
d.Item2.NetzSummarisch = main;
main.NetzSummarischDetails.Add(d.Item2);
nhScope.Session.Save(d.Item2);
}
}
CloseYear(item.Key.Year, mandantId);
}
}
private void LoadRealisierteMassnahmeEntities <TEnitity>(Table table, NetzErfassungsmodus erfassungsmodus)
where TEnitity : IErfassungsPeriodDependentEntity, IFlaecheFahrbahnUndTrottoirHolder, IRealisierteMassnahmeKostenHolder, IBelastungskategorieHolder, new()
{
var reader = GetObjectReaderConfigurationFor <TEnitity>()
.PropertyAliasFor(e => e.ErfassungsPeriod, "Jahr")
.ConverterFor(e => e.Belastungskategorie,
(s, p) =>
ScenarioContextWrapper.CurrentScope.Session.Query <Belastungskategorie>().ToArray().Single(
i => i.Typ == s))
.ConverterFor(e => e.Mandant, (s, p) => new Mandant()
{
MandantName = s
})
.ConverterFor(e => e.ErfassungsPeriod,
(s, p) => new ErfassungsPeriod()
{
Erfassungsjahr = new DateTime(int.Parse(s), 1, 1), NetzErfassungsmodus = erfassungsmodus
});
using (var nhScope = new NHibernateSpecflowScope())
{
entitesProErfassungsmodus[erfassungsmodus][typeof(TEnitity)] = (IEnumerable <IErfassungsPeriodDependentEntity>)reader.GetObjectReader().GetObjectList <TEnitity>(table);
}
}
private Guid GetBelastungskategorieIdByTyp(string belastungskategorieTyp)
{
using (var nhScope = new NHibernateSpecflowScope()) { return(nhScope.GetBelastungskategorie(belastungskategorieTyp).Id); }
}
