public void BeforeUpdateAchse(Achse targetAchse, KopieAchse kopieAchse)
{
if (!oldAxisValidFromDict.ContainsKey(targetAchse.BsId))
{
oldAxisValidFromDict.Add(targetAchse.BsId, targetAchse.VersionValidFrom);
}
}
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());
}
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);
}
}
}
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;
}
}
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 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;
}
}
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);
}
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);
}
public void BeforeDeleteAchse(Achse targetAchse)
{
// noop
}
