X-Git-Url: https://gerrit.simantics.org/r/gitweb?a=blobdiff_plain;f=org.simantics.district.network.ui%2Fsrc%2Forg%2Fsimantics%2Fdistrict%2Fnetwork%2Fui%2Fcontributions%2FPasteDistrictVertexHandler.java;h=7fadac3fd32743aac2800e79017027463c22fd2a;hb=e6b35994e05232dd536af4da224a342c1bd090af;hp=633395d5fd22ddacd54cfc226a7bf99bafbb8a51;hpb=2551bea874c75c004cd3fb8520d88268ce50c4a4;p=simantics%2Fdistrict.git diff --git a/org.simantics.district.network.ui/src/org/simantics/district/network/ui/contributions/PasteDistrictVertexHandler.java b/org.simantics.district.network.ui/src/org/simantics/district/network/ui/contributions/PasteDistrictVertexHandler.java index 633395d5..7fadac3f 100644 --- a/org.simantics.district.network.ui/src/org/simantics/district/network/ui/contributions/PasteDistrictVertexHandler.java +++ b/org.simantics.district.network.ui/src/org/simantics/district/network/ui/contributions/PasteDistrictVertexHandler.java @@ -1,8 +1,11 @@ package org.simantics.district.network.ui.contributions; import java.util.Collection; +import java.util.HashMap; import java.util.List; +import java.util.Map; import java.util.concurrent.TimeUnit; +import java.util.stream.Collectors; import javax.inject.Named; @@ -20,11 +23,14 @@ import org.simantics.db.common.request.WriteRequest; import org.simantics.db.exception.DatabaseException; import org.simantics.db.layer0.SelectionHints; import org.simantics.db.layer0.util.RemoverUtil; +import org.simantics.db.layer0.variable.Variable; +import org.simantics.db.layer0.variable.Variables; import org.simantics.db.request.Read; import org.simantics.diagram.stubs.DiagramResource; import org.simantics.district.network.DistrictNetworkUtil; import org.simantics.district.network.ontology.DistrictNetworkResource; import org.simantics.layer0.Layer0; +import org.simantics.modeling.ModelingResources; import org.simantics.utils.threads.ThreadUtils; import org.simantics.utils.ui.ISelectionUtils; import org.slf4j.Logger; @@ -122,6 +128,8 @@ public class PasteDistrictVertexHandler { Resource sourceElement = copiedElements.get(0); try { + Map sourceCopyAttributes = new HashMap<>(); + Map targetCopyAttributes = new HashMap<>(); Simantics.getSession().syncRequest(new WriteRequest() { @Override @@ -129,7 +137,9 @@ public class PasteDistrictVertexHandler { DistrictNetworkResource DN = DistrictNetworkResource.getInstance(graph); Resource sourceMappedElement = graph.getPossibleObject(sourceElement, DN.MappedComponent); + sourceCopyAttributes.putAll(copyAttributes(graph, sourceElement, sourceMappedElement)); Resource targetMappedElement = graph.getPossibleObject(targetElement, DN.MappedComponent); + targetCopyAttributes.putAll(copyAttributes(graph, targetElement, targetMappedElement)); if (sourceMappedElement != null && cut) RemoverUtil.remove(graph, sourceMappedElement); if (targetMappedElement != null) @@ -148,15 +158,20 @@ public class PasteDistrictVertexHandler { Resource newTarget = doCopy(graph, diagram, targetElement, sourceElement); if (cut) { Resource newSource = doCopy(graph, diagram, sourceElement, targetElement); + for (Map.Entry attrValue : targetCopyAttributes.entrySet()) { + graph.claimLiteral(newSource, attrValue.getKey(), attrValue.getValue()); + } copyVertexInverses(graph, sourceElement, newSource); deleteExistingTarget(graph, sourceElement); } + for (Map.Entry attrValue : sourceCopyAttributes.entrySet()) { + graph.claimLiteral(newTarget, attrValue.getKey(), attrValue.getValue()); + } copyVertexInverses(graph, targetElement, newTarget); deleteExistingTarget(graph, targetElement); } }); } catch (DatabaseException e) { - // TODO Auto-generated catch block e.printStackTrace(); } }, 500, TimeUnit.MILLISECONDS); @@ -218,4 +233,132 @@ public class PasteDistrictVertexHandler { } } + + private static Map copyAttributes(WriteGraph graph, Resource sourceElement, Resource mappedElement) throws DatabaseException { + Layer0 L0 = Layer0.getInstance(graph); + DistrictNetworkResource DN = DistrictNetworkResource.getInstance(graph); + + Resource mapping = graph.getSingleObject(sourceElement, DN.HasMapping); + Collection statements = graph.getStatements(mapping, L0.HasProperty); + Collection mappingAttributeStatements = statements.stream().filter(stm -> { + try { + Resource predicate = stm.getPredicate(); + Resource hasDomain = graph.getPossibleObject(predicate, L0.HasDomain); + if (hasDomain != null && hasDomain.equals(DN.Mapping_VertexMapping)) { + // filter out x and y and z + Resource vertexAttribute = attributeMappingToVertexAttribute(graph, DN, predicate); + return vertexAttribute != null; + } + } catch (Exception e) { + e.printStackTrace(); + } + return false; + }).collect(Collectors.toList()); + Resource component = graph.getPossibleObject(mappedElement, ModelingResources.getInstance(graph).ElementToComponent); + Variable variable = Variables.getVariable(graph, component); + Map predValues = new HashMap<>(); + for (Statement stm : mappingAttributeStatements) { + String propertyName = graph.getPossibleValue(stm.getObject()); + if (propertyName != null) { + Object propertyValue = variable.getPossiblePropertyValue(graph, propertyName); + if (propertyValue != null) { + predValues.put(attributeMappingToVertexAttribute(graph, DN, stm.getPredicate()), propertyValue); + } else { + System.err.println("no property value for " + variable.getURI(graph) + " and property " + propertyName); + } + } else { + System.err.println("stm.getObject() is not string " + stm.getObject()); + } + } + return predValues; + } + + private static Resource attributeMappingToVertexAttribute(ReadGraph graph, DistrictNetworkResource DN, Resource attribute) throws DatabaseException { + Resource attr = null; + if (attribute.equals(DN.Mapping_VertexMapping_ElevationAttribute)) + attr = null; // ignore elevation as well + else if (attribute.equals(DN.Mapping_VertexMapping_AddressAttribute)) + attr = DN.Vertex_HasAddress; + else if (attribute.equals(DN.Mapping_VertexMapping_DeltaPressureAttribute)) + attr = DN.Vertex_HasDeltaPressure; + else if (attribute.equals(DN.Mapping_VertexMapping_DeltaTemperatureAttribute)) + attr = DN.Vertex_HasDeltaTemperature; + else if (attribute.equals(DN.Mapping_VertexMapping_dpAttribute)) + attr = DN.Vertex_HasDeltaPressure; + else if (attribute.equals(DN.Mapping_VertexMapping_dtAttribute)) + attr = DN.Vertex_HasDeltaTemperature; + else if (attribute.equals(DN.Mapping_VertexMapping_FlowAreaAttribute)) + attr = DN.Vertex_HasFlowArea; + else if (attribute.equals(DN.Mapping_VertexMapping_HeatLoadDsAttribute)) + attr = DN.Vertex_HasHeatLoadDs; + else if (attribute.equals(DN.Mapping_VertexMapping_HeatPowerAttribute)) + attr = DN.Vertex_HasHeatPower; + else if (attribute.equals(DN.Mapping_VertexMapping_MassFlowAttribute)) + attr = DN.Vertex_HasMassFlow; + else if (attribute.equals(DN.Mapping_VertexMapping_MaximumHeadMAttribute)) + attr = DN.Vertex_HasMaximumHeadM; + else if (attribute.equals(DN.Mapping_VertexMapping_NominalFlowAttribute)) + attr = DN.Vertex_HasNominalFlow; + else if (attribute.equals(DN.Mapping_VertexMapping_NominalHeadBAttribute)) + attr = DN.Vertex_HasNominalHeadB_Inverse; + else if (attribute.equals(DN.Mapping_VertexMapping_NominalHeadMAttribute)) + attr = DN.Vertex_HasNominalHeadM; + else if (attribute.equals(DN.Mapping_VertexMapping_NominalMassFlowAttribute)) + attr = DN.Vertex_HasNominalFlow; + else if (attribute.equals(DN.Mapping_VertexMapping_NominalPressureLossAttribute)) + attr = DN.Vertex_HasNominalPressureLoss; + else if (attribute.equals(DN.Mapping_VertexMapping_ReturnPressureAttribute)) + attr = DN.Vertex_HasReturnPressure; + else if (attribute.equals(DN.Mapping_VertexMapping_ReturnTemperatureAttribute)) + attr = DN.Vertex_HasReturnTemperature; + else if (attribute.equals(DN.Mapping_VertexMapping_SupplyPressureAttribute)) + attr = DN.Vertex_HasSupplyPressure; + else if (attribute.equals(DN.Mapping_VertexMapping_SupplyTemperatureAttribute)) + attr = DN.Vertex_HasSupplyTemperature; + else if (attribute.equals(DN.Mapping_VertexMapping_ValvePositionAttribute)) + attr = DN.Vertex_HasValvePosition; + else if (attribute.equals(DN.Mapping_VertexMapping_VelocityAttribute)) + attr = DN.Vertex_HasVelocity; + else if (attribute.equals(DN.Mapping_VertexMapping_VolFlowAttribute)) + attr = DN.Vertex_HasVolFlow; + else if (attribute.equals(DN.Mapping_VertexMapping_PumpInReturnLineAttribute)) + attr = DN.Vertex_HasPumpInReturnLine; + else if (attribute.equals(DN.Mapping_VertexMapping_HeadPumpMaximumAttribute)) + attr = DN.Vertex_HasHeadPumpMaximum; + else if (attribute.equals(DN.Mapping_VertexMapping_HeadPumpNominalAttribute)) + attr = DN.Vertex_HasHeadPumpNominal; + else if (attribute.equals(DN.Mapping_VertexMapping_FrequencyConverterControlledAttribute)) + attr = DN.Vertex_HasFrequencyConverterControlled; + else if (attribute.equals(DN.Mapping_VertexMapping_InternalValveMeasurementAttribute)) + attr = DN.Vertex_HasInternalValveMeasurement; + else if (attribute.equals(DN.Mapping_VertexMapping_PumpMassFlowNominalAttribute)) + attr = DN.Vertex_HasPumpMassFlowNominal; + else if (attribute.equals(DN.Mapping_VertexMapping_PumpMeMaxAttribute)) + attr = DN.Vertex_HasPumpMeMax; + else if (attribute.equals(DN.Mapping_VertexMapping_PumpMeMinAttribute)) + attr = DN.Vertex_HasPumpMeMin; + else if (attribute.equals(DN.Mapping_VertexMapping_PumpSpeedMaxAttribute)) + attr = DN.Vertex_HasPumpSpeedMax; + else if (attribute.equals(DN.Mapping_VertexMapping_PumpSpeedMinAttribute)) + attr = DN.Vertex_HasPumpSpeedMin; + else if (attribute.equals(DN.Mapping_VertexMapping_ValveReturnLineAttribute)) + attr = DN.Vertex_HasValveReturnLine; + else if (attribute.equals(DN.Mapping_VertexMapping_ValveMeMaxAttribute)) + attr = DN.Vertex_HasValveMeMax; + else if (attribute.equals(DN.Mapping_VertexMapping_ValveMeMinAttribute)) + attr = DN.Vertex_HasValveMeMin; + else if (attribute.equals(DN.Mapping_VertexMapping_ValveMinPositionAttribute)) + attr = DN.Vertex_HasValveMinPosition; + else if (attribute.equals(DN.Mapping_VertexMapping_ValveOutletModeAttribute)) + attr = DN.Vertex_HasValveOutletMode; + else if (attribute.equals(DN.Mapping_VertexMapping_ValvePressLossNominalAttribute)) + attr = DN.Vertex_HasValvePressLossNominal; + else if (attribute.equals(DN.Mapping_VertexMapping_OpeningTimeAttribute)) + attr = DN.Vertex_HasOpeningTime; + else if (attribute.equals(DN.Mapping_VertexMapping_XAttribute)) + attr = null; // ignore this! + else if (attribute.equals(DN.Mapping_VertexMapping_YAttribute)) + attr = null; // ignore this! + return attr; + } }