import org.simantics.db.layer0.request.VariableProperty;
import org.simantics.db.layer0.request.VariableRead;
import org.simantics.db.layer0.request.VariableValueWithBinding;
+import org.simantics.db.layer0.scl.SCLDatabaseException;
import org.simantics.db.layer0.variable.ConstantPropertyVariable;
import org.simantics.db.layer0.variable.ProxyChildVariable;
import org.simantics.db.layer0.variable.ProxySessionRequest;
import org.simantics.document.server.io.CommandContextMutable;
import org.simantics.document.server.io.CommandResult;
import org.simantics.document.server.io.IConsole;
+import org.simantics.document.server.request.NodeRequest;
import org.simantics.document.server.request.ServerSCLHandlerValueRequest;
import org.simantics.document.server.request.ServerSCLValueRequest;
import org.simantics.document.server.serverResponse.ServerResponse;
import org.simantics.modeling.services.ComponentNamingStrategy;
import org.simantics.operation.Layer0X;
import org.simantics.project.IProject;
+import org.simantics.scl.compiler.module.repository.ImportFailureException;
import org.simantics.scl.compiler.types.TCon;
import org.simantics.scl.compiler.types.Type;
import org.simantics.scl.compiler.types.Types;
import org.simantics.structural2.variables.Connection;
import org.simantics.structural2.variables.StandardProceduralChildVariable;
import org.simantics.structural2.variables.VariableConnectionPointDescriptor;
+import org.slf4j.LoggerFactory;
import gnu.trove.map.hash.THashMap;
public class Functions {
+ private static final org.slf4j.Logger LOGGER = LoggerFactory.getLogger(Functions.class);
+
private static class PrimitivePropertyStatementsProcedure implements AsyncProcedure<DirectStatements> {
public DirectStatements result;
@SCLValue(type = "VariableMap")
public static VariableMap primitiveProperties = new VariableMapImpl() {
+ private void storePropertyValueAndExceptions(ReadGraph graph, Variable parent, String name, Variable property, Map<String, Variable> map) {
+ try {
+ Object value = property.getValue(graph);
+ map.put(name, new ConstantPropertyVariable(parent, name, value, null));
+ } catch (DatabaseException e) {
+ Variable propertyExceptions = map.get(NodeRequest.PROPERTY_VALUE_EXCEPTIONS);
+ Map<String, Exception> exceptionMap;
+ if (propertyExceptions == null) {
+ exceptionMap = new TreeMap<String, Exception>();
+ propertyExceptions = new ConstantPropertyVariable(parent, NodeRequest.PROPERTY_VALUE_EXCEPTIONS, exceptionMap, null);
+ map.put(NodeRequest.PROPERTY_VALUE_EXCEPTIONS, propertyExceptions);
+ } else {
+ try {
+ exceptionMap = propertyExceptions.getValue(graph);
+ } catch (DatabaseException e1) {
+ Logger.defaultLogError(e1);
+ return;
+ }
+ }
+ String label = name;
+ try {
+ label = property.getLabel(graph);
+ } catch (DatabaseException e2) {
+ }
+ exceptionMap.put(label, e);
+ }
+ }
+
@Override
public Variable getVariable(ReadGraph graph, Variable context, String name) throws DatabaseException {
return All.getStandardPropertyDomainPropertyVariableFromValue(graph, context, name);
@Override
public Map<String, Variable> getVariables(final ReadGraph graph, Variable context, Map<String, Variable> map) throws DatabaseException {
+ if(map == null) map = new HashMap<String,Variable>();
+
Variable parent = context.getParent(graph);
DocumentationResource DOC = DocumentationResource.getInstance(graph);
for(Variable property : procedural.getProperties(graph/*, DocumentationResource.URIs.Document_AttributeRelation*/)) {
if(property instanceof StandardAssertedGraphPropertyVariable) {
StandardAssertedGraphPropertyVariable ass = (StandardAssertedGraphPropertyVariable)property;
- if("datadefinitions".equals(ass.property.name) || "commands".equals(ass.property.name)) {
- Object value = property.getPossibleValue(graph);
- if(value != null) map.put(ass.property.name, new ConstantPropertyVariable(parent, ass.property.name, value, null));
+ if("dataDefinitions".equals(ass.property.name) || "commands".equals(ass.property.name) || "pollingFunction".equals(ass.property.name)) {
+ storePropertyValueAndExceptions(graph, parent, ass.property.name, property, map);
}
continue;
}
if(predicate != null) {
PropertyInfo info = graph.syncRequest(new PropertyInfoRequest(predicate));
if(info.hasClassification(DocumentationResource.URIs.Document_AttributeRelation)) {
- Variable prop = parent.getProperty(graph, predicate);
- Object value = prop.getValue(graph);
- if(map == null) map = new HashMap<String,Variable>();
- map.put(info.name, new ConstantPropertyVariable(parent, info.name, value, null));
+ Variable prop = parent.getProperty(graph, predicate);
+ storePropertyValueAndExceptions(graph, parent, info.name, prop, map);
}
}
}
} else {
+ Resource parentRes = parent.getRepresents(graph);
+ {
+ Variable prop = new StandardGraphPropertyVariable(graph, parent, DOC.Properties_commands);
+ storePropertyValueAndExceptions(graph, parent, "commands", prop, map);
+ }
+
+ if (graph.getPossibleObject(parentRes, DOC.Properties_dataDefinitions) != null) {
+ Variable prop = new StandardGraphPropertyVariable(graph, parent, DOC.Properties_dataDefinitions);
+ storePropertyValueAndExceptions(graph, parent, "dataDefinitions", prop, map);
+ }
+
DirectQuerySupport dqs = graph.getService(DirectQuerySupport.class);
PrimitivePropertyStatementsProcedure foo = new PrimitivePropertyStatementsProcedure();
- dqs.forEachDirectPersistentStatement(graph, parent.getRepresents(graph), foo);
-
+ dqs.forEachDirectPersistentStatement(graph, parentRes, foo);
+
for(Statement stm : foo.result) {
Resource predicate = stm.getPredicate();
PropertyInfo info = graph.syncRequest(new PropertyInfoRequest(predicate));
+
if(info.isHasProperty && info.hasClassification(DocumentationResource.URIs.Document_AttributeRelation)) {
- if(map == null) map = new HashMap<String,Variable>();
- Variable prop = new StandardGraphPropertyVariable(graph, parent, predicate);
- Object value = prop.getValue(graph);
- map.put(info.name, new ConstantPropertyVariable(parent, info.name, value, null));
+ Variable prop = new StandardGraphPropertyVariable(graph, parent, predicate);
+ storePropertyValueAndExceptions(graph, parent, info.name, prop, map);
+ } else {
+ Resource definition = graph.getPossibleObject(predicate, DOC.Document_definesAttributeRelation);
+ if(definition != null) {
+ PropertyInfo info2 = graph.syncRequest(new PropertyInfoRequest(definition));
+ Variable prop = new StandardGraphPropertyVariable(graph, parent, definition);
+ map.put(info2.name, new PrimitiveValueVariable(parent, info2.name, prop));
+ }
}
}
-
- Variable prop = new StandardGraphPropertyVariable(graph, parent, DOC.Properties_dataDefinitions);
- Object value = prop.getPossibleValue(graph);
- if(value != null) map.put("dataDefinitions", new ConstantPropertyVariable(parent, "dataDefinitions", value, null));
- prop = new StandardGraphPropertyVariable(graph, parent, DOC.Properties_commands);
- value = prop.getPossibleValue(graph);
- if(value != null) map.put("commands", new ConstantPropertyVariable(parent, "commands", value, null));
-
}
-
- if(map == null) return Collections.emptyMap();
-
return map;
}
}
}
+ @Deprecated
public static AbstractEventHandler emptyOnClick(ReadGraph graph) throws DatabaseException {
return new EventHandler() {
@Override
};
}
+ @Deprecated
public static AbstractEventHandler writeEventHandler(ReadGraph graph, final Variable variable, final Function fn) {
final Session session = graph.getSession();
return (String)response;
}
return null;
- } catch (Throwable t) {
- t.printStackTrace();
} finally {
sclContext.put("graph", oldGraph);
sclContext.put(SCLReportingHandler.REPORTING_HANDLER, oldPrinter);
}
- return null;
-
}
});
};
}
+ @Deprecated
public static AbstractEventHandler readEventHandler(ReadGraph graph, final Variable variable, final Function fn) {
final Session session = graph.getSession();
return (String)response;
}
return null;
- } catch (Throwable t) {
- t.printStackTrace();
} finally {
sclContext.put("graph", oldGraph);
sclContext.put(SCLReportingHandler.REPORTING_HANDLER, oldPrinter);
}
- return null;
-
}
});
};
}
+ @Deprecated
public static AbstractEventHandler readEventHandler2(ReadGraph graph, final Function fn) {
final Session session = graph.getSession();
return (CommandResult)response;
}
return null;
- } catch (Throwable t) {
- t.printStackTrace();
} finally {
sclContext.put("graph", oldGraph);
sclContext.put(SCLReportingHandler.REPORTING_HANDLER, oldPrinter);
}
- return null;
-
}
});
Object oldGraph = sclContext.put("graph", graph);
Object oldPrinter = sclContext.put(SCLReportingHandler.REPORTING_HANDLER, printer);
try {
- Object response = fn.apply(parameters);
- return response;
- } catch (Throwable t) {
- return new org.simantics.document.server.serverResponse.Error(formatError(graph, t));
+ return fn.apply(parameters);
} finally {
sclContext.put("graph", oldGraph);
sclContext.put(SCLReportingHandler.REPORTING_HANDLER, oldPrinter);
Object oldPrinter = sclContext.put(SCLReportingHandler.REPORTING_HANDLER, printer);
try {
- Object response = fn.apply(parameters);
- return response;
- } catch (Throwable t) {
- return new org.simantics.document.server.serverResponse.Error(formatError(graph, t));
+ return fn.apply(parameters);
} finally {
sclContext.put("graph", oldGraph);
sclContext.put(SCLReportingHandler.REPORTING_HANDLER, oldPrinter);
};
}
+ @Deprecated
public static AbstractEventHandler writeEventHandler2(ReadGraph graph, final Function fn) {
final Session session = graph.getSession();
return (CommandResult)response;
}
return null;
- } catch (Throwable t) {
- t.printStackTrace();
} finally {
sclContext.put("graph", oldGraph);
sclContext.put(SCLReportingHandler.REPORTING_HANDLER, oldPrinter);
}
- return null;
-
}
});
};
}
+
+ @Deprecated
public static AbstractEventHandler eventHandler2(ReadGraph graph, final Function fn) {
return new AbstractEventHandler() {
return (CommandResult)response;
}
return null;
- } catch (Throwable t) {
- t.printStackTrace();
} finally {
sclContext.put(SCLReportingHandler.REPORTING_HANDLER, oldPrinter);
}
- return null;
-
} catch (Throwable e) {
Logger.defaultLogError(e);
return new org.simantics.document.server.serverResponse.Error(e.getMessage());
};
}
+ @Deprecated
public static AbstractEventHandler eventHandler(ReadGraph graph, final Function fn) {
return new AbstractEventHandler() {
if(response instanceof String) {
result = (String)response;
}
- } catch (Throwable t) {
- t.printStackTrace();
} finally {
sclContext.put(SCLReportingHandler.REPORTING_HANDLER, oldPrinter);
}
return graph.syncRequest(new PathExistsRequest(context));
}
+ public static String compileDocumentSCLValueExpression(ReadGraph graph, Variable context) {
+ try {
+ ServerSCLValueRequest.validate(graph, context);
+ return "";
+ } catch (Exception e) {
+ return resolveIssueMessage(e);
+ }
+ }
+
+ private static String resolveIssueMessage(Exception e) {
+ if (e instanceof ImportFailureException)
+ return "";
+ if (e.getCause() != null && e.getCause() instanceof ImportFailureException)
+ return "";
+ if (e instanceof SCLDatabaseException) {
+ SCLDatabaseException ee = (SCLDatabaseException) e;
+ return ee.getMessage();
+ }
+ if (LOGGER.isDebugEnabled())
+ LOGGER.debug("", e);
+ return e.getMessage();
+ }
+
}
\ No newline at end of file
Code Review / simantics / platform.git / blobdiff