Issue Subsystem

org.ththry.sspsimulator.ui.ontology/graph/SSPViewpoint.pgraph

L0 = <http://www.simantics.org/Layer0-1.1>
    
SSPUI = <http://org.ththry.sspsimulator/ui-1.0> : L0.Ontology
    @L0.new
    L0.HasResourceClass "org.ththry.sspsimulator.ui.ontology.SSPBuiltins"

SSPUI.Functions : L0.Library

org.ththry.sspsimulator.ui.ontology/graph/Functions.pgraph

L0 = <http://www.simantics.org/Layer0-1.1>
SSPUI = <http://org.ththry.sspsimulator/ui-1.0>

SSPUI.Functions.mismatchedConnectionTypeValidator : L0.Function

• NOTE: We define the function name mismatchedConnectionTypeValidator which must match the name of the Java function we will reference later.

org.ththry.sspsimulator.ui.ontology/graph/Validations.pgraph

L0 = <http://www.simantics.org/Layer0-1.1>
L0X = <http://www.simantics.org/Layer0X-1.1>
ISSUE = <http://www.simantics.org/Issue-1.2>

SSPUI = <http://org.ththry.sspsimulator/ui-1.0>

VALIDATIONS = SSPUI.Validations : L0.Library
    L0.HasResourceClass "org.ththry.sspsimulator.ui.ontology.SSPValidations"

// This is a template
VALIDATIONS.constraint : L0.Template
    @template %type %constraint %source %validator
        %type
            L0.HasConstraint %constraint : L0.Constraint
                L0.Constraint.Validator %validator
        %source <T ISSUE.Sources.ListeningDependencyTracker
            L0.Asserts _ : L0.Assertion
                L0.HasPredicate ISSUE.Sources.DependencyTracker.HasType
                L0.HasObject %type
            L0.Asserts _ : L0.Assertion
                L0.HasPredicate ISSUE.Sources.DependencyTracker.HasConstraint
                L0.HasObject %constraint

// Constraints

SSP.ComplexTypes.TSystem.Connections.Connection
    @VALIDATIONS.constraint
        VALIDATIONS.MismatchedConnectionTypeConstraint 
        VALIDATIONS.MismatchedConnectionTypeConstraint.Source 
        SSPUI.Functions.mismatchedConnectionTypeValidator

VALIDATIONS.MismatchedConnectionTypeConstraint.Source 
  L0.HasLabel "Mismatched types"

VALIDATIONS.MismatchedConnectionTypeConstraint.Source
  @L0.assert ISSUE.Sources.DependencyTracker.HasSearchType SSP.ComplexTypes.TSystem.Connections.Connection

// Issues
VALIDATIONS.MismatchedConnectionTypeConstraint.WarningIssue
    @ISSUE.issue ISSUE.Severity.Warning "Connectors have mismatching type."

• NOTE 1: We create a new library Validations under your SSPUI ontology, just like we did with Functions.

• NOTE 2: We define a reusable template (VALIDATIONS.constraint) which makes it easier to define constrains later

• NOTE 3: We use the template to create for the resource type SSP.ComplexTypes.TSystem.Connections.Connection a constraint

• NOTE 4: We define the constrain and source, as well as reference our function mismatchedConnectionTypeValidator in this constraint.

• NOTE 5: We need to define the source of the constraint and give it a label, and with an assert inject a HasSearchType for our resource type (SSP.ComplexTypes.TSystem.Connections.Connection)

• NOTE 6: We need to create a new issue type so that we can create issues of that type from our Java function (which we have not yet defined)

package org.ththry.sspsimulator.ui.functions;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.List;

import org.simantics.db.Issue;
import org.simantics.db.ReadGraph;
import org.simantics.db.Resource;
import org.simantics.db.common.issue.StandardIssue;
import org.simantics.db.exception.DatabaseException;
import org.simantics.scl.reflection.annotations.SCLValue;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.ththry.sspsimulator.ui.ontology.SSPBuiltins;

public class Func {

    @SCLValue(type = "ReadGraph -> Resource -> [Issue]")
    public static List<Issue> mismatchedConnectionTypeValidator(ReadGraph graph, Resource connection) throws DatabaseException {
        SSPBuiltins ssp = SSPBuiltins.getInstance(graph);
        Resource type = ssp.Validations_MismatchedConnectionTypeConstraint_WarningIssue;

        if (/* test if there is a mismatch */) {
            return List.of(new StandardIssue(type, connection));
        }
        return List.of();
    }
}

• NOTE 1: The name of the function "mismatchedConnectionTypeValidator" must match what you defined in your Functions.pgraph and referenced in your Validations.pgraph

• NOTE 2: In this example, we don't actually show any logic that checks if the Resource fails or succeeds its issue: This example ALWAYS creates an issue for the resource. In your actual code, you should implement logic that checks the situation you were interested in, and only create issues if the situation occurs.

• NOTE 3: In this example, we're creating a simple "StandardIssue" that doesn't contain the "HasDescription", "Issue_resource" or "Issue_path" metadata that is populated in the Issue table's columns.

• NOTE 4: We are referencing our Validations.pgraph ontology here, creating an issue with a specific type "Validations_MismatchedConnectionTypeConstraint_WarningIssue"

package org.ththry.sspsimulator.ui;

import org.simantics.db.Disposable;
import org.simantics.db.Session;
import org.simantics.db.exception.DatabaseException;
import org.simantics.issues.common.IssueUtils;
import org.simantics.layer0.Layer0;
import org.simantics.project.IProject;
import org.simantics.project.exception.ProjectException;
import org.simantics.project.features.AbstractProjectFeature;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class DesktopProjectFeature extends AbstractProjectFeature {

    private static final Logger LOGGER = LoggerFactory.getLogger(DesktopProjectFeature.class);

    private Disposable issueListener;

    @Override
    public void configure() throws ProjectException {
        final IProject project = getProject();
        final Session session = getSession();
        try {
            issueListener = IssueUtils.listenActiveProjectIssueSources(session, project.get());
            if(issueListener != null) {
            	LOGGER.info("Registered issueListener correctly.");
            }
        } catch (DatabaseException e) {
            throw new ProjectException(e);
        }
    }

    @Override
    public void deconfigure() throws ProjectException {
        if (issueListener != null) {
            issueListener.dispose();
            issueListener = null;
        }
    }
}

• NOTE 1: This is a bare minimum example of an implementation of an AbstractProjectFeature

• NOTE 2: You need to create the issueListener and remember to dispose of it later, like in the deconfigure function.

org.ththry.sspsimulator.ui/plugin.xml

<?xml version="1.0" encoding="UTF-8"?>
<plugin>
   <extension
         point="org.simantics.project.feature">
      <feature
            label="SSP Simulator Desktop Project"
            description="SSP Simulator desktop project feature."
            class="org.ththry.sspsimulator.ui.DesktopProjectFeature"
            published="true"
            id="org.ththry.sspsimulator.ui">
            <installGroup id="omnipresent" version="[0.0.0,9.0.0)"/>
      </feature>
   </extension>
   <extension
         point="org.simantics.scl.reflection.binding">
      <namespace
            path="http://org.ththry.sspsimulator/ui-1.0/Functions">
         <externalClass
               className="org.simantics.db.Issue">
         </externalClass>
         <externalClass
               className="org.simantics.db.Resource">
         </externalClass>
         <externalClass
               className="org.simantics.db.layer0.variable.Variable">
         </externalClass>
         <externalClass
               className="org.simantics.db.layer0.variable.VariableMap">
         </externalClass>
         <externalClass
               className="org.simantics.db.layer0.variable.ValueAccessor">
         </externalClass>
         <externalClass
               className="org.simantics.db.ReadGraph">
         </externalClass>
         <externalClass
               className="org.simantics.db.WriteGraph">
         </externalClass>
         <externalClass
               className="org.simantics.db.RelationContext">
         </externalClass>
         <class
               className="org.ththry.sspsimulator.ui.functions.Func">
         </class>
      </namespace>
   </extension>
</plugin>

• NOTE 1: The plugin.xml can exist in the same plugin as your DesktopProjectFeature and Func.java

• NOTE 2: You need to register your Project Feature. The "id=org.ththry.sspsimulator.ui" needs to match the plugin's name where your DesktopProjectFeature is located.

• NOTE 3: You need to bind the Functions ontology and let it know where to find the implementation of your functions. This is done with the class element's className field. Make sure the className points to the path of your `Func.java``, like in the example above.

This step can be done in various ways, and should be done in such a way that new models created in the desktop product always have new issue sources created for them (automatically).

If you simply want to test things, you can create the necessary resources and claims with SCL. Open your SCL Console and write:

import "Simantics/All"
import "http://org.ththry.sspsimulator/ui-1.0" as UI

model = resource "http://Projects/Development%20Project/Model"
source = newResource ()
claim source L0.InstanceOf UI.Validations.MismatchedConnectionTypeConstraint.Source
claimRelatedValue source L0.HasName "Find mismatched connection data types"
claim model L0X.Activates source
claim model L0.ConsistsOf source

• NOTE 1: The URI "http://Projects/Development%20Project/Model" should be the URI of your model so the model must have a valid URI.

• NOTE 2: The imported ontology (http://org.ththry.sspsimulator/ui-1.0) should be your base ontology

• NOTE 3: The instance type of the source resource should be the Source you defined in Validations.pgraph

• NOTE 4: The name can be anything, but should describe what this resource represents (not a random uuid).

When you now create a new resource of the specificed type (specificed in Validations.pgraph), an issue will be created in the Simantics desktop "Issues" view. To see this, you need to include the org.simantics.issues.ui.feature feature in your product's features. At the time of writing (2025.02.05), you can debug the implementation by adding breakpoints to DependencyIssueSource2.java, to see if the source is triggered and the model is correctly found for the sources.