Beispiel #1
0
        protected override List <MassnahmenvorschlagProZustandsabschnittPo> GetPresentationObjectListForGis(MassnahmenvorschlagProZustandsabschnittParameter parameter)
        {
            ZustandsabschnittGIS za = null;
            StrassenabschnittGIS sa = null;
            var joinAlias           = transactionScopeProvider.CurrentTransactionScope.Session.QueryOver(() => za).JoinAlias(() => za.StrassenabschnittGIS, () => sa);
            var queryOver           = filtererFactory.CreateFilterer <ZustandsabschnittGIS>(parameter).Filter(joinAlias)
                                      .Where(z => z.MassnahmenvorschlagFahrbahn != null || z.MassnahmenvorschlagTrottoirLinks != null || z.MassnahmenvorschlagTrottoirRechts != null);

            if (ErfassungsPeriodService.GetCurrentErfassungsPeriod().NetzErfassungsmodus == NetzErfassungsmodus.Gis)
            {
                queryOver = massnahmenvorschlagProZustandsabschnittMapProvider.FilterForBoundingBox(queryOver, parameter);
            }

            var fetchedQueryOver = queryOver
                                   .Fetch(z => z.StrassenabschnittGIS).Eager
                                   .Fetch(z => z.MassnahmenvorschlagFahrbahn).Eager
                                   .Fetch(z => z.MassnahmenvorschlagTrottoirLinks).Eager
                                   .Fetch(z => z.MassnahmenvorschlagTrottoirRechts).Eager;

            return(fetchedQueryOver.List <ZustandsabschnittGIS>().Select(CreatePo)
                   .OrderBy(z => z.Strassenname)
                   .ThenBy(z => z.Strassenabschnittsnummer)
                   .ThenBy(z => z.StrasseBezeichnungVon)
                   .ThenBy(z => z.Abschnittsnummer)
                   .ThenBy(z => z.BezeichnungVon)
                   .ToList());
        }
Beispiel #2
0
        protected override List <StrassenabschnitteListePo> GetPresentationObjectListForGis(StrassenabschnitteListeParameter parameter)
        {
            var queryOver = filtererFactory.CreateFilterer <StrassenabschnittGIS>(parameter).Filter(transactionScopeProvider.QueryOver <StrassenabschnittGIS>());

            if (ErfassungsPeriodService.GetCurrentErfassungsPeriod().NetzErfassungsmodus == NetzErfassungsmodus.Gis)
            {
                queryOver = strassenabschnitteListeMapProvider.FilterForBoundingBox(queryOver, parameter);
            }

            return(queryOver.Fetch(s => s.Belastungskategorie).Eager.List <StrassenabschnittGIS>().OrderBy(s => s.Strassenname).Select(CreatePo).ToList());
        }
        private void CalculatePosForErfassungsPeriod <TZustandsabschnittBase, TStrassenabschnittBase>(TZustandsabschnittBase[] zustandsabschnittList, JahresInterval jahresInterval, ErfassungsPeriod erfassungsPeriod)
            where TStrassenabschnittBase : StrassenabschnittBase
            where TZustandsabschnittBase : ZustandsabschnittBase
        {
            var zustandsspiegelProJahrGrafischeDiagramPos = Enum.GetValues(typeof(ZustandsindexTyp))
                                                            .OfType <ZustandsindexTyp>()
                                                            .Where(z => z != ZustandsindexTyp.Unbekannt)
                                                            .Select(z => CreateDiagramPo(z, jahresInterval))
                                                            .ToDictionary(po => po.ZustandsindexTyp, po => po);

            decimal totalUnknowZustandsindexTypFlaeche = 0;

            decimal mittlereZustandsindexWithFlaeche = 0;
            decimal mittlererAufnahmedatumTickMultipliedWithFlaeche = 0;

            foreach (var zustandsabschnitt in zustandsabschnittList)
            {
                var zustandsindexTyp = ZustandsindexCalculator.GetTyp(zustandsabschnitt.Zustandsindex);
                zustandsspiegelProJahrGrafischeDiagramPos[zustandsindexTyp].FlaecheFahrbahn += (zustandsabschnitt.FlaecheFahrbahn ?? 0);
                mittlereZustandsindexWithFlaeche += zustandsabschnitt.Zustandsindex * (zustandsabschnitt.FlaecheFahrbahn ?? 0);

                mittlererAufnahmedatumTickMultipliedWithFlaeche += zustandsabschnitt.Aufnahmedatum.Ticks * (zustandsabschnitt.FlaecheFahrbahn ?? 0);
            }

            var currentJahr = ErfassungsPeriodService.GetCurrentErfassungsPeriod().Erfassungsjahr.Year;

            diagramPos[jahresInterval.JahrBis] = zustandsspiegelProJahrGrafischeDiagramPos.Values.ToList();

            var totalKnownZustandsindexTypFlaeche = zustandsspiegelProJahrGrafischeDiagramPos.Values.Sum(po => po.FlaecheFahrbahn);
            var totalFlaeche = totalKnownZustandsindexTypFlaeche + totalUnknowZustandsindexTypFlaeche;

            var totalStrasseFlaeche = transactionScopeProvider.Queryable <TStrassenabschnittBase>()
                                      .Where(z => z.ErfassungsPeriod == erfassungsPeriod)
                                      .Sum(g => g.Laenge * g.BreiteFahrbahn);

            var zustandsspiegelProJahrGrafischeTablePos = zustandsspiegelProJahrGrafischeDiagramPos.Values
                                                          .Select(po => CreateTablePo(jahresInterval, GetPerzent(po.FlaecheFahrbahn, totalKnownZustandsindexTypFlaeche), FormatHelper.ToReportNoDecimalPercentString, LocalizationService.GetLocalizedEnum(po.ZustandsindexTyp), (int)po.ZustandsindexTyp, currentJahr, po.ZustandsindexTyp));

            tablePos[jahresInterval.JahrBis] = zustandsspiegelProJahrGrafischeTablePos.ToList();

            PercentPartitioningCorrector.Corrigate(tablePos[jahresInterval.JahrBis].Cast <IPercentHolder>().ToList());

            var mittlererAufnahmedatum = (mittlererAufnahmedatumTickMultipliedWithFlaeche == 0 || totalFlaeche == 0) ? (decimal?)null : (decimal.Divide(mittlererAufnahmedatumTickMultipliedWithFlaeche, totalFlaeche));

            tablePos[jahresInterval.JahrBis].Add(CreateTablePo(jahresInterval, mittlererAufnahmedatum, d => FormatHelper.ToReportDateTimeString(d, "-"), reportLocalizationService.MittleresAlterDerZustandsaufnahmen, -10, currentJahr));

            var netzAnteil = GetPerzent(totalKnownZustandsindexTypFlaeche, totalStrasseFlaeche);

            tablePos[jahresInterval.JahrBis].Add(CreateTablePo(jahresInterval, netzAnteil, FormatHelper.ToReportNoDecimalPercentString, reportLocalizationService.NetzAnteil, -20, currentJahr));

            var mittlererZustandsindex = (mittlereZustandsindexWithFlaeche == 0 || totalFlaeche == 0) ? 0 : decimal.Divide(mittlereZustandsindexWithFlaeche, totalFlaeche);

            tablePos[jahresInterval.JahrBis].Add(CreateTablePo(jahresInterval, mittlererZustandsindex, FormatHelper.ToReportDecimalString, reportLocalizationService.MittlererZustandsindex, -30, currentJahr));
        }
        private void CalculateTablePos(JahresInterval jahresInterval,
                                       RealisiertenMassnahmenWertverlustZustandsindexProJahrGrafischeDiagramPo diagramPo)
        {
            var currentJahr = ErfassungsPeriodService.GetCurrentErfassungsPeriod().Erfassungsjahr.Year;

            tablePos[jahresInterval.JahrBis].Add(new TablePo
            {
                CurrentJahr  = currentJahr,
                AktualString = LocalizationService.GetLocalizedText("CurrentShort"),
                JahrVon      = jahresInterval.JahrVon,
                JahrBis      = jahresInterval.JahrBis,
                Value        = diagramPo.RealisierteMassnahmen,
                Bezeichnung  = reportLocalizationService.RealisiertenMassnahmen,
                FormatString = FormatStrings.ReportNoDecimalFormat,
                ColorCode    = "#800080",
                LegendUrl    = reportLegendImageService.GetLegendUrl("RM"),
                SortOrder    = 10
            });


            tablePos[jahresInterval.JahrBis].Add(new TablePo
            {
                CurrentJahr  = currentJahr,
                AktualString = LocalizationService.GetLocalizedText("CurrentShort"),
                JahrVon      = jahresInterval.JahrVon,
                JahrBis      = jahresInterval.JahrBis,
                Value        = diagramPo.WertVerlust,
                Bezeichnung  = reportLocalizationService.WV,
                FormatString = FormatStrings.ReportNoDecimalFormat,
                ColorCode    = "#6495ED",
                LegendUrl    = reportLegendImageService.GetLegendUrl("RWV"),
                SortOrder    = 10
            });

            tablePos[jahresInterval.JahrBis].Add(new TablePo
            {
                CurrentJahr  = currentJahr,
                AktualString = LocalizationService.GetLocalizedText("CurrentShort"),
                JahrVon      = jahresInterval.JahrVon,
                JahrBis      = jahresInterval.JahrBis,
                Value        = diagramPo.MittlererZustandindex,
                Bezeichnung  = reportLocalizationService.MittlererZustandsindex,
                ColorCode    = "#FF0000",
                FormatString = FormatStrings.ReportShortDecimalFormat,
                LegendUrl    = reportLegendImageService.GetLegendUrl("Mittlerer"),
                SortOrder    = 20
            });
        }
        protected NetzErfassungsmodus GetNetzErfassungsmodus(TReportParameter parameter)
        {
            NetzErfassungsmodus erfassungsmodus;

            if (parameter.ErfassungsPeriodId.HasValue)
            {
                erfassungsmodus = ErfassungsPeriodService.GetEntityById(parameter.ErfassungsPeriodId.Value).NetzErfassungsmodus;
            }
            else
            {
                var currentErfassungsPeriod = ErfassungsPeriodService.GetCurrentErfassungsPeriod();
                erfassungsmodus = currentErfassungsPeriod.NetzErfassungsmodus;
                parameter.ErfassungsPeriodId = parameter.ErfassungsPeriodId ?? currentErfassungsPeriod.Id;
            }

            return(erfassungsmodus);
        }
Beispiel #6
0
        protected override List <ZustandProZustandsabschnittPo> GetPresentationObjectListForGis(ZustandProZustandsabschnittParameter parameter)
        {
            ZustandsabschnittGIS za = null;
            StrassenabschnittGIS sa = null;
            var joinAlias           = transactionScopeProvider.CurrentTransactionScope.Session.QueryOver(() => za).JoinAlias(() => za.StrassenabschnittGIS, () => sa);
            var queryOver           = filtererFactory.CreateFilterer <ZustandsabschnittGIS>(parameter).Filter(joinAlias);

            if (ErfassungsPeriodService.GetCurrentErfassungsPeriod().NetzErfassungsmodus == NetzErfassungsmodus.Gis)
            {
                queryOver = zustandProZustandsabschnittMapProvider.FilterForBoundingBox(queryOver, parameter);
            }

            return(queryOver.Fetch(z => z.StrassenabschnittGIS).Eager.Fetch(z => z.StrassenabschnittGIS.Belastungskategorie).Eager.List <ZustandsabschnittGIS>().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 CalculatePosForJahr <T>(ErfassungsPeriod erfassungsPeriod, List <T> entityList, JahresInterval jahresInterval,
                                             Func <T, WiederbeschaffungswertKatalogModel, decimal> getWiederBeschaffungswert,
                                             Func <T, Belastungskategorie> getBelastungskategorie,
                                             Func <T, decimal> getFlaeche)
        {
            if (!diagramPos.ContainsKey(jahresInterval.JahrBis))
            {
                diagramPos[jahresInterval.JahrBis] = new List <DiagramPo>();
            }
            if (!tablePos.ContainsKey(jahresInterval.JahrBis))
            {
                tablePos[jahresInterval.JahrBis] = new List <TablePo>();
            }

            var wiederbeschaffungswertUndWertverlustProJahrGrafischeDiagramPos = GetWiederbeschaffungswertUndWertverlustProJahrGrafischeDiagramPos(jahresInterval);

            foreach (var netzSummarischDetail in entityList)
            {
                var belastungskategorie = getBelastungskategorie(netzSummarischDetail);
                var wieder = wiederbeschaffungswertKatalogService.GetWiederbeschaffungswertKatalogModel(belastungskategorie, erfassungsPeriod);
                var wiederbeschaffungswert = getWiederBeschaffungswert(netzSummarischDetail, wieder);

                var diagramPo = wiederbeschaffungswertUndWertverlustProJahrGrafischeDiagramPos[belastungskategorie.Id];
                //Note: divided by 1 000 (1000m2)
                diagramPo.FlaecheFahrbahn += getFlaeche(netzSummarischDetail) / 1000m;
                //Note: divided by 1 000 000 (Mio. CHF) infro from sample excel
                diagramPo.WiederBeschaffungsWert += wiederbeschaffungswert / 1000000m;
                //Note: divided by 1 000 (kCHF)
                diagramPo.WertVerlust += (wiederbeschaffungswert * wieder.AlterungsbeiwertII / 100) / 1000;
            }

            diagramPos[jahresInterval.JahrBis].AddRange(wiederbeschaffungswertUndWertverlustProJahrGrafischeDiagramPos.Values);
            var currentJahr = ErfassungsPeriodService.GetCurrentErfassungsPeriod().Erfassungsjahr.Year;
            var wiederbeschaffungswertUndWertverlustProJahrGrafischeTablePos
                = wiederbeschaffungswertUndWertverlustProJahrGrafischeDiagramPos.Values
                  .Select(po => new TablePo
            {
                CurrentJahr  = currentJahr,
                AktualString = LocalizationService.GetLocalizedText("CurrentShort"),
                JahrVon      = jahresInterval.JahrVon,
                JahrBis      = jahresInterval.JahrBis,
                Value        = po.FlaecheFahrbahn,
                Bezeichnung  = po.BelastungskategorieBezeichnung + " " + reportLocalizationService.TausendQuadratMeter,
                ColorCode    = po.ColorCode,
                LegendUrl    = reportLegendImageService.GetLegendUrl(po.BelastungskategorieTyp),
                SortOrder    = belastungskategorieService.AlleBelastungskategorie.IndexOf(belastungskategorieService.AlleBelastungskategorie.Single(bk => bk.Id == po.BelastungskategorieId))
            });

            tablePos[jahresInterval.JahrBis].AddRange(wiederbeschaffungswertUndWertverlustProJahrGrafischeTablePos);

            tablePos[jahresInterval.JahrBis].Add(new TablePo
            {
                CurrentJahr  = currentJahr,
                AktualString = LocalizationService.GetLocalizedText("CurrentShort"),
                JahrVon      = jahresInterval.JahrVon,
                JahrBis      = jahresInterval.JahrBis,
                Value        = wiederbeschaffungswertUndWertverlustProJahrGrafischeDiagramPos.Values.Sum(po => po.FlaecheFahrbahn),
                Bezeichnung  = reportLocalizationService.GesamtFlaeche,
                SortOrder    = 10
            });

            tablePos[jahresInterval.JahrBis].Add(new TablePo
            {
                CurrentJahr  = currentJahr,
                AktualString = LocalizationService.GetLocalizedText("CurrentShort"),
                JahrVon      = jahresInterval.JahrVon,
                JahrBis      = jahresInterval.JahrBis,
                Value        = wiederbeschaffungswertUndWertverlustProJahrGrafischeDiagramPos.Values.Sum(po => po.WertVerlust),
                Bezeichnung  = reportLocalizationService.WV,
                ColorCode    = "#8b0000",
                LegendUrl    = reportLegendImageService.GetLegendUrl("WV"),
                SortOrder    = 20
            });

            tablePos[jahresInterval.JahrBis].Add(new TablePo
            {
                CurrentJahr  = currentJahr,
                AktualString = LocalizationService.GetLocalizedText("CurrentShort"),
                JahrVon      = jahresInterval.JahrVon,
                JahrBis      = jahresInterval.JahrBis,
                Value        = wiederbeschaffungswertUndWertverlustProJahrGrafischeDiagramPos.Values.Sum(po => po.WiederBeschaffungsWert),
                Bezeichnung  = reportLocalizationService.WBW,
                LegendUrl    = reportLegendImageService.GetLegendUrl("WBW"),
                ColorCode    = "#cd48ff",
                SortOrder    = 30
            });
        }
        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");
                }
            }
        }
        private void CalculatePos(RealisiertenMassnahmenWertverlustZustandsindexProJahrGrafischeParameter 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;
                    }
                    CalculatePosForSummarischeModus(erfassungsPeriod, jahresInterval);
                    break;

                case NetzErfassungsmodus.Tabellarisch:
                    CalculatePosForStrassenModus(erfassungsPeriod, parameter, jahresInterval);
                    break;

                case NetzErfassungsmodus.Gis:
                    CalculatePosForStrassenModusGIS(erfassungsPeriod, parameter, jahresInterval);
                    break;

                default:
                    throw new ArgumentOutOfRangeException("NetzErfassungsmodus");
                }
            }
        }