コード例 #1
0
 public void BeforeUpdateAchse(Achse targetAchse, KopieAchse kopieAchse)
 {
     if (!oldAxisValidFromDict.ContainsKey(targetAchse.BsId))
     {
         oldAxisValidFromDict.Add(targetAchse.BsId, targetAchse.VersionValidFrom);
     }
 }
コード例 #2
0
        private AchsenSegment findSegment(Achse achse, KopieAchsenSegment kopieSegment)
        {
            var list = achse.AchsenSegmente.Where(o => o.BsId == kopieSegment.Id);

            if (list.Count() == 0)
            {
                list = achsenCache.SelectMany(a => a.Value.AchsenSegmente).Where(s => s.BsId == kopieSegment.Id);
                if (!list.Any())
                {
                    return(null);
                }
            }

            return(list.First());
        }
コード例 #3
0
        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);
                }
            }
        }
コード例 #4
0
 protected override void OnEntityCreating(AchsenSegmentModel model, AchsenSegment entity)
 {
     if (entity.Achse == null)
     {
         //Create and save Dummy Achse
         Achse achse = new Achse();
         achse.VersionValidFrom = DateTime.Now;
         achse.Id               = Guid.NewGuid();
         achse.Name             = model.Name;
         achse.Mandant          = this.CurrentMandant;
         achse.ErfassungsPeriod = this.CurrentErfassungsPeriod;
         achse.AchsenSegmente.Add(entity);
         entity.Achse = achse;
         this.transactionScopeProvider.CurrentTransactionScope.Session.Save(achse);
         model.AchsenId = achse.Id;
     }
 }
コード例 #5
0
        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);
                }
            }
        }
コード例 #6
0
        public void Rotate(Achse a, float _degree)
        {
            float degree = (_degree / 360) * (float)Math.PI * 2;

            switch (a)
            {
            case Achse.X:
                RotationX *= new Matrix(
                    1, 0, 0, 0,
                    0, (float)Math.Cos(-degree), (float)-Math.Sin(-degree), 0,
                    0, (float)Math.Sin(-degree), (float)Math.Cos(-degree), 0,
                    0, 0, 0, 1);

                break;

            case Achse.Y:
                RotationY *= new Matrix(
                    (float)Math.Cos(-degree), 0, (float)Math.Sin(-degree), 0,
                    0, 1, 0, 0,
                    (float)-Math.Sin(-degree), 0, (float)Math.Cos(-degree), 0,
                    0, 0, 0, 1
                    );

                break;

            case Achse.Z:
                RotationZ *= new Matrix(
                    (float)Math.Cos(-degree), (float)-Math.Sin(-degree), 0, 0,
                    (float)Math.Sin(-degree), (float)Math.Cos(-degree), 0, 0,
                    0, 0, 1, 0,
                    0, 0, 0, 1
                    );

                break;
            }
        }
コード例 #7
0
        private AchsenSegment UpdateSegment(Achse achse, KopieAchse kopieAchse, KopieAchsenSegment kopieSegment, int operation)
        {
            if (kopieSegment.ImpNr <= lastImpNr)
            {
                return(null);
            }

            maxImpNr = Math.Max(maxImpNr, kopieSegment.ImpNr);

            switch (operation)
            {
            case AxisImportOperation.DELETE:
            {
                AchsenSegment segment =
                    findSegment(achse, kopieSegment);

                if (segment == null)
                {
                    return(null);
                }

                if (ReferenceUpdater != null)
                {
                    ReferenceUpdater.BeforeDeleteSegment(segment);
                }

                foreach (KopieSektor kopieSektor in kopieSegmentToSektorDict[kopieSegment])
                {
                    UpdateSektor(segment, kopieSektor, kopieSektor.Operation);
                }

                achse.AchsenSegmente.Remove(segment);
                session.Delete(segment);

                statistics.NumSegment.Deletes++;
                return(null);
            }

            case AxisImportOperation.UPDATE:
            {
                AchsenSegment segment =
                    findSegment(achse, kopieSegment);

                if (segment == null)
                {
                    return(UpdateSegment(achse, kopieAchse, kopieSegment, AxisImportOperation.INSERT));
                }

                if (ReferenceUpdater != null)
                {
                    ReferenceUpdater.BeforeUpdateSegment(segment, kopieAchse, kopieSegment);
                }

                segment         = gisKopieMappingEngine.Translate <KopieAchsenSegment, AchsenSegment>(kopieSegment, segment);
                segment.Shape4d = kopieSegment.Shape;

                if (segment.Mandant != mandant)
                {
                    throw new Exception("segment.Mandant != mandant");
                }

                foreach (KopieSektor kopieSektor in kopieSegmentToSektorDict[kopieSegment])
                {
                    UpdateSektor(segment, kopieSektor, kopieSektor.Operation);
                }

                statistics.NumSegment.Updates++;
                return(segment);
            }

            case AxisImportOperation.INSERT:
            {
                if (findSegment(achse, kopieSegment) != null)
                {
                    throw new Exception("Cannot insert: KopieSegment " + kopieSegment.Id + " already exists in AchsenSegment table!");
                }

                AchsenSegment segment = gisKopieMappingEngine.Translate <KopieAchsenSegment, AchsenSegment>(kopieSegment);
                segment.BsId = kopieSegment.Id;

                segment.Shape4d = kopieSegment.Shape;

                segment.Mandant          = mandant;
                segment.ErfassungsPeriod = erfassungsPeriod;

                segment.Achse = achse;
                achse.AchsenSegmente.Add(segment);

                foreach (KopieSektor kopieSektor in kopieSegmentToSektorDict[kopieSegment])
                {
                    UpdateSektor(segment, kopieSektor, kopieSektor.Operation);
                }

                if (ReferenceUpdater != null)
                {
                    ReferenceUpdater.AfterCreateSegment(segment);
                }

                statistics.NumSegment.Inserts++;
                return(segment);
            }
            }
            return(null);
        }
コード例 #8
0
        private Achse UpdateAchse(KopieAchse kopieAchse, int operation)
        {
            if (kopieAchse.ImpNr <= lastImpNr)
            {
                return(null);
            }

            maxImpNr = Math.Max(maxImpNr, kopieAchse.ImpNr);

            switch (operation)
            {
            case AxisImportOperation.DELETE:
            {
                Achse achse = lookupAchseByBSID(kopieAchse.Id);
                if (achse == null)
                {
                    Loggers.TechLogger.Warn(String.Format("AchsenUpdate Delete: Achse {0} not found", kopieAchse.Id));
                    return(null);
                }

                if (ReferenceUpdater != null)
                {
                    ReferenceUpdater.BeforeDeleteAchse(achse);
                }


                foreach (KopieAchsenSegment kopieSegment in kopieAchsenToSegmentDict[kopieAchse])
                {
                    UpdateSegment(achse, kopieAchse, kopieSegment, kopieSegment.Operation);
                }

                session.Delete(achse);

                statistics.NumAchsen.Deletes++;
                return(null);
            }

            case AxisImportOperation.UPDATE:
            {
                Achse achse = lookupAchseByBSID(kopieAchse.Id);
                if (achse == null)
                {
                    return(UpdateAchse(kopieAchse, AxisImportOperation.INSERT));
                }

                if (ReferenceUpdater != null)
                {
                    ReferenceUpdater.BeforeUpdateAchse(achse, kopieAchse);
                }
                achse = gisKopieMappingEngine.Translate <KopieAchse, Achse>(kopieAchse, achse);


                if (achse.Mandant != mandant)
                {
                    throw new Exception("achse.Mandant != mandant");
                }

                foreach (KopieAchsenSegment kopieSegment in kopieAchsenToSegmentDict[kopieAchse])
                {
                    UpdateSegment(achse, kopieAchse, kopieSegment, kopieSegment.Operation);
                }

                statistics.NumAchsen.Updates++;
                return(achse);
            }

            case AxisImportOperation.INSERT:
            {
                if (lookupAchseByBSID(kopieAchse.Id) != null)
                {
                    throw new Exception("Cannot insert: KopieAchse " + kopieAchse.Id + " already exists in Achsen table!");
                }

                Achse achse = gisKopieMappingEngine.Translate <KopieAchse, Achse>(kopieAchse);

                achse.BsId             = kopieAchse.Id;
                achse.Mandant          = mandant;
                achse.ErfassungsPeriod = erfassungsPeriod;

                foreach (KopieAchsenSegment kopieSegment in kopieAchsenToSegmentDict[kopieAchse])
                {
                    UpdateSegment(achse, kopieAchse, kopieSegment, kopieSegment.Operation);
                }

                session.Persist(achse);

                statistics.NumAchsen.Inserts++;
                return(achse);
            }
            }
            return(null);
        }
コード例 #9
0
 public void BeforeDeleteAchse(Achse targetAchse)
 {
     // noop
 }