public List <BenchmarkingData> GetForMandantList(DateTime jahrDateTime, IList <Mandant> mandants)
{
var mandantIds = mandants.Select(m => m.Id).ToArray();
var q = transactionScopeProvider.Queryable <MandantDetails>()
.OrderBy(b => b.Id)
.Where(d => d.ErfassungsPeriod.Erfassungsjahr.Year == jahrDateTime.Year && mandantIds.Contains(d.Mandant.Id));
var result = ForMandantList(q);
result.AddRange(kenngroessenFruehererJahreBenchmarkingDataService.GetForMandantList(jahrDateTime, mandants));
return(result);
}
public bool HasInspektionsRouteGISJustUniqueStraasenabschnitten(InspektionsRouteGISModel inspektionsRouteGISModel, IList <InspektionsRtStrAbschnitteModel> inspektionsRtStrAbschnitteModelList)
{
var inspektionsRouteGIS = GetEntityById <InspektionsRouteGIS>(inspektionsRouteGISModel.Id);
List <Guid> irsList = inspektionsRtStrAbschnitteModelList.Select(irsa => irsa.StrassenabschnittId).ToList();
if (inspektionsRouteGIS != null)
{
return(!transactionScopeProvider.Queryable <InspektionsRouteGIS>()
.Any(ir => ir.Id != inspektionsRouteGIS.Id && ir.InspektionsRtStrAbschnitteList.Any(irsa => irsList.Contains(irsa.StrassenabschnittGIS.Id))));
}
return(!transactionScopeProvider.Queryable <InspektionsRouteGIS>()
.Any(ir => ir.InspektionsRtStrAbschnitteList.Any(irsa => irsList.Contains(irsa.StrassenabschnittGIS.Id))));
}
protected override List <StrassenabschnitteListeOhneInspektionsroutePo> GetPresentationObjectListForGis(StrassenabschnitteListeOhneInspektionsrouteParameter parameter)
{
var queryable = transactionScopeProvider.Queryable <StrassenabschnittGIS>().Where(sa => !sa.InspektionsRtStrAbschnitte.Any());
queryable = filtererFactory.CreateFilterer <StrassenabschnittGIS>(parameter).Filter(queryable);
return(queryable.OrderBy(s => s.Strassenname).Fetch(s => s.Belastungskategorie).Select(CreatePo).ToList());
}
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 List <Models.Reports.AusgefuellteErfassungsformulareFuerOberflaechenschaeden> GetPreviewModels(AusgefuellteErfassungsformulareFuerOberflaechenschaedenParameter parameter, IPresentationObjectProcessor <Models.Reports.AusgefuellteErfassungsformulareFuerOberflaechenschaeden> presentationObjectProcessor)
{
if (AvailableInCurrentErfassungPeriod || parameter.ErfassungsPeriodId != null)
{
var erfassungsmodus = GetNetzErfassungsmodus(parameter);
switch (erfassungsmodus)
{
case NetzErfassungsmodus.Summarisch:
return(new List <Models.Reports.AusgefuellteErfassungsformulareFuerOberflaechenschaeden>());
case NetzErfassungsmodus.Tabellarisch:
return(GetZustandsabschnitten(parameter).Fetch(za => za.Strassenabschnitt)
.Select(entityServiceMappingEngine.Translate <Zustandsabschnitt, Models.Reports.AusgefuellteErfassungsformulareFuerOberflaechenschaeden>).ToList());
case NetzErfassungsmodus.Gis:
var erfassungPeriod = GetErfassungsPeriod(parameter);
//NOTE: Manually Fetch because a random OracleClient memory access exception
var routeGis = scopeProvider.Queryable <InspektionsRouteGIS>().Where(e => e.ErfassungsPeriod == erfassungPeriod).ToList();
return(GetZustandsabschnittenGIS(parameter)
.Fetch(za => za.StrassenabschnittGIS)
.ThenFetchMany(sa => sa.InspektionsRtStrAbschnitte) //.ThenFetch(irsa => irsa.InspektionsRouteGIS)
.Select(entityServiceMappingEngine.Translate <ZustandsabschnittGIS, Models.Reports.AusgefuellteErfassungsformulareFuerOberflaechenschaeden>).ToList());
default:
throw new ArgumentOutOfRangeException();
}
}
return(new List <Models.Reports.AusgefuellteErfassungsformulareFuerOberflaechenschaeden>());
}
private void CalculatePos(Parameter parameter)
{
List <ErfassungsPeriod> erfassungsPeriodList = ErfassungsPeriodService.GetErfassungsPeriods(parameter.ErfassungsPeriodIdVon, parameter.ErfassungsPeriodIdBis).ToList();
for (int i = 0; i < erfassungsPeriodList.Count; i++)
{
var erfassungsPeriod = erfassungsPeriodList[i];
var jahresInterval = jahresIntervalService.CalculateFromErfassungsPeriodList(erfassungsPeriod, erfassungsPeriodList);
switch (erfassungsPeriod.NetzErfassungsmodus)
{
case NetzErfassungsmodus.Summarisch:
continue;
case NetzErfassungsmodus.Tabellarisch:
var zustandsabschnittList = filtererFactory
.CreateFilterer <Zustandsabschnitt>(parameter)
.Filter(transactionScopeProvider.Queryable <Zustandsabschnitt>().Where(za => za.Strassenabschnitt.ErfassungsPeriod == erfassungsPeriod))
.Fetch(s => s.Strassenabschnitt)
.ToArray();
CalculatePosForErfassungsPeriod <Zustandsabschnitt, Strassenabschnitt>(zustandsabschnittList, jahresInterval, erfassungsPeriod);
break;
case NetzErfassungsmodus.Gis:
var zustandsabschnittGisList = filtererFactory
.CreateFilterer <ZustandsabschnittGIS>(parameter)
.Filter(transactionScopeProvider.Queryable <ZustandsabschnittGIS>().Where(za => za.StrassenabschnittGIS.ErfassungsPeriod == erfassungsPeriod))
.Fetch(s => s.StrassenabschnittGIS)
.ToArray();
CalculatePosForErfassungsPeriod <ZustandsabschnittGIS, StrassenabschnittGIS>(zustandsabschnittGisList, jahresInterval, erfassungsPeriod);
break;
default:
throw new ArgumentOutOfRangeException("NetzErfassungsmodus");
}
}
}
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(),
});
}
protected override List <MassnahmenvorschlagProZustandsabschnittPo> GetPresentationObjectListForTabellarisch(MassnahmenvorschlagProZustandsabschnittParameter parameter)
{
var queryable = filtererFactory.CreateFilterer <Zustandsabschnitt>(parameter)
.Filter(transactionScopeProvider.Queryable <Zustandsabschnitt>())
.Where(z => z.MassnahmenvorschlagFahrbahn != null || z.MassnahmenvorschlagTrottoirLinks != null || z.MassnahmenvorschlagTrottoirRechts != null);
var fetchedQuery = queryable
.Fetch(z => z.Strassenabschnitt)
.Fetch(z => z.MassnahmenvorschlagFahrbahn)
.Fetch(z => z.MassnahmenvorschlagTrottoirLinks)
.Fetch(z => z.MassnahmenvorschlagTrottoirRechts);
return(fetchedQuery.ToList().Select(CreatePo)
.OrderBy(z => z.Strassenname)
.ThenBy(z => z.Strassenabschnittsnummer)
.ThenBy(z => z.StrasseBezeichnungVon)
.ThenBy(z => z.Abschnittsnummer)
.ThenBy(z => z.BezeichnungVon)
.ToList());
}
private void CalculatePosForStrassenModus(ErfassungsPeriod erfassungsPeriod, RealisiertenMassnahmenWertverlustZustandsindexProJahrGrafischeParameter parameter, JahresInterval jahresInterval)
{
var strassenabschnittList = filtererFactory
.CreateFilterer <Strassenabschnitt>(parameter)
.Filter(transactionScopeProvider.Queryable <Strassenabschnitt>()
.Where(e => e.ErfassungsPeriod == erfassungsPeriod))
.Fetch(sa => sa.Belastungskategorie)
.FetchMany(sa => sa.Zustandsabschnitten)
.ToList();
var diagramPo = new RealisiertenMassnahmenWertverlustZustandsindexProJahrGrafischeDiagramPo()
{
JahrVon = jahresInterval.JahrVon,
JahrBis = jahresInterval.JahrBis,
WertVerlust = strassenabschnittList.Sum(d => (GetWiederbeschaffungswert(d, wiederbeschaffungswertKatalogService.GetWiederbeschaffungswertKatalogModel(d.Belastungskategorie, erfassungsPeriod)) * wiederbeschaffungswertKatalogService.GetWiederbeschaffungswertKatalogModel(d.Belastungskategorie, erfassungsPeriod).AlterungsbeiwertII / 100) / 1000m),
MittlererZustandindex = SafeDevide(strassenabschnittList.SelectMany(s => s.Zustandsabschnitten).Sum(d => (d.FlaecheFahrbahn ?? 0) * d.Zustandsindex), strassenabschnittList.SelectMany(s => s.Zustandsabschnitten).Sum(z => z.FlaecheFahrbahn) ?? 0m),
RealisierteMassnahmen = (transactionScopeProvider.Queryable <RealisierteMassnahme>().Where(r => r.ErfassungsPeriod == erfassungsPeriod).ToArray().Sum(s => (s.KostenFahrbahn ?? 0) + (s.KostenTrottoirLinks ?? 0) + (s.KostenTrottoirRechts ?? 0))) / 1000m
};
EnsureJahrInPoLists(jahresInterval);
diagramPos[jahresInterval.JahrBis].Add(diagramPo);
CalculateTablePos(jahresInterval, diagramPo);
}
public bool IsUserExists(string username)
{
return(transactionScopeProvider.Queryable <TestUserInfo>().Any(tui => tui.UserName == username));
}
private FeatureWithID getFeatureWithId(IAbschnittGISBase entity)
{
List <AchsenReferenz> achsenreferenzListe = achsenReferenzService.GetAchsenReferenzGruppe(entity.ReferenzGruppe.Id);
//create geojson
List <FeatureWithID> featuresListChilds = new List <FeatureWithID>();
FeatureWithID feature = new FeatureWithID();
IAttributesTable attribute = new AttributesTable();
feature.Id = entity.Id.ToString();
feature.Geometry = entity.Shape;
//GEOJSON PROPERTIES: Childs (= Achsenreferenzen)
foreach (AchsenReferenz ar in achsenreferenzListe)
{
FeatureWithID feat = new FeatureWithID();
IAttributesTable attributes = new AttributesTable();
feat.Id = ar.Id.ToString();
feat.Geometry = ar.Shape;
attributes.AddAttribute(geoJSONAttribute_AchsenSegmentId, ar.AchsenSegment.Id);
attributes.AddAttribute(geoJSONAttribute_IsInverted, ar.AchsenSegment.IsInverted);
feat.Attributes = attributes;
featuresListChilds.Add(feat);
}
attribute.AddAttribute(geoJSONAttribute_childs, featuresListChilds);
if (entity is KoordinierteMassnahmeGIS)
{
attribute.AddAttribute("Name", ((KoordinierteMassnahmeGIS)entity).Projektname);
}
if (entity is MassnahmenvorschlagTeilsystemeGIS)
{
attribute.AddAttribute("Name", ((MassnahmenvorschlagTeilsystemeGIS)entity).Projektname);
attribute.AddAttribute("System", localizationService.GetLocalizedEnum <TeilsystemTyp>(((MassnahmenvorschlagTeilsystemeGIS)entity).Teilsystem));
}
//GEOJSON PROPERTIES: ZUSTANDSABSCHNITTE
if (entity is StrassenabschnittGIS)
{
List <FeatureWithID> featuresListZustandsabschnitte = new List <FeatureWithID>();
List <ZustandsabschnittGIS> zustandsabschnitte = transactionScopeProvider.Queryable <ZustandsabschnittGIS>().Where(za => za.StrassenabschnittGIS.Id == entity.Id).ToList();
foreach (ZustandsabschnittGIS zustandsabschnitt in zustandsabschnitte)
{
FeatureWithID feat = new FeatureWithID();
IAttributesTable att = new AttributesTable();
feat.Id = zustandsabschnitt.Id.ToString();
feat.Geometry = zustandsabschnitt.Shape;
feat.Attributes = att;
featuresListZustandsabschnitte.Add(feat);
}
var sa = entity as StrassenabschnittGIS;
attribute.AddAttribute(geoJSONAttribute_Zustandsabschnitte, featuresListZustandsabschnitte);
attribute.AddAttribute(geoJSONAttribute_IsLocked, sa.IsLocked);
if (sa.InspektionsRtStrAbschnitte.Count > 0)
{
attribute.AddAttribute(geoJSONAttribute_InspektionsrouteID, sa.InspektionsRtStrAbschnitte.SingleOrDefault().InspektionsRouteGIS.Id);
}
else
{
attribute.AddAttribute(geoJSONAttribute_InspektionsrouteID, "");
}
}
else
{
if (entity is ZustandsabschnittGIS)
{
attribute.AddAttribute(geoJSONAttribute_StrassenabschnittsID, ((ZustandsabschnittGIS)entity).StrassenabschnittGIS.Id);
var za = entity as ZustandsabschnittGIS;
attribute.AddAttribute(geoJSONAttribute_IsLocked, za.IsLocked);
}
}
feature.Attributes = attribute;
return(feature);
}
private IQueryable <KenngroessenFruehererJahre> GetKenngroessenFruehererJahres(DateTime jahrDateTime)
{
return(transactionScopeProvider.Queryable <KenngroessenFruehererJahre>().OrderBy(k => k.Id).Where(k => k.Jahr == jahrDateTime.Year));
}
protected List <TReportPo> CreatePoList(TReportParameter parameter)
{
var result = new List <TReportPo>();
erfassungPeriodVon = ErfassungsPeriodService.GetEntityById(parameter.ErfassungsPeriodIdVon);
erfassungPeriodBis = ErfassungsPeriodService.GetEntityById(parameter.ErfassungsPeriodIdBis);
var summarich = filtererFactory.CreateFilterer <RealisierteMassnahmeSummarsich>(parameter).Filter(transactionScopeProvider.Queryable <RealisierteMassnahmeSummarsich>());
var strassennamen = filtererFactory.CreateFilterer <RealisierteMassnahme>(parameter).Filter(transactionScopeProvider.Queryable <RealisierteMassnahme>());
var gis = filtererFactory.CreateFilterer <RealisierteMassnahmeGIS>(parameter).Filter(transactionScopeProvider.Queryable <RealisierteMassnahmeGIS>());
DateTime jahrVon = erfassungPeriodVon.Erfassungsjahr;
DateTime jahrBis = erfassungPeriodBis.Erfassungsjahr;
if (!erfassungPeriodBis.IsClosed)
{
DateTime notCurrentYear = jahrBis.AddYears(-1);
result.AddRange(CreatePoListFromRealisierteMassnahmeSummarsich(FilterByErfassungsPeriodVonBis(summarich, jahrVon, notCurrentYear)));
result.AddRange(CreatePoListFromRealisierteMassnahme(FilterByErfassungsPeriodVonBis(strassennamen, jahrVon, notCurrentYear)));
result.AddRange(CreatePoFromRealisierteMassnahmeGIS(FilterByErfassungsPeriodVonBis(gis, jahrVon, notCurrentYear)));
switch (erfassungPeriodBis.NetzErfassungsmodus)
{
case NetzErfassungsmodus.Summarisch:
result.AddRange(CreatePoListFromRealisierteMassnahmeSummarsich(summarich.Where(s => s.ErfassungsPeriod.Id == erfassungPeriodBis.Id)));
break;
case NetzErfassungsmodus.Tabellarisch:
result.AddRange(CreatePoListFromRealisierteMassnahme(strassennamen.Where(s => s.ErfassungsPeriod.Id == erfassungPeriodBis.Id)));
break;
case NetzErfassungsmodus.Gis:
result.AddRange(CreatePoFromRealisierteMassnahmeGIS(gis.Where(s => s.ErfassungsPeriod.Id == erfassungPeriodBis.Id)));
break;
default:
throw new ArgumentOutOfRangeException();
}
}
else
{
result.AddRange(CreatePoListFromRealisierteMassnahmeSummarsich(FilterByErfassungsPeriodVonBis(summarich, jahrVon, jahrBis)));
result.AddRange(CreatePoListFromRealisierteMassnahme(FilterByErfassungsPeriodVonBis(strassennamen, jahrVon, jahrBis)));
result.AddRange(CreatePoFromRealisierteMassnahmeGIS(FilterByErfassungsPeriodVonBis(gis, jahrVon, jahrBis)));
}
result = result.OrderByDescending(r => r.AusfuehrungsEnde).ThenBy(r => r.Projektname).ToList();
return(result);
}
private void CalculatePos(Parameter parameter)
{
int jahrVon = GetJahr(parameter.JahrIdVon);
int jahrBis = GetJahr(parameter.JahrIdBis);
var kenngroessenFruehererJahreList = kenngroessenFruehererJahreService.GetKenngroessenFruehererJahren(jahrVon, jahrBis);
var erfassungsPeriodList = ErfassungsPeriodService.GetErfassungsPeriods(jahrVon, jahrBis);
//If there is a Filter for not supported Field, Skip year
if (parameter.Eigentuemer == null)
{
for (int i = 0; i < kenngroessenFruehererJahreList.Count; i++)
{
var kenngroessenFruehererJahre = kenngroessenFruehererJahreList[i];
int erfassungsJahrVon = kenngroessenFruehererJahre.Jahr;
int erfassungsJahrBis;
if (kenngroessenFruehererJahre == kenngroessenFruehererJahreList.Last())
{
erfassungsJahrBis = erfassungsPeriodList.Any() ? erfassungsPeriodList.First().Erfassungsjahr.Year - 1 : erfassungsJahrVon;
}
else
{
erfassungsJahrBis = kenngroessenFruehererJahreList[i + 1].Jahr - 1;
}
CalculatePosForKenngroessenFruehererJahre(ErfassungsPeriodService.GetCurrentErfassungsPeriod(), kenngroessenFruehererJahre, new JahresInterval(erfassungsJahrVon, erfassungsJahrBis));
}
}
for (int i = 0; i < erfassungsPeriodList.Count; i++)
{
var erfassungsPeriod = erfassungsPeriodList[i];
var jahresInterval = jahresIntervalService.CalculateFromErfassungsPeriodList(erfassungsPeriod, erfassungsPeriodList);
switch (erfassungsPeriod.NetzErfassungsmodus)
{
case NetzErfassungsmodus.Summarisch:
//If there is a Filter for not supported Field, Skip year
if (parameter.Eigentuemer != null)
{
continue;
}
var netzSummarischDetailList = netzSummarischDetailService.GetEntitiesBy(erfassungsPeriod).Fetch(nsd => nsd.Belastungskategorie).ToList();
CalculatePosForSummarischeModus(erfassungsPeriod, netzSummarischDetailList, jahresInterval);
break;
case NetzErfassungsmodus.Tabellarisch:
var strassenabschnittList = transactionScopeProvider.Queryable <Strassenabschnitt>().Where(sa => sa.ErfassungsPeriod == erfassungsPeriod);
CalculatePosForStrassenModus(erfassungsPeriod, strassenabschnittList, parameter, jahresInterval);
break;
case NetzErfassungsmodus.Gis:
var strassenabschnittGisList = transactionScopeProvider.Queryable <StrassenabschnittGIS>().Where(sa => sa.ErfassungsPeriod == erfassungsPeriod);
CalculatePosForStrassenModus(erfassungsPeriod, strassenabschnittGisList, parameter, jahresInterval);
break;
default:
throw new ArgumentOutOfRangeException("NetzErfassungsmodus");
}
}
}
protected override List <ZustandProZustandsabschnittPo> GetPresentationObjectListForTabellarisch(ZustandProZustandsabschnittParameter parameter)
{
var queryable = filtererFactory.CreateFilterer <Zustandsabschnitt>(parameter).Filter(transactionScopeProvider.Queryable <Zustandsabschnitt>());
return(queryable.Fetch(z => z.Strassenabschnitt).ThenFetch(s => s.Belastungskategorie).ToList().Select(CreatePo)
.OrderBy(z => z.Strassenname)
.ThenBy(z => z.Strassenabschnittsnummer)
.ThenBy(z => z.StrasseBezeichnungVon)
.ThenBy(z => z.Abschnittsnummer)
.ThenBy(z => z.BezeichnungVon)
.ToList());
}
protected override List <StrassenabschnitteListePo> GetPresentationObjectListForTabellarisch(StrassenabschnitteListeParameter parameter)
{
var queryable = filtererFactory.CreateFilterer <Strassenabschnitt>(parameter).Filter(transactionScopeProvider.Queryable <Strassenabschnitt>());
return(queryable.OrderBy(s => s.Strassenname).ThenBy(s => s.Abschnittsnummer).Fetch(s => s.Belastungskategorie).Select(CreatePo).OrderBy(s => s.Strassenname).ToList());
}
private IQueryable <BenchmarkingData> GetBenchmarkingDatasFromMandant(DateTime jahrDateTime)
{
return(transactionScopeProvider.Queryable <BenchmarkingData>()
.OrderBy(b => b.Id)
.Where(d => d.ErfassungsPeriod.Erfassungsjahr.Year == jahrDateTime.Year));
}
private IQueryable <TEntity> FilterEntities <TEntity>(Parameter parameter)
where TEntity : class, IEntity
{
return(filtererFactory.CreateFilterer <TEntity>(parameter).Filter(transactionScopeProvider.Queryable <TEntity>()));
}