--- /dev/null
+package org.simantics.district.network.techtype;
+
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Map;
+import java.util.Set;
+
+import org.simantics.Simantics;
+import org.simantics.databoard.binding.NumberBinding;
+import org.simantics.databoard.binding.error.BindingException;
+import org.simantics.databoard.type.Datatype;
+import org.simantics.databoard.type.NumberType;
+import org.simantics.databoard.util.Range;
+import org.simantics.databoard.util.RangeException;
+import org.simantics.db.ReadGraph;
+import org.simantics.db.Resource;
+import org.simantics.db.common.procedure.adapter.TransientCacheListener;
+import org.simantics.db.common.request.ResourceRead;
+import org.simantics.db.common.request.UniqueRead;
+import org.simantics.db.exception.DatabaseException;
+import org.simantics.db.layer0.request.PropertyInfo;
+import org.simantics.db.layer0.request.PropertyInfoRequest;
+import org.simantics.district.network.ontology.DistrictNetworkResource;
+import org.simantics.district.network.techtype.requests.TechTypeTableData;
+import org.simantics.layer0.Layer0;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+public class TechTypeValidationUtils {
+ private static final Logger LOGGER = LoggerFactory.getLogger(TechTypeValidationUtils.class);
+
+ /**
+ * Return a set of invalid tech type table entries.
+ *
+ * The tech type table values are validated against any limits that have been
+ * defined for associated component type properties.
+ *
+ * Invalid entries are designated by strings of the form "<type_code>/<property_name>".
+ *
+ * @param table A tech type table resource
+ * @return A set of labels for invalid values
+ * @throws DatabaseException
+ */
+ public static Set<String> validateTechTypeTable(Resource table) throws DatabaseException {
+ LOGGER.trace("Validating resource table {}", table);
+
+ // Use a unique read - we don't want to pollute the cache with this
+ return Simantics.getSession().syncRequest(new UniqueRead<Set<String>>() {
+ @Override
+ public Set<String> perform(ReadGraph graph) throws DatabaseException {
+ Resource type = graph.getPossibleObject(table, DistrictNetworkResource.getInstance(graph).TechType_TechTypeTable_HasComponentType);
+ if (type == null)
+ return Collections.emptySet();
+
+ Map<String, PropertyInfo> props = graph.syncRequest(new PropertyInfoMapOfType(type), TransientCacheListener.instance());
+ Set<String> result = new HashSet<>();
+
+ Map<String, Map<String, String>> data = graph.syncRequest(new TechTypeTableData(table), TransientCacheListener.instance());
+ for (String code : data.keySet()) {
+ LOGGER.trace(" type code {}", code);
+ Map<String, String> values = data.get(code);
+ for (String propertyName : values.keySet()) {
+ PropertyInfo info = props.get(propertyName);
+
+ // Allow property names to start with an underscore
+ if (info == null)
+ info = props.get("_" + propertyName);
+
+ if (info == null) {
+ LOGGER.trace(" {} - no property", propertyName);
+ continue;
+ }
+
+ Datatype dt = info.requiredDatatype;
+ if (dt == null || !(dt instanceof NumberType))
+ continue; // Only check ranges of numerical properties
+
+ String range = dt.metadata.get("range");
+ if (range != null) {
+ Range rng;
+ try {
+ rng = Range.valueOf(range);
+ } catch (RangeException e1) {
+ LOGGER.error("Invalid range string {} for property {}", range, propertyName, e1);
+ continue;
+ }
+
+ String valueString = values.get(propertyName).replace(",", ".");
+ try {
+ Double num = Double.valueOf(valueString);
+ NumberBinding binding = (NumberBinding)info.defaultBinding;
+ Number value = (Number) binding.create(num);
+
+ if (!rng.contains(value)) {
+ LOGGER.trace(" {} - range violation {} / {}", propertyName, valueString, range);
+ result.add(code + "/" + propertyName);
+ } else {
+ LOGGER.trace(" {} - valid value {} / {}", propertyName, valueString, range);
+ }
+ } catch (NumberFormatException e) {
+ // Nothing to do here, treat non-numeric strings as missing values
+ LOGGER.trace(" {} - no value {} / {}", propertyName, valueString, range);
+ } catch (BindingException e) {
+ LOGGER.error("Binding error for property {}", propertyName, e);
+ }
+ }
+ }
+ }
+
+ return result;
+ }
+ });
+ }
+
+ private static class PropertyInfoMapOfType extends ResourceRead<Map<String, PropertyInfo>> {
+ protected PropertyInfoMapOfType(Resource type) {
+ super(type);
+ }
+
+ @Override
+ public Map<String, PropertyInfo> perform(ReadGraph graph) throws DatabaseException {
+ Map<String, PropertyInfo> result = new HashMap<String, PropertyInfo>();
+ for (Resource prop : graph.getObjects(resource, Layer0.getInstance(graph).DomainOf)) {
+ PropertyInfo info = graph.syncRequest(new PropertyInfoRequest(prop), TransientCacheListener.instance());
+ result.put(info.name, info);
+ }
+
+ return result;
+ }
+ }
+}
Code Review / simantics / district.git / blobdiff