private void RegisterConflict(AchsenReferenz achsRef, AchsenUpdateConflict conflict)
{
if (Register(achsRef))
{
items[GetAbschnittGISBase(achsRef)].conflicts.Add(conflict);
}
}
public void AngenommenDieFolgendenZustandsabschnitteGISExistieren(Table table)
{
var reader = GetObjectReaderConfigurationFor <ZustandsabschnittGIS>()
.PropertyAliasFor(e => e.ErfassungsPeriod, "Jahr")
.PropertyAliasFor(e => e.StrassenabschnittGIS, "Strassenname")
.ConverterFor(e => e.Mandant, (s, p) => new Mandant())
.ConverterFor(e => e.StrassenabschnittGIS, (s, p) => new StrassenabschnittGIS())
.ConverterFor(e => e.ErfassungsPeriod, (s, p) => new ErfassungsPeriod());
var strassenabschnitts = entitesProErfassungsmodus[NetzErfassungsmodus.Gis][typeof(StrassenabschnittGIS)].Cast <StrassenabschnittGIS>().ToArray();
foreach (var zustandabscnitt in reader.GetObjectReader().GetObjectListWithRow <ZustandsabschnittGIS>(table))
{
var sa = strassenabschnitts.Single(s =>
s.Mandant.MandantName == zustandabscnitt.Item1["Mandant"] &&
s.ErfassungsPeriod.Erfassungsjahr.Year.ToString() == zustandabscnitt.Item1["Jahr"] &&
s.Strassenname == zustandabscnitt.Item1["Strassenname"]
);
zustandabscnitt.Item2.StrassenabschnittGIS = sa;
var achsenReferenz = new AchsenReferenz();
achsenReferenz.AchsenSegment = sa.ReferenzGruppe.AchsenReferenzen[0].AchsenSegment;
var referenzGruppe = new ReferenzGruppe();
zustandabscnitt.Item2.ReferenzGruppe = referenzGruppe;
referenzGruppe.ZustandsabschnittGISList.Add(zustandabscnitt.Item2);
achsenReferenz.ReferenzGruppe = referenzGruppe;
referenzGruppe.AchsenReferenzen.Add(achsenReferenz);
sa.Zustandsabschnitten.Add(zustandabscnitt.Item2);
}
}
private void DeleteAchsenReferenz(AchsenReferenz referenz)
{
ISession session = transactionScopeProvider.CurrentTransactionScope.Session;
referenz.ReferenzGruppe.AchsenReferenzen.Remove(referenz);
referenz.AchsenSegment.AchsenReferenzen.Remove(referenz);
session.Delete(referenz);
IAbschnittGISBase abschnitt = this.GetAbschnittGISBase(referenz);
if (abschnitt == null)
{
Loggers.ApplicationLogger.Warn(String.Format("No Abschnitt found for Referenzgruppe id: {0}", referenz.ReferenzGruppe.Id.ToString()));
}
else
{
if (referenz.ReferenzGruppe.AchsenReferenzen.Count < 1)
{
session.Delete(referenz.ReferenzGruppe);
ZustandsabschnittGIS zab = abschnitt as ZustandsabschnittGIS;
if (zab != null)
{
zab.StrassenabschnittGIS.Zustandsabschnitten.Remove(zab);
}
session.Delete(abschnitt);
}
else
{
this.UpdateAbschnitt(abschnitt);
}
}
}
public static void GenerateRealisierteMassnahmeGIS(ISession session, ErfassungsPeriod currentPeriod)
{
var achsensegmente = session.Query <AchsenSegment>().ToList();
achsensegmente = achsensegmente.Where(r => r.ErfassungsPeriod == currentPeriod).Take(RealisierteMassnahmeGISCount).ToList();
int achsensegmente_count = achsensegmente.Count;
var generator = new RandomGenerator();
var massnahmenvorschlagBuilder = Builder <RealisierteMassnahmeGIS> .CreateListOfSize(achsensegmente_count)
.All()
.With(s => s.Mandant = currentPeriod.Mandant)
.With(s => s.Beschreibung = generator.Phrase(20))
.With(s => s.Projektname = generator.Phrase(20));
var realisierteMassnahmenList = massnahmenvorschlagBuilder.Build();
var index = 0;
foreach (var realisierteMassnahme in realisierteMassnahmenList)
{
realisierteMassnahme.Shape = achsensegmente[index].Shape;
realisierteMassnahme.ReferenzGruppe = new ReferenzGruppe();
realisierteMassnahme.ReferenzGruppe.Erfassungsperiod = currentPeriod;
realisierteMassnahme.ReferenzGruppe.Mandant = currentPeriod.Mandant;
realisierteMassnahme.ReferenzGruppe.RealisierteMassnahmeGISList.Add(realisierteMassnahme);
var ar = new AchsenReferenz();
ar.Mandandt = currentPeriod.Mandant;
ar.Shape = achsensegmente[index].Shape;
ar.AchsenSegment = achsensegmente[index];
ar.ReferenzGruppe = realisierteMassnahme.ReferenzGruppe;
realisierteMassnahme.ReferenzGruppe.AchsenReferenzen.Add(ar);
realisierteMassnahme.Shape = achsensegmente[index].Shape;
session.Save(realisierteMassnahme);
index++;
}
}
public Feature CreateAchsenReferenzFeature(AchsenReferenz achsenreferenz, Guid inspektionsrouteid)
{
Feature arFeature = new Feature();
IAttributesTable saArAttributes = new AttributesTable();
arFeature.Geometry = achsenreferenz.Shape;
//ID
saArAttributes.AddAttribute(checkStringLengthforDBF(CheckOutGISDefaults.AchsenreferenzID), achsenreferenz.Id.ToString());
//AchsenID
saArAttributes.AddAttribute(checkStringLengthforDBF(CheckOutGISDefaults.AchsensegmentID), achsenreferenz.AchsenSegment.Id.ToString());
//ReferenzgruppeID
saArAttributes.AddAttribute(checkStringLengthforDBF(CheckOutGISDefaults.ReferenzgruppeID), achsenreferenz.ReferenzGruppe.Id.ToString());
//inspektionsRouteID
saArAttributes.AddAttribute(checkStringLengthforDBF(CheckOutGISDefaults.InspektionsRouteID), inspektionsrouteid.ToString());
//ZustandsabschnittID if Achsenreferenz belongs to a Zustandsabschnitt else StrassenabschnittsID (belongs to Strassenabschnitt)
if (achsenreferenz.ReferenzGruppe.ZustandsabschnittGIS != null)
{
saArAttributes.AddAttribute(checkStringLengthforDBF(CheckOutGISDefaults.ZustandsabschnittID), achsenreferenz.ReferenzGruppe.ZustandsabschnittGIS.Id.ToString());
saArAttributes.AddAttribute(checkStringLengthforDBF(CheckOutGISDefaults.StrassenabschnittGISID), achsenreferenz.ReferenzGruppe.ZustandsabschnittGIS.StrassenabschnittGIS.Id.ToString());
}
else if (achsenreferenz.ReferenzGruppe.StrassenabschnittGIS != null)
{
saArAttributes.AddAttribute(checkStringLengthforDBF(CheckOutGISDefaults.StrassenabschnittGISID), achsenreferenz.ReferenzGruppe.StrassenabschnittGIS.Id.ToString());
}
arFeature.Attributes = saArAttributes;
return(arFeature);
}
private IAbschnittGISBase GetAbschnittGISBase(AchsenReferenz achsRef)
{
if (achsRef.ReferenzGruppe.StrassenabschnittGIS != null)
{
return(achsRef.ReferenzGruppe.StrassenabschnittGIS);
}
else if (achsRef.ReferenzGruppe.ZustandsabschnittGIS != null)
{
return(achsRef.ReferenzGruppe.ZustandsabschnittGIS);
}
else if (achsRef.ReferenzGruppe.KoordinierteMassnahmeGIS != null)
{
return(achsRef.ReferenzGruppe.KoordinierteMassnahmeGIS);
}
else if (achsRef.ReferenzGruppe.MassnahmenvorschlagTeilsystemeGIS != null)
{
return(achsRef.ReferenzGruppe.MassnahmenvorschlagTeilsystemeGIS);
}
else if (achsRef.ReferenzGruppe.RealisierteMassnahmeGIS != null)
{
return(achsRef.ReferenzGruppe.RealisierteMassnahmeGIS);
}
else
{
return(null);
}
}
private AchsenReferenz PrepareAchsenreferenz(AchsenReferenz achsenreferenzToCopy)
{
AchsenReferenz copiedAchsensreferenz = entityServiceMappingEngine.Translate <AchsenReferenz, AchsenReferenz>(achsenreferenzToCopy);
copiedAchsensreferenz.Mandandt = CurrentMandant;
copiedAchsensreferenz.Erfassungsperiod = CurrentErfassungsPeriod;
return(copiedAchsensreferenz);
}
public void SplitStrassenabschnittGISAtXY(Guid strassenabschnittId, string x, string y)
{
StrassenabschnittGIS strassenabschnittToSplit = GetEntityById(strassenabschnittId);
//check whether the strassenabschnitt (inspektionsroute) is checked out (=locked)
if (strassenabschnittToSplit.IsLocked)
{
return;
}
//1. find achsenref. to split
IGeometry splitPoint = GISService.CreateGeometryFactory().CreatePoint(new Coordinate(double.Parse(x, System.Globalization.NumberFormatInfo.InvariantInfo), double.Parse(y, System.Globalization.NumberFormatInfo.InvariantInfo), 0));
AchsenReferenz achsenreferenceToSplit = gisService.GetNearestGeometry(splitPoint, strassenabschnittToSplit.ReferenzGruppe.AchsenReferenzen);
//2. split achsenref
LengthIndexedLine line = new LengthIndexedLine(achsenreferenceToSplit.Shape);
IGeometry split1 = line.ExtractLine(0, line.IndexOf(splitPoint.Coordinate));
IGeometry split2 = line.ExtractLine(line.IndexOf(splitPoint.Coordinate), line.EndIndex);
//create new strassenabschnitte
StrassenabschnittGIS copiedStrassenabschnittGIS1 = PrepareNewStrassenabschnitt(strassenabschnittToSplit, achsenreferenceToSplit, split1);
StrassenabschnittGIS copiedStrassenabschnittGIS2 = PrepareNewStrassenabschnitt(strassenabschnittToSplit, achsenreferenceToSplit, split2);
//3. relate other achsenrefs to the new two references
foreach (AchsenReferenz achsref in strassenabschnittToSplit.ReferenzGruppe.AchsenReferenzen.Where(ac => !ac.Equals(achsenreferenceToSplit)))
{
if (achsref.Shape.Distance(split1) <= achsref.Shape.Distance(split2))
{
copiedStrassenabschnittGIS1.ReferenzGruppe.AddAchsenReferenz(PrepareAchsenreferenz(achsref));
copiedStrassenabschnittGIS1.Shape = copiedStrassenabschnittGIS1.Shape.Union(achsref.Shape);
}
else
{
copiedStrassenabschnittGIS2.ReferenzGruppe.AddAchsenReferenz(PrepareAchsenreferenz(achsref));
copiedStrassenabschnittGIS2.Shape = copiedStrassenabschnittGIS2.Shape.Union(achsref.Shape);
}
}
copiedStrassenabschnittGIS1.Laenge = getLength(copiedStrassenabschnittGIS1);
copiedStrassenabschnittGIS2.Laenge = getLength(copiedStrassenabschnittGIS2);
//update inspektionsroute
strassenabschnittToSplit.InspektionsRtStrAbschnitte.ForEach(s => s.InspektionsRouteGIS.AddStrassenabschnittGIS(copiedStrassenabschnittGIS1));
strassenabschnittToSplit.InspektionsRtStrAbschnitte.ForEach(s => s.InspektionsRouteGIS.AddStrassenabschnittGIS(copiedStrassenabschnittGIS2));
strassenabschnittToSplit.InspektionsRtStrAbschnitte.ForEach(s => s.InspektionsRouteGIS.RemoveStrassenabschnittGIS(strassenabschnittToSplit));
//5. save/delete splitted strassenabschnitte
Delete(strassenabschnittToSplit);
CreateEntity(copiedStrassenabschnittGIS1);
CreateEntity(copiedStrassenabschnittGIS2);
}
private void UpdateAchsenReferenz(AchsenReferenz referenz, ILineString iLineString)
{
referenz.Shape = iLineString;
IAbschnittGISBase abschnitt = this.GetAbschnittGISBase(referenz);
if (abschnitt == null)
{
Loggers.ApplicationLogger.Warn(String.Format("No Abschnitt found for Referenzgruppe id: {0}", referenz.ReferenzGruppe.Id.ToString()));
}
else
{
this.UpdateAbschnitt(abschnitt);
}
}
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 UpdateEntityFieldsInternal(ReferenzGruppeModel model, ReferenzGruppe entity)
{
List <AchsenReferenzModel> new_AchsenReferenzen = new List <AchsenReferenzModel>();
foreach (AchsenReferenzModel achsenReferenzModel in model.AchsenReferenzenModel)
{
AchsenReferenz ar = new AchsenReferenz();
ar.ReferenzGruppe = entity;
ar.Shape = achsenReferenzModel.Shape;
ar.AchsenSegment = GetEntityById <AchsenSegment>(achsenReferenzModel.AchsenSegment);
entity.AddAchsenReferenz(ar);
}
model.AchsenReferenzenModel = new_AchsenReferenzen;
base.UpdateEntityFieldsInternal(model, entity);
}
protected override void UpdateEntityFieldsInternal(ReferenzGruppeDTO DataTransferObject, ReferenzGruppe entity)
{
List <AchsenReferenzDTO> new_AchsenReferenzen = new List <AchsenReferenzDTO>();
foreach (AchsenReferenzDTO achsenReferenzDTO in DataTransferObject.AchsenReferenzenDTO)
{
AchsenReferenz ar = new AchsenReferenz();
ar.ReferenzGruppe = entity;
ar.Shape = achsenReferenzDTO.Shape;
ar.AchsenSegment = GetEntityById <AchsenSegment>(achsenReferenzDTO.AchsenSegment);
entity.AddAchsenReferenz(ar);
}
DataTransferObject.AchsenReferenzenDTO = new_AchsenReferenzen;
base.UpdateEntityFieldsInternal(DataTransferObject, entity);
}
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 static void GenerateMassnahmenTeilsystemeGIS(ISession session, ErfassungsPeriod currentPeriod)
{
var achsensegmente = session.Query <AchsenSegment>();
var achsensegmentelist = achsensegmente.Where(r => r.ErfassungsPeriod == currentPeriod).Take(MassnahmenTeilsystemeGISCount).ToList();
int achsensegmente_count = achsensegmentelist.Count;
var generator = new RandomGenerator();
var massnahmenvorschlagBuilder = Builder <MassnahmenvorschlagTeilsystemeGIS> .CreateListOfSize(achsensegmente_count)
.All()
.With(s => s.Mandant = currentPeriod.Mandant)
.With(s => s.Beschreibung = generator.Phrase(20))
.With(s => s.Projektname = generator.Phrase(20))
.With(s => s.Teilsystem = Pick <TeilsystemTyp> .RandomItemFrom(Enum.GetValues(typeof(TeilsystemTyp)).Cast <TeilsystemTyp>().ToList()))
.With(s => s.Status = Pick <StatusTyp> .RandomItemFrom(Enum.GetValues(typeof(StatusTyp)).Cast <StatusTyp>().ToList()));
var massnahmenTeilsysteme = massnahmenvorschlagBuilder.Build();
var index = 0;
foreach (var massnahmenTeilsystem in massnahmenTeilsysteme)
{
massnahmenTeilsystem.Shape = achsensegmentelist[index].Shape;
massnahmenTeilsystem.ReferenzGruppe = new ReferenzGruppe();
massnahmenTeilsystem.ReferenzGruppe.Erfassungsperiod = currentPeriod;
massnahmenTeilsystem.ReferenzGruppe.Mandant = currentPeriod.Mandant;
massnahmenTeilsystem.ReferenzGruppe.MassnahmenvorschlagTeilsystemeGISList.Add(massnahmenTeilsystem);
var ar = new AchsenReferenz();
ar.Mandandt = currentPeriod.Mandant;
ar.Shape = achsensegmentelist[index].Shape;
ar.AchsenSegment = achsensegmentelist[index];
massnahmenTeilsystem.ReferenzGruppe.AchsenReferenzen.Add(ar);
session.Save(ar);
session.Save(massnahmenTeilsystem.ReferenzGruppe);
session.Save(massnahmenTeilsystem);
index++;
}
}
/// <summary>
/// Update a Achsenreferenz using a <code>GeometryTransformerResult</code>
/// </summary>
/// <param name="referenz">Achsenreferenz to update</param>
/// <param name="result">Result of <seealso cref='GeometryTransformer.Transform()' />GeometryTransformer.Transform()</param>
/// <param name="doDelete">Always delete Achsenreferenz even on <code>GeometryTransformerResultState.Success</code></param>
private void UpdateAchsenReferenz(AchsenReferenz referenz, GeometryTransformerResult result, bool doDelete)
{
switch (result.ResultState)
{
case GeometryTransformerResultState.Success:
if (doDelete)
{
this.DeleteAchsenReferenz(referenz);
}
else
{
this.UpdateAchsenReferenz(referenz, result.NewRefGeometry);
}
break;
case GeometryTransformerResultState.FailedWouldBeTooShort:
case GeometryTransformerResultState.FailedWouldBeOutside:
this.DeleteAchsenReferenz(referenz);
break;
default:
break;
}
}
private bool Register(AchsenReferenz achsRef)
{
IAbschnittGISBase abschnittGISBase = GetAbschnittGISBase(achsRef);
if (abschnittGISBase == null)
{
return(false);
}
CheckIfLocked(abschnittGISBase);
if (items.ContainsKey(abschnittGISBase))
{
return(true);
}
RegisteredItem rItem = new RegisteredItem();
rItem.abschnittGISBase = abschnittGISBase;
rItem.originalGeometry = abschnittGISBase.Shape;
items.Add(abschnittGISBase, rItem);
return(true);
}
private void RemoveReference(AchsenReferenz reference)
{
reference.AchsenSegment.AchsenReferenzen.Remove(reference);
reference.ReferenzGruppe.AchsenReferenzen.Remove(reference);
session.Delete(reference);
}
private StrassenabschnittGIS PrepareNewStrassenabschnitt(StrassenabschnittGIS strassenabschnittToCopy, AchsenReferenz achsenreferenzPart, IGeometry newGeometry)
{
StrassenabschnittGIS copiedStrassenabschnittGIS = entityServiceMappingEngine.Translate <StrassenabschnittGIS, StrassenabschnittGIS>(strassenabschnittToCopy);
copiedStrassenabschnittGIS.ErfassungsPeriod = CurrentErfassungsPeriod;
copiedStrassenabschnittGIS.Mandant = CurrentMandant;
copiedStrassenabschnittGIS.Shape = newGeometry;
//LineString line = newGeometry as LineString;
//copiedStrassenabschnittGIS.Laenge = (decimal)Math.Round(line.Length,1);
copiedStrassenabschnittGIS.ReferenzGruppe = new ReferenzGruppe {
Mandant = CurrentMandant,
Erfassungsperiod = CurrentErfassungsPeriod,
};
achsenreferenzPart.Shape = newGeometry;
copiedStrassenabschnittGIS.ReferenzGruppe.AchsenReferenzen.Add(PrepareAchsenreferenz(achsenreferenzPart));
return(copiedStrassenabschnittGIS);
}
public static IList <StrassenabschnittGIS> GenerateStrassenabschnittGIS(ISession session, ErfassungsPeriod currentPeriod, IList <AchsenSegment> achsensegmente)
{
var belastungskategories = session.Query <Belastungskategorie>().ToList();
var Massnahmen = session.Query <MassnahmenvorschlagKatalog>().Where(mvk => mvk.ErfassungsPeriod.Id == currentPeriod.Id).ToList();
Random rnd = new Random();
int achsensegmente_count = achsensegmente.Count;
var generator = new RandomGenerator();
var strassenabschnittBuilder = Builder <StrassenabschnittGIS> .CreateListOfSize(achsensegmente_count)
.All()
.With(s => s.Belastungskategorie = Pick <Belastungskategorie> .RandomItemFrom(belastungskategories))
.With(s => s.Mandant = currentPeriod.Mandant)
.With(s => s.ErfassungsPeriod = currentPeriod)
.With(s => s.Strassenname = generator.Phrase(20))
.With(s => s.IsLocked = false)
.With(s => s.Trottoir = Pick <TrottoirTyp> .RandomItemFrom(Enum.GetValues(typeof(TrottoirTyp)).Cast <TrottoirTyp>().ToList()));
var strassenabschnitte = strassenabschnittBuilder.Build();
var pageSize = 1;
var index = 0;
foreach (var strassenabschnitt in strassenabschnitte)
{
strassenabschnitt.Shape = achsensegmente[index].Shape;
IGeometry shape = strassenabschnitt.Shape;
foreach (Coordinate coord in shape.Coordinates)
{
coord.Z = double.NaN;
}
switch (strassenabschnitt.Trottoir)
{
case TrottoirTyp.Links:
strassenabschnitt.BreiteTrottoirLinks = (decimal)rnd.NextDouble() + 1;
break;
case TrottoirTyp.Rechts:
strassenabschnitt.BreiteTrottoirRechts = (decimal)rnd.NextDouble() + 1;
break;
case TrottoirTyp.BeideSeiten:
strassenabschnitt.BreiteTrottoirLinks = (decimal)rnd.NextDouble() + 1;
strassenabschnitt.BreiteTrottoirRechts = (decimal)rnd.NextDouble() + 1;
break;
case TrottoirTyp.NochNichtErfasst:
case TrottoirTyp.KeinTrottoir:
default:
break;
}
LengthIndexedLine indexedLine = new LengthIndexedLine(shape);
strassenabschnitt.Laenge = Convert.ToDecimal(Math.Round(indexedLine.EndIndex, 1));
strassenabschnitt.ReferenzGruppe = new ReferenzGruppe();
strassenabschnitt.ReferenzGruppe.StrassenabschnittGISList.Add(strassenabschnitt);
AchsenReferenz achsenreferenz = new AchsenReferenz();
achsenreferenz.ReferenzGruppe = strassenabschnitt.ReferenzGruppe;
achsenreferenz.AchsenSegment = achsensegmente[index];
achsenreferenz.Shape = achsensegmente[index].Shape;
achsenreferenz.ReferenzGruppe = strassenabschnitt.ReferenzGruppe;
strassenabschnitt.ReferenzGruppe.AddAchsenReferenz(achsenreferenz);
double linelength = indexedLine.EndIndex;
for (int i = 0; i < pageSize; i++)
{
ZustandsabschnittGIS zustandsabschnitt = new ZustandsabschnittGIS();
zustandsabschnitt.StrassenabschnittGIS = strassenabschnitt;
zustandsabschnitt.ReferenzGruppe = new ReferenzGruppe();
zustandsabschnitt.ReferenzGruppe.ZustandsabschnittGISList.Add(zustandsabschnitt);
AchsenReferenz achsenreferenzzustandsabschnitt = new AchsenReferenz();
achsenreferenzzustandsabschnitt.ReferenzGruppe = zustandsabschnitt.ReferenzGruppe;
achsenreferenzzustandsabschnitt.AchsenSegment = achsensegmente[index];
IGeometry subline = indexedLine.ExtractLine(linelength / pageSize * i, linelength / pageSize * (i + 1));
achsenreferenzzustandsabschnitt.Shape = subline;
zustandsabschnitt.Shape = subline;
zustandsabschnitt.Laenge = decimal.Parse(new LengthIndexedLine(subline).EndIndex.ToString());
zustandsabschnitt.Zustandsindex = Pick <decimal> .RandomItemFrom(new List <decimal> {
0, 1, 2, 3, 4, 5
});
zustandsabschnitt.Erfassungsmodus = ZustandsErfassungsmodus.Manuel;
achsenreferenzzustandsabschnitt.ReferenzGruppe = zustandsabschnitt.ReferenzGruppe;
zustandsabschnitt.ReferenzGruppe.AddAchsenReferenz(achsenreferenzzustandsabschnitt);
zustandsabschnitt.Aufnahmedatum = DateTime.Now.Date;
zustandsabschnitt.Aufnahmeteam = generator.Phrase(20);
zustandsabschnitt.Bemerkung = generator.Phrase(40);
zustandsabschnitt.BezeichnungVon = strassenabschnitt.BezeichnungVon + generator.Phrase(10);
zustandsabschnitt.BezeichnungBis = strassenabschnitt.BezeichnungBis + generator.Phrase(10);
strassenabschnitt.Zustandsabschnitten.Add(zustandsabschnitt);
zustandsabschnitt.MassnahmenvorschlagFahrbahn = Pick <MassnahmenvorschlagKatalog> .RandomItemFrom(Massnahmen.Where(mvk => mvk.KatalogTyp == MassnahmenvorschlagKatalogTyp.Fahrbahn && mvk.Belastungskategorie.Id == strassenabschnitt.Belastungskategorie.Id).ToList());
zustandsabschnitt.DringlichkeitFahrbahn = Pick <DringlichkeitTyp> .RandomItemFrom(Enum.GetValues(typeof(DringlichkeitTyp)).Cast <DringlichkeitTyp>().ToList());
switch (strassenabschnitt.Trottoir)
{
case TrottoirTyp.Links:
zustandsabschnitt.MassnahmenvorschlagTrottoirLinks = Pick <MassnahmenvorschlagKatalog> .RandomItemFrom(Massnahmen.Where(mvk => mvk.KatalogTyp == MassnahmenvorschlagKatalogTyp.Trottoir && mvk.Belastungskategorie.Id == strassenabschnitt.Belastungskategorie.Id).ToList());
zustandsabschnitt.ZustandsindexTrottoirLinks = Pick <ZustandsindexTyp> .RandomItemFrom(Enum.GetValues(typeof(ZustandsindexTyp)).Cast <ZustandsindexTyp>().ToList());
zustandsabschnitt.DringlichkeitTrottoirLinks = Pick <DringlichkeitTyp> .RandomItemFrom(Enum.GetValues(typeof(DringlichkeitTyp)).Cast <DringlichkeitTyp>().ToList());
break;
case TrottoirTyp.Rechts:
zustandsabschnitt.MassnahmenvorschlagTrottoirRechts = Pick <MassnahmenvorschlagKatalog> .RandomItemFrom(Massnahmen.Where(mvk => mvk.KatalogTyp == MassnahmenvorschlagKatalogTyp.Trottoir && mvk.Belastungskategorie.Id == strassenabschnitt.Belastungskategorie.Id).ToList());
zustandsabschnitt.ZustandsindexTrottoirRechts = Pick <ZustandsindexTyp> .RandomItemFrom(Enum.GetValues(typeof(ZustandsindexTyp)).Cast <ZustandsindexTyp>().ToList());
zustandsabschnitt.DringlichkeitTrottoirRechts = Pick <DringlichkeitTyp> .RandomItemFrom(Enum.GetValues(typeof(DringlichkeitTyp)).Cast <DringlichkeitTyp>().ToList());
break;
case TrottoirTyp.BeideSeiten:
zustandsabschnitt.MassnahmenvorschlagTrottoirLinks = Pick <MassnahmenvorschlagKatalog> .RandomItemFrom(Massnahmen.Where(mvk => mvk.KatalogTyp == MassnahmenvorschlagKatalogTyp.Trottoir && mvk.Belastungskategorie.Id == strassenabschnitt.Belastungskategorie.Id).ToList());
zustandsabschnitt.MassnahmenvorschlagTrottoirRechts = Pick <MassnahmenvorschlagKatalog> .RandomItemFrom(Massnahmen.Where(mvk => mvk.KatalogTyp == MassnahmenvorschlagKatalogTyp.Trottoir && mvk.Belastungskategorie.Id == strassenabschnitt.Belastungskategorie.Id).ToList());
zustandsabschnitt.ZustandsindexTrottoirLinks = Pick <ZustandsindexTyp> .RandomItemFrom(Enum.GetValues(typeof(ZustandsindexTyp)).Cast <ZustandsindexTyp>().ToList());
zustandsabschnitt.ZustandsindexTrottoirRechts = Pick <ZustandsindexTyp> .RandomItemFrom(Enum.GetValues(typeof(ZustandsindexTyp)).Cast <ZustandsindexTyp>().ToList());
zustandsabschnitt.DringlichkeitTrottoirLinks = Pick <DringlichkeitTyp> .RandomItemFrom(Enum.GetValues(typeof(DringlichkeitTyp)).Cast <DringlichkeitTyp>().ToList());
zustandsabschnitt.DringlichkeitTrottoirRechts = Pick <DringlichkeitTyp> .RandomItemFrom(Enum.GetValues(typeof(DringlichkeitTyp)).Cast <DringlichkeitTyp>().ToList());
break;
case TrottoirTyp.NochNichtErfasst:
case TrottoirTyp.KeinTrottoir:
default:
break;
}
session.Save(zustandsabschnitt);
}
session.Save(strassenabschnitt);
index++;
}
var test = strassenabschnitte.Where(s => s.IsLocked == true);
return(strassenabschnitte);
}
