Interface ICore


  • public interface ICore
    This documentation can be used when developing custom Java actions or custom Java modules to enhance application functionality.
    Core is a good starting point to find functionality. This class provides amongst other functionality: all object actions (create, change, commit, delete, rollback), authentication and sign-in functionality and file document handling.

    This is an internal interface that is not to be used and may change any time.

    • Method Detail

      • getListenersRegistry

        ListenersRegistry getListenersRegistry()
        Returns an instance of ListenersRegistry which can be used to register callbacks on system events for all persistable entities in the application.
        Returns:
        the register of listeners
        Since:
        7.6
      • addUserAction

        void addUserAction​(java.lang.Class<? extends UserAction<?>> userActionClass)
        Add the action specified by the given action name to action registry. This enables calling execute(actionName) for this action.
        Parameters:
        userActionClass - the action (e.g. com.mendix.action.MyAction)
      • authenticate

        boolean authenticate​(IContext context,
                             IUser user,
                             java.lang.String password)
                      throws CoreException
        Authenticate the given user with the given password.
        Parameters:
        context - the context for executing the authentication action
        user - the user to authenticate
        password - the password of the user to authenticate
        Returns:
        returns true if authentication was successful
        Throws:
        CoreException
      • buildException

        void buildException​(java.lang.StringBuilder trace,
                            java.lang.Throwable throwable)
        Prints the message and stacktrace of a Throwable and its cause(s).
        Parameters:
        trace - the StringBuilder the exception is printed to
        throwable - the Throwable to print
      • change

        boolean change​(IContext context,
                       IMendixObject object,
                       java.util.Map<java.lang.String,​java.lang.String> changes)
                throws CoreException
        Changes the given object in the state store (synchronously). When the object is not in the state store yet, the object will be retrieved from the database and put in the state store. This action is executed in a transaction.

        The 'changed by' and 'changed date' system attributes will be updated, independently of if there's an actual change. This is different behavior than in microflows.
        Parameters:
        context - the context
        object - the object to change
        changes - contains changes by member name (e.g. <"Name", "User1">)
        Returns:
        returns whether the change succeeded or not
        Throws:
        CoreException
      • changeAsync

        java.util.concurrent.Future<java.lang.Boolean> changeAsync​(IContext context,
                                                                   IMendixObject obj,
                                                                   java.util.Map<java.lang.String,​java.lang.String> changes)
        Changes the object (asynchronously). Object will be stored in the state store. This action is not executed in a transaction.

        The 'changed by' and 'changed date' system attributes will be updated, independently of if there's an actual change. This is different behavior than in microflows.
        Parameters:
        context - the context
        obj - the MendixObject to change
        changes - contains changes by member name (e.g. <"Name", "User1">)
        Returns:
        returns the Future object
      • commit

        IMendixObject commit​(IContext context,
                             IMendixObject object)
                      throws CoreException
        Commits the given object. This will store the object in the database and remove it from the server state store. This action is executed in a transaction.
        Parameters:
        context - the context
        object - the IMendixObject to commit
        Returns:
        returns committed object
        Throws:
        CoreRuntimeException - if commit fails
        CoreException
      • commit

        java.util.List<IMendixObject> commit​(IContext context,
                                             java.util.List<IMendixObject> objects)
        Commits the given objects. This will store the objects in the database and remove them from the server state store. Before events defined for these objects are executed before any object will be committed and after events will be executed after all objects have been committed. This action is executed in a transaction.
        Parameters:
        context - the context
        objects - the objects to commit
        Returns:
        returns committed objects
        Throws:
        CoreRuntimeException - if commit fails
      • commit

        IMendixObject commit​(IContext context,
                             IMendixObject object,
                             int queryTimeout)
        Commits the given object. This will store the object in the database and remove it from the server state store. This action is executed in a transaction.
        Parameters:
        context - the context
        object - the IMendixObject to commit
        queryTimeout - the timeout for queries related to this commit
        Returns:
        returns committed object
        Throws:
        CoreRuntimeException - if commit fails
      • commit

        java.util.List<IMendixObject> commit​(IContext context,
                                             java.util.List<IMendixObject> objects,
                                             int queryTimeout)
        Commits the given objects. This will store the objects in the database and remove them from the server state store. Before events defined for these objects are executed before any object will be committed and after events will be executed after all objects have been committed. This action is executed in a transaction.
        Parameters:
        context - the context
        objects - the objects to commit
        queryTimeout - the timeout for queries related to this commit
        Returns:
        returns committed objects
        Throws:
        CoreRuntimeException - if commit fails
      • commitAsync

        java.util.List<java.util.concurrent.Future<java.util.List<IMendixObject>>> commitAsync​(IContext context,
                                                                                               java.util.List<IMendixObject> objects)
        Commits the given object (asynchronously). This will store the object in the database and remove it from the server state store. This action is not executed in a transaction.
        Parameters:
        context - the context
        objects - the instances of IMendixObject to commit
        Returns:
        returns a list of future objects with committed object lists, one for each entity type
      • commitWithoutEvents

        IMendixObject commitWithoutEvents​(IContext context,
                                          IMendixObject object)

        Commits the given object without events. This will store the object in the database and remove it from the server cache.

        This action is executed in a transaction.

        Validations except unique validation are not executed. It is possible to save an entity which would not pass validations using this method.

        Parameters:
        context - the context
        object - the IMendixObject to commit
        Returns:
        returns committed object
        Throws:
        CoreRuntimeException - if commit fails
      • commitWithoutEvents

        IMendixObject commitWithoutEvents​(IContext context,
                                          IMendixObject object,
                                          int queryTimeout)

        Commits the given object without events. This will store the object in the database and remove it from the server cache.

        This action is executed in a transaction.

        Validations except unique validation are not executed. It is possible to save an entity which would not pass validations using this method.

        Parameters:
        context - the context
        object - the IMendixObject to commit
        queryTimeout - the timeout for queries related to this commit
        Returns:
        returns committed object
        Throws:
        CoreRuntimeException - if commit fails
      • commitWithoutEvents

        java.util.List<IMendixObject> commitWithoutEvents​(IContext context,
                                                          java.util.List<IMendixObject> objects)

        Commits the given objects without events. This will store the objects in the database and remove it from the server cache.

        This action is executed in a transaction.

        Validations except unique validation are not executed. It is possible to save entities which would not pass validations using this method.

        Parameters:
        context - the context
        objects - the objects to commit
        Returns:
        returns commited objects
        Throws:
        CoreRuntimeException - if commit fails
      • commitWithoutEvents

        java.util.List<IMendixObject> commitWithoutEvents​(IContext context,
                                                          java.util.List<IMendixObject> objects,
                                                          int queryTimeout)

        Commits the given objects without events. This will store the objects in the database and remove it from the server cache.

        This action is executed in a transaction.

        Validations except unique validation are not executed. It is possible to save entities which would not pass validations using this method.

        Parameters:
        context - the context
        objects - the objects to commit
        queryTimeout - the query timeout
        Returns:
        returns commited objects
        Throws:
        CoreRuntimeException - if commit fails
      • createDataType

        IDataType createDataType​(java.lang.String type)
        Creates a DataType based on a type.
        Possible types:
        - Boolean
        - Integer
        - Long
        - Float
        - String
        - Datetime
        - {code#id} (enumeration key)
        - ModuleName.ObjectName (IMendixObject)
        - [ModuleName.ObjectName] (List<IMendixObject>)
        Parameters:
        type - the type to base the IDataType on
        Returns:
        the resulting IDataType
      • createDataType

        IDataType createDataType​(java.lang.String objectType,
                                 java.lang.String attributeName)
        Creates a DataType based on an object type and a attribute name.
        Parameters:
        objectType - the object type (format: "ModuleName.EntityName")
        attributeName - the attribute to create the IDataType for (should be a member of above object type)
        Returns:
        the resulting IDataType
      • createMendixIdentifier

        IMendixIdentifier createMendixIdentifier​(long guid)
        Creates a new IMendixIdentifier for the given guid.
        Parameters:
        guid - the guid
        Returns:
        returns the created MendixIdentifier
      • createMendixIdentifier

        IMendixIdentifier createMendixIdentifier​(java.lang.String guid)
        Creates a IMendixIdentifier for the given guid.
        Parameters:
        guid - the guid
        Returns:
        returns the created MendixIdentifier
      • createOQLTextGetRequest

        IOQLTextGetRequest createOQLTextGetRequest()
        Create a new IOQLTextGetRequest. This class can be used to define a textual OQL retrieval query.
        Returns:
        an IOQLTextGetRequest
      • createOQLTextGetRequestFromDataSet

        IOQLTextGetRequest createOQLTextGetRequestFromDataSet​(java.lang.String dataSetQualifiedName)
        Instantiate IOQLTextGetRequest from given qualified DataSet name.

        Code examples

        Example OQL query without parameters

         
          private String getOqlQueryFromDataSet(String dataSetName) {
              final IOQLTextGetRequest oqlTextGetRequest = Core.createOQLTextGetRequestFromDataSet(dataSetName);
        
              return oqlTextGetRequest.getQuery();
          }
        
          public Report generateReport() {
              String oqlQuery = getOqlQueryFromDataSet();
              final IDataTable dataTable = Core.retrieveOQLDataTable(context, oqlQuery);
              final List<? extends IDataRow> rows = dataTable.getRows();
              Report report = new Report();
              report.addRow(rows.get(0));
        
              return report;
          }
         
         
        The above example first defines a getOqlQueryFromDataSet method at the top, which returns a OQL query in string format. It takes a qualified dataSetName which means DataSet name along with its module name separated by '.' character. For example, if the name of the DataSet is ReportGeneratorDataSet and it belongs to a module named Reporting then the qualified DataSet name will be Reporting.ReportGeneratorDataSet.
        This method is then used in generateReport method which retrieves a database data table from the OQL query.

        Example OQL query along with its parameters
         
         public Report generateReport(String dataSetName) {
             final IOQLTextGetRequest oqlTextGetRequest = Core.createOQLTextGetRequestFromDataSet(dataSetName);
             final IParameterMap newParameterMap = oqlTextGetRequest.createParameterMap();
             newParameterMap.put("ParGroupNumber", 4); // Set value of ParGroupNumber parameter to 4
             oqlTextGetRequest.setParameters(newParameterMap);
             final IDataTable dataTable = Core.retrieveOQLDataTable(context, oqlTextGetRequest);
             final List<? extends IDataRow> rows = dataTable.getRows();
             Report report = new Report();
             report.addRow(rows.get(0));
        
             return report;
         }
         
         
        The above example defines a similar generateReport method as shown in the previous example, however in this case the given DataSet has a OQL query which takes parameters. Let us consider that the given DataSet contains following OQL query with a parameter named ParGroupNumber -
         
           FROM CRM.Customers As CustomerObj
           INNER JOIN CustomerObj/CRM.Orders_Customer/CRM.Orders As OrderObj
           WHERE CustomerObj/CRM.Customer_Group/CRM.Group/GroupNumber = $ParGroupNumber
           GROUP BY CustomerObj/Name
           SELECT CustomerObj/Name As Name, SUM(OrderObj/TotalAmount) As TotalAmount
         
         
        Using the DataSet name generateReport method first creates a oqlTextGetRequest. Next, in order to set the ParGroupNumber parameter a new IParameterMap is instantiated and the value of ParGroupNumber parameter is specified, which in the above example would be 4. Finally we provide this newParameterMap to the setParameters method of IOQLTextGetRequest. This modified request is then used to retrieve a data table from the database, which in turn is used to generate a report.
        Parameters:
        dataSetQualifiedName - the qualified name of the DataSet containing OQL
        Returns:
        an instance of IOQLTextGetRequest if DataSet with OQL is found by given name
        Throws:
        java.lang.IllegalArgumentException - if given qualified name is null, has invalid format, found DataSet contains Java Action or DataSet is not found
      • createRetrievalSchema

        IRetrievalSchema createRetrievalSchema()
        Create a new IRetrievalSchema.
        Returns:
        an IRetrievalSchema
      • createSystemContext

        IContext createSystemContext()
        Returns the context of the system session (this is always a sudo context). The system session has no associated user or user roles.
        Returns:
        returns the system session context
      • getSessionById

        ISession getSessionById​(java.util.UUID sessionId)
        Returns the session belonging to the given session id.
        Parameters:
        sessionId - A session id
        Returns:
        The session belonging to the id. Returns null of not found
      • createXPathTextGetRequest

        IXPathTextGetRequest createXPathTextGetRequest()
        Create a new IXPathTextGetRequest. This class can be used to define an XPath retrieval query. The query must be set in textual form.
        Returns:
        an IXPathTextGetRequest
      • createXPathQuery

        XPathQuery createXPathQuery​(java.lang.String xpathQuery)
        Creates an XPath query representation that can be built up in a fluent manner

        Can be used to create and execute XPath queries in a fluent manner. For example:

         
         public getObjectsWithValue(IContext context, ICore core, int value) {
             List<IMendixObject> results = core.createXPathQuery("//Entity[attribute=$value]")
                 .setVariable("value", 1)
                 .setAmount(500)
                 .setOffset(50)
                 .setDepth(1)
                 .execute(context);
             return results;
         }
         

        After the XPath query is built up, XPathQueryBase.execute(IContext) can be called to retrieve the results.

        Parameters:
        xpathQuery - the XPath query to execute. Variable can be denoted with '$', e.g. a valid query syntax could be '//Entity.Ref[field >= $limit)'. If variables are declared inside the XPath query, they can be set using XPathQuery.setVariable(java.lang.String, java.math.BigDecimal) Unset variables are treated as NULL.
        Returns:
        instance of XPathQuery that can be used to construct an XPath query
        Since:
        Mendix 7.17
      • delete

        boolean delete​(IContext context,
                       IMendixObject... objects)
        Deletes the given objects from the database and server state store (synchronously). This action is executed in a transaction.
        Parameters:
        context - the context
        objects - the objects to delete
        Returns:
        returns whether the delete succeeded
      • delete

        boolean delete​(IContext context,
                       int queryTimeout,
                       IMendixObject... objects)
        Deletes the given objects from the database and server state store (synchronously). This action is executed in a transaction.
        Parameters:
        context - the context
        objects - the objects to delete
        queryTimeout - the timeout for queries related to this delete
        Returns:
        returns whether the delete succeeded
      • delete

        boolean delete​(IContext context,
                       java.util.List<IMendixObject> objectList)
        Deletes the given objects from the database and server state store (synchronously). This action is executed in a transaction.
        Parameters:
        context - the context
        objectList - the objects to delete
        Returns:
        returns whether the delete succeeded
      • deleteAsync

        java.util.List<java.util.concurrent.Future<java.lang.Boolean>> deleteAsync​(IContext context,
                                                                                   IMendixObject object,
                                                                                   boolean useDeleteBehavior)
        Deletes the given object from the database and server state store (asynchronously). This action is not executed in a transaction.
        Parameters:
        context - the context
        object - the object to delete
        useDeleteBehavior - whether to use delete behavior
        Returns:
        returns a list of future booleans, one for each entity type
      • deleteAsync

        java.util.List<java.util.concurrent.Future<java.lang.Boolean>> deleteAsync​(IContext context,
                                                                                   java.util.List<IMendixObject> objects,
                                                                                   boolean useDeleteBehavior)
        Deletes the given object from the database and server state store (asynchronously). This action is not executed in a transaction.
        Parameters:
        context - the context
        objects - the objects to delete
        useDeleteBehavior - whether to use delete behavior
        Returns:
        returns a list of future booleans, one for each entity type
      • deleteWithoutEvents

        boolean deleteWithoutEvents​(IContext context,
                                    java.util.List<IMendixObject> objects,
                                    boolean useDeleteBehavior)
        Deletes the given objects from the database and server state store (synchronously) without events This action is executed in a transaction.
        Parameters:
        context - the context
        objects - the objects to delete
        useDeleteBehavior - whether to use delete behavior
        Returns:
        returns whether the delete succeeded
      • evaluateExpression

        java.lang.Object evaluateExpression​(IContext context,
                                            java.util.Map<java.lang.String,​java.lang.Object> variables,
                                            java.lang.String expression)
        Evaluate the given (microflow)expression.
        Parameters:
        context - the context
        variables - name of variables referenced in the expression (without '$') and their values
        expression - the expression
        Returns:
        the evaluated value of the expression
      • microflowCall

        MicroflowCallBuilder microflowCall​(java.lang.String name)
        Prepare to call a microflow. Parameters and transaction properties can be set and specified microflow can be called using the returned object.
           Core.microflowCall("AModule.SomeMicroflow")
             .inTransaction(true)
             .withParam("Param1", "Value1")
             .withParam("Param2", "Value2")
             .execute(context);
         
        Parameters:
        name - the name of the microflow to prepare
        Returns:
        a builder for constructing the microflow
        See Also:
        MicroflowCallBuilder
      • userActionCall

        UserActionCallBuilder userActionCall​(java.lang.String name)
        Prepare to call a Java action. Parameters can be set and specified action can be called using the returned object.
           Core.userActionCall("AModule.SomeJavaAction")
             .withParams("Value1", "Value2")
             .execute(context);
         
        Parameters:
        name - the name of the user action to prepare
        Returns:
        a builder for constructing the user action
        See Also:
        UserActionCallBuilder
      • execute

        <T extends ICoreAction<R>,​R> java.util.concurrent.Future<R> execute​(T action)
        Execute an action asynchronously, result is given and/or exceptions are raised when calling Future.get(). When calling Future.get() the result of the action will return immediately if the execution is done, otherwise the call is blocking. Exceptions raised while executing the action will not be thrown until Future.get() is called.
        Type Parameters:
        T - action type, subclass of CoreAction
        R - result type of the action, which should match the return value of the action
        Parameters:
        action - the action to execute
        Returns:
        the Future object
      • executeAsync

        <R> java.util.concurrent.Future<R> executeAsync​(IContext context,
                                                        java.lang.String actionName,
                                                        boolean executeInTransaction,
                                                        java.util.Map<java.lang.String,​java.lang.Object> params)
                                                 throws CoreException
        Execute the specified microflow (asynchronously).
        Type Parameters:
        R - result type of the action, which should match the return value of the action
        Parameters:
        context - the context for this microflow
        actionName - the name of the microflow (format "ModuleName.ActionName")
        executeInTransaction - defines whether the microflow should be executed in a transaction (enables rolling back changes when exceptions are raised).
        params - microflow parameters by name
        Returns:
        return value of the specified microflow
        Throws:
        CoreException
      • executeAsync

        <R> java.util.concurrent.Future<R> executeAsync​(IContext context,
                                                        java.lang.String actionName,
                                                        java.lang.Object... params)
                                                 throws CoreException
        Execute the specified action (asynchronously), result is given and/or exceptions are raised when calling Future.get(). When calling Future.get() the result of the action will return immediately if the execution is done, otherwise the call is blocking. Exceptions raised while executing the action will not be thrown until Future.get() is called.

        Note that when called with a microflow, primitives will not be passed and multiple arguments that are a subtype of a microflow parameter will not work as expected.

        When calling microflows use executeAsync(IContext, String, boolean, Map) instead.

        Type Parameters:
        R - result type of the action, which should match the return value of the action
        Parameters:
        context - the context for this action
        actionName - the name of a microflow or Java action (format "ModuleName.ActionName")
        params - for microflows: add IMendixObject, IMendixIdentifier or primitive parameters for Java actions: add any object parameters.
        Returns:
        the Future object
        Throws:
        CoreException
      • executeSync

        <T extends ICoreAction<R>,​R> R executeSync​(T action)
                                                  throws CoreException
        Execute an action synchronously.
        Type Parameters:
        T - action type, subclass of CoreAction
        R - result type of the action, which should match the return value of the action
        Parameters:
        action - the action to execute
        Returns:
        return value of the specified action
        Throws:
        CoreException
      • executeVoid

        <T extends ICoreAction<R>,​R> void executeVoid​(T action)
        Execute the specified action (asynchronously).
        Type Parameters:
        R - result type of the action, which should be Object
        T - action type, subclass of CoreAction
        Parameters:
        action - the action to execute
      • getActionQueueSize

        int getActionQueueSize()
        Returns the current action pool queue size.
        Returns:
        returns current queue size of action thread pool
      • getActiveActionCount

        int getActiveActionCount()
        Returns the current number of active actions. This number represents only the actions which were started asynchronously.
        Returns:
        number of current active actions
      • getActiveSession

        ISession getActiveSession​(java.lang.String userName)
        Returns the active session for the user with the given username.
        Parameters:
        userName - the username associated with the session to search for
        Returns:
        the session associated with the given username if such a session exists, otherwise null
      • getActiveSessions

        java.util.Collection<? extends ISession> getActiveSessions()
        Returns all active sessions.
        Returns:
        the active sessions
      • getAllMendixObjects

        java.lang.Iterable<IMendixObject> getAllMendixObjects()
        Get all IMendixObject types.
        Returns:
        returns a list with all IMendixObjects (one object for each existing type)
      • getCompletedActionCount

        long getCompletedActionCount()
        Returns the number of completed actions since server startup. This number represents only the actions which were started asynchronously.
        Returns:
        number of completed actions
      • getConcurrentUserCount

        long getConcurrentUserCount​(boolean anonymous)
        The current number of concurrent users.
        Parameters:
        anonymous - whether anonymous users should be included in the count
        Returns:
        the number of concurrent users
      • getConfiguration

        Configuration getConfiguration()
        Returns the current configuration.
        Returns:
        the configuration
      • getCurrentPoolSize

        int getCurrentPoolSize()
        Returns the current action pool size.
        Returns:
        the current size of the action thread pool
      • getDatabaseChildColumnName

        java.lang.String getDatabaseChildColumnName​(IMetaAssociation metaAssociation)
        Returns the name of the database column for the child of the given association.
        Parameters:
        metaAssociation - the meta association to get the database child column name for
        Returns:
        the name of the database child column name
      • getDatabaseColumnName

        java.lang.String getDatabaseColumnName​(IMetaPrimitive metaPrimitive)
        Returns the name of the database column for the given attribute.
        Parameters:
        metaPrimitive - the meta primitive to get the database column name for
        Returns:
        the name of the database column
      • getDatabaseParentColumnName

        java.lang.String getDatabaseParentColumnName​(IMetaAssociation metaAssociation)
        Returns the name of the database column for the parent of the given association.
        Parameters:
        metaAssociation - the meta association to get the database parent column name for
        Returns:
        the name of the database parent column name
      • getDatabaseTableName

        java.lang.String getDatabaseTableName​(IMetaObject metaObject)
        Returns the name of the database table for the given entity type.
        Parameters:
        metaObject - the meta object to get the database table name for
        Returns:
        the name of the database table
      • getDatabaseTableName

        java.lang.String getDatabaseTableName​(IMetaAssociation metaAssociation)
        Returns the name of the database table for the given association. This table will contain two columns, to be able to store the id's of both sides of the association.
        Parameters:
        metaAssociation - the meta association to get the database table name for
        Returns:
        the name of the database table
      • getDefaultLanguage

        ILanguage getDefaultLanguage()
        Returns the default language of the loaded project.
        Returns:
        the default langauge
      • getLanguage

        ILanguage getLanguage​(IContext context)
        Get the language for the current context. If the session linked with this context is a user session the language will be the language of the user, in case of a system session and in case there is no language configured for this user, it will be the default language.
        Parameters:
        context - the context to retrieve the language from
        Returns:
        Language of the user attached to this session or the default language
        See Also:
        getDefaultLanguage()
      • getFileDocumentContent

        java.io.InputStream getFileDocumentContent​(IContext context,
                                                   IMendixObject fileDocument)
        Returns contents of a file document as an input stream. The returned stream must be closed when it is not needed anymore. No security checks will be performed.
        Parameters:
        context - the context
        fileDocument - the file document from which the contents will be returned
        Returns:
        the input stream of the file content of the given file document
      • getImage

        java.io.InputStream getImage​(IContext context,
                                     IMendixObject imageDocument,
                                     boolean retrieveThumbnail)
        Retrieve contents of the given image document. The returned stream must be closed when it is not needed anymore. No security checks will be performed.
        Parameters:
        context - the context
        imageDocument - the image document for which its contents are retrieved
        retrieveThumbnail - indicates whether a thumbnail or the full image is retrieved
        Returns:
        the image as an input stream
      • getInputParameters

        java.util.Map<java.lang.String,​IDataType> getInputParameters​(java.lang.String actionName)
        Returns all input parameter data types the specified action by name.
        Parameters:
        actionName - the name of a microflow or java action (format "ModuleName.ActionName")
        Returns:
        data types by input parameter name
      • getInternationalizedString

        java.lang.String getInternationalizedString​(IContext context,
                                                    java.lang.String key,
                                                    java.lang.Object... args)
        Returns the translated string for a certain key and context. The context is used to retrieve the language of the current user.
        Parameters:
        context - the context
        key - the key referring to the translatable string
        args - the arguments which should be applied to translatable string template
        Returns:
        the translated string
      • getInternationalizedString

        java.lang.String getInternationalizedString​(java.lang.String languageCode,
                                                    java.lang.String key,
                                                    java.lang.Object... args)
        Returns the translated string for a certain key and language code.
        Parameters:
        languageCode - the language code (ISO-639)
        key - the key referring to the translatable string
        args - values which should replace possible templates in the translatable string ({1}, {2}, etc.)
        Returns:
        the translated string
      • getLargestPoolSize

        int getLargestPoolSize()
        Returns the largest action pool size.
        Returns:
        the maximum number of threads the thread pool has ever ran
      • getLocale

        java.util.Locale getLocale​(IContext context)
        Retrieve locale using the given context.
        Parameters:
        context - the context
        Returns:
        the Locale
      • getLocale

        java.util.Locale getLocale​(java.lang.String languageCode)
        Retrieve locale using the given language code (e.g. en_US).
        Parameters:
        languageCode - the languageCode (ISO-639)
        Returns:
        the Locale
      • getMaximumNumberConcurrentUsers

        int getMaximumNumberConcurrentUsers()
                                     throws CoreException
        Returns the maximum number of concurrent users since the server was started.
        Returns:
        maximum number of concurrent users
        Throws:
        CoreException
      • getMetaAssociation

        IMetaAssociation getMetaAssociation​(java.lang.String association)
        Get the IMetaAssociation corresponding to the given association name.
        Parameters:
        association - the association name (e.g. "System.UserRoles")
        Returns:
        returns the IMetaAssociation for the given association name
      • getMetaAssociations

        java.lang.Iterable<IMetaAssociation> getMetaAssociations()
        Get all IMetaAssociations.
        Returns:
        returns all IMetaAssociations
      • getMetaObject

        IMetaObject getMetaObject​(java.lang.String metaObjectName)
        Get the IMetaObject corresponding to the given meta object name.
        Parameters:
        metaObjectName - the meta object name
        Returns:
        returns the IMetaObject for the given metaObjectName
      • getMetaObjects

        java.lang.Iterable<IMetaObject> getMetaObjects()
        Get all IMetaObjects.
        Returns:
        returns all IMetaObjects
      • getMetaPrimitive

        IMetaPrimitive getMetaPrimitive​(java.lang.String qualifiedAttributeName)
        Get the IMetaPrimtive based on a qualified attribute name (e.g. "System.User.Name").
        Parameters:
        qualifiedAttributeName - the qualified attribute name
        Returns:
        the IMetaPrimtive
      • getMicroflowNames

        java.util.Set<java.lang.String> getMicroflowNames()
        Returns the names of all modeled microflows.
        Returns:
        all microflow names (format "ModuleName.MicroflowName")
      • getNamedUserCount

        long getNamedUserCount()
        Returns the number of named, active users, excluding the admin user.
        Returns:
        the number of users
      • getNumberConcurrentSessions

        long getNumberConcurrentSessions()
        Returns current number of concurrent sessions.
        Returns:
        the number of concurrent sessions
      • getProfiler

        IProfiler getProfiler()
        Returns the currently registered profiler (if any).
        Returns:
        the profiler if one is registered; null otherwise
      • getReturnType

        IDataType getReturnType​(java.lang.String actionName)
        Returns the return type of the specified action.
        Parameters:
        actionName - the name of a microflow or java action (format "ModuleName.ActionName")
        Returns:
        the return data type of the specified action
      • getScheduledActionCount

        int getScheduledActionCount()
        Returns the number of actions currently scheduled for future execution.
        Returns:
        the number of scheduled actions
      • getStartupDateTime

        java.util.Date getStartupDateTime()
        Returns the startup date time of the Mendix runtime server.
        Returns:
        the date time on which the Mendix runtime server was started
      • getSubtypesOf

        java.util.List<java.lang.String> getSubtypesOf​(java.lang.String objectType)
        Get all subtypes for an object type (including subtypes of subtypes, etc.).
        Parameters:
        objectType - the object type
        Returns:
        list of subtypes, in no particular order
      • getUser

        IUser getUser​(IContext context,
                      java.lang.String userName)
               throws CoreException
        Returns a user using the given username.
        Parameters:
        context - the context
        userName - the username to retrieve a user for
        Returns:
        the retrieved user
        Throws:
        CoreException
      • getXASId

        java.lang.String getXASId()
        Returns the id of this server instance.
        Returns:
        the server id in UUID format
      • getLogger

        ILogNode getLogger​(java.lang.String name)
        Returns the logger corresponding to the specified name. If no logger with that name exists yet, it is created.
        Parameters:
        name - the name of te logger
        Returns:
        the log node
      • initializeGuestSession

        ISession initializeGuestSession()
                                 throws CoreException
        Initialize a new session for a guest user.
        Returns:
        the created session
        Throws:
        CoreException - if something goes wrong during the initializing a guest session
      • initializeSession

        ISession initializeSession​(IUser user,
                                   java.lang.String currentSessionId)
                            throws CoreException
        Initialize a new session for the given user.
        Parameters:
        user - the user for which the session should be initialized
        currentSessionId - id of the current session, will be used to transfer data when current session is associated with a guest user
        Returns:
        the created session
        Throws:
        CoreException
      • instantiate

        IMendixObject instantiate​(IContext context,
                                  java.lang.String objectType)
        Creates a new IMendixObject with the given object type (synchronously). The object will NOT be stored in the database. This action is executed in a transaction.
        Parameters:
        context - the context
        objectType - type of object to create (e.g. "System.User")
        Returns:
        returns the newly created object
      • instantiateAsync

        java.util.concurrent.Future<IMendixObject> instantiateAsync​(IContext context,
                                                                    java.lang.String objectType)
        Creates a new IMendixObject with the given object type (asynchronously). The object will NOT be stored in the database. This action is not executed in a transaction.
        Parameters:
        context - the context
        objectType - type of object to create (e.g. "System.User")
        Returns:
        returns the Future object
      • isInDevelopment

        boolean isInDevelopment()
        Returns whether this runtime server is running in development mode.
        Returns:
        true if the server is in development mode; false otherwise
      • isSubClassOf

        boolean isSubClassOf​(IMetaObject superObject,
                             IMetaObject type)
        Checks whether a type is a subclass of or equal to a potential super class.
        Parameters:
        superObject - the super object
        type - the name of the type to check
        Returns:
        returns true if type is a subclass of superClass or if type equals superClass
      • isSubClassOf

        boolean isSubClassOf​(java.lang.String superClass,
                             short typeHash)
        Checks whether a type is a subclass of or equal to a potential super class.
        Parameters:
        superClass - the name of the super class
        typeHash - the hash of the name of the type to check
        Returns:
        returns true if type is a subclass of superClass or if type equals superClass
      • isSubClassOf

        boolean isSubClassOf​(java.lang.String superClass,
                             java.lang.String type)
        Checks whether a type is a subclass of or equal to a potential super class.
        Parameters:
        superClass - the name of the super class
        type - the name of the type to check
        Returns:
        returns true if type is a subclass of superClass or if type equals superClass
      • login

        ISession login​(java.util.Map<java.lang.String,​? extends java.lang.Object> params)
                throws CoreException
        Generic login method (can be used in modules in combination with LoginAction replacement).
        Parameters:
        params - the params
        Returns:
        the created session if login was successful
        Throws:
        CoreException - when the login fails
      • login

        ISession login​(java.lang.String userName,
                       java.lang.String password)
                throws CoreException
        Login user with the given username and password.
        Parameters:
        userName - the username
        password - the password
        Returns:
        the created session if login is successful
        Throws:
        CoreException - when the login fails
      • login

        ISession login​(java.lang.String userName,
                       java.lang.String password,
                       IMxRuntimeRequest request)
                throws CoreException
        Login user with the given parameters.
        Parameters:
        userName - the username
        password - the password
        request - the HTTP request
        Returns:
        the created session if login is successful
        Throws:
        CoreException - when the login fails
      • login

        ISession login​(java.lang.String userName,
                       java.lang.String password,
                       java.lang.String currentSessionId)
                throws CoreException
        Login user with the given parameters.
        Parameters:
        userName - the username
        password - the password
        currentSessionId - current session UUID
        Returns:
        the created session if login is successful
        Throws:
        CoreException - when the login fails
      • logout

        void logout​(ISession session)
        Logout the given session. When the session is persistent it will be removed from the database. If the session is not persistent it will be removed from the session state.
        Parameters:
        session - the session to logout
      • registerLogSubscriber

        void registerLogSubscriber​(LogSubscriber subscriber)
        Register the specified subscriber for receiving log events.
        Parameters:
        subscriber - the subscriber to register
      • registerProfiler

        void registerProfiler​(IProfiler profiler)
                       throws MendixException
        Registers the specified profiler for receiving profiling events.
        Parameters:
        profiler - the profiler to register
        Throws:
        java.lang.IllegalArgumentException - if a profiler is already registered
        MendixException
      • removeScheduledFuture

        boolean removeScheduledFuture​(java.util.concurrent.RunnableScheduledFuture<?> scheduledFuture)
        Remove scheduled future.
        Parameters:
        scheduledFuture - the RunnableScheduledFuture to remove
        Returns:
        whether removing the RunnableScheduledFuture was successful
      • reschedule

        <R> java.util.concurrent.ScheduledFuture<?> reschedule​(java.util.concurrent.RunnableScheduledFuture<R> scheduledFuture,
                                                               ICoreAction<R> action,
                                                               long newDelay,
                                                               java.util.concurrent.TimeUnit timeUnit)
        Reschedule an action with a new delay.
        Type Parameters:
        R - result type of the action, which should be Object
        Parameters:
        scheduledFuture - the scheduledFuture (old action) to remove from the queue
        action - the action to reschedule
        newDelay - the new delay
        timeUnit - time unit of the delay
        Returns:
        scheduled future object
      • resolveTokens

        java.lang.Object resolveTokens​(IContext context,
                                       java.lang.String text)
        Resolve tokens (Mendix system variables) in the given text. Possible tokens: - [%CurrentDateTime%] - [%CurrentUser%] - [%SecondLength%] - [%MinuteLength%] - [%HourLength%] - [%DayLength%] - [%WeekLength%] - [%MonthLength%] - [%YearLength%] - [%BeginOfCurrentMinute%] - [%EndOfCurrentMinute%] - [%BeginOfCurrentHour%] - [%BeginOfCurrentDay%] - [%EndOfCurrentDay%] - [%BeginOfCurrentWeek%] - [%EndOfCurrentWeek%] - [%BeginOfCurrentMonth%] - [%EndOfCurrentMonth%] - [%BeginOfCurrentYear%] - [%EndOfCurrentYear%] - [%UserRole_%Name%%] (e.g. [%UserRole_Administrator%])
        Parameters:
        text - the text to resolve
        context - the context
        Returns:
        the resolved object
      • retrieveByPath

        java.util.List<IMendixObject> retrieveByPath​(IContext context,
                                                     IMendixObject mxObject,
                                                     java.lang.String path)
        Retrieves objects using the given object and path.
        Parameters:
        context - the context
        mxObject - the start point of the path
        path - the path (association) to the objects to retrieve
        Returns:
        the list of retrieved objects
      • retrieveByPath

        java.util.List<IMendixObject> retrieveByPath​(IContext context,
                                                     IMendixObject mxObject,
                                                     java.lang.String path,
                                                     boolean isSelfAssociationChild)
        Retrieves objects using the given object and path.
        Parameters:
        context - the context
        mxObject - the start point of the path
        path - the path (association) to the objects to retrieve
        isSelfAssociationChild - defines whether the mxObject instance is the child of the path of a self association
        Returns:
        the list of retrieved objects
      • retrieveByPath

        java.util.List<IMendixObject> retrieveByPath​(IContext context,
                                                     IMendixObject mxObject,
                                                     java.lang.String path,
                                                     java.lang.String entity,
                                                     boolean isSelfAssociationChild)
        Retrieves objects using the given object and path.
        Parameters:
        context - the context
        mxObject - the start point of the path
        path - the path (association) to the objects to retrieve
        entity - the specialization entity to limit the results to
        isSelfAssociationChild - defines whether the mxObject instance is the child of the path of a self association
        Returns:
        the list of retrieved objects
      • retrieveId

        IMendixObject retrieveId​(IContext context,
                                 IMendixIdentifier id)
                          throws CoreException
        Retrieves object with the given id (synchronously). First, the object is attempted to be retrieved from the state store. When the object cannot be retrieve from the state store it will be retrieved from the database.
        Parameters:
        context - the context
        id - id of the object to retrieve
        Returns:
        returns the Future object
        Throws:
        CoreException
      • retrieveIdAsync

        java.util.concurrent.Future<IMendixObject> retrieveIdAsync​(IContext context,
                                                                   IMendixIdentifier id)
        Retrieves object with the given id (asynchronously). First, the object is attempted to be retrieved from the state store. When the object cannot be retrieve from the state store it will be retrieved from the database.
        Parameters:
        context - the context
        id - id of the object to retrieve
        Returns:
        returns the Future object
      • retrieveIdList

        java.util.List<IMendixObject> retrieveIdList​(IContext context,
                                                     java.util.List<IMendixIdentifier> ids)
                                              throws CoreException
        Retrieves objects with the given ids (synchronously). First, objects are attempted to be retrieved from the state store. When an object cannot be retrieved from the state store it will be retrieved from the database. When (amount > 0) || (offset > 0) || (sort.size() > 0), all objects will be retrieved from the database.
        Parameters:
        context - the context
        ids - ids of the objects to retrieve
        Returns:
        returns the objects of the given ids
        Throws:
        CoreException
      • retrieveIdList

        java.util.List<IMendixObject> retrieveIdList​(IContext context,
                                                     java.util.List<IMendixIdentifier> ids,
                                                     int amount,
                                                     int offset,
                                                     java.util.Map<java.lang.String,​java.lang.String> sort)
                                              throws CoreException
        Retrieves objects with the given ids (synchronously). First, objects are attempted to be retrieved from the state store. When an object cannot be retrieve from the state store it will be retrieved from the database. When (amount > 0) || (offset > 0) || (sort.size() > 0), all objects will be retrieve from the database.
        Parameters:
        context - the context
        ids - ids of the objects to retrieve
        amount - the maximum number of objects to retrieve from the database
        offset - offset of returned objects when retrieved from the database
        sort - sorting of returned objects when retrieved from the database (e.g. <"Name", "ASC">, <"Age", "DESC">)
        Returns:
        returns the Future object
        Throws:
        CoreException
      • retrieveIdListAsync

        java.util.concurrent.Future<java.util.List<IMendixObject>> retrieveIdListAsync​(IContext context,
                                                                                       java.util.List<IMendixIdentifier> ids)
        Retrieves objects with the given ids (asynchronously). First, objects are attempted to be retrieved from the state store. When an object cannot be retrieve from the state store it will be retrieved from the database. When (amount > 0) || (offset > 0) || (sort.size() > 0), all objects will be retrieve from the database.
        Parameters:
        context - the context
        ids - ids of the objects to retrieve
        Returns:
        returns the Future object
      • retrieveOQLDataTable

        IDataTable retrieveOQLDataTable​(IContext context,
                                        java.lang.String oqlQuery,
                                        int amount,
                                        int offset)
                                 throws CoreException
        Retrieve raw data (IDataTable) using an OQL query (asynchronously).
        Parameters:
        context - context to be used to process this request
        oqlQuery - the OQL query to execute
        amount - maximum number of objects to retrieve
        offset - index of first object to retrieve
        Returns:
        the data table containing the raw data
        Throws:
        CoreException
      • retrieveOQLDataTable

        IDataTable retrieveOQLDataTable​(IContext context,
                                        IGetRequest request)
                                 throws CoreException
        Retrieve raw data (IDataTable) using an IGetRequest object (synchronously).
        Parameters:
        context - context to be used to process this request
        request - the request object
        Returns:
        the data table containing the raw data
        Throws:
        CoreException
      • retrieveOQLDataTable

        IDataTable retrieveOQLDataTable​(IContext context,
                                        java.lang.String oqlQuery)
                                 throws CoreException
        Retrieve raw data (IDataTable) using an IGetRequest object (synchronously).
        Parameters:
        context - context to be used to process this request
        oqlQuery - the OQL query to execute
        Returns:
        the data table containing the raw data
        Throws:
        CoreException
      • retrieveOQLDataTableAsync

        java.util.concurrent.Future<IDataTable> retrieveOQLDataTableAsync​(IContext context,
                                                                          java.lang.String oqlQuery)
        Retrieve raw data (IDataTable) using an OQL query (asynchronously).
        Parameters:
        context - context to be used to process this request
        oqlQuery - the OQL query to execute
        Returns:
        the Future object
      • retrieveOQLDataTableAsync

        java.util.concurrent.Future<IDataTable> retrieveOQLDataTableAsync​(IContext context,
                                                                          IGetRequest request)
        Retrieve raw data (IDataTable) using an IGetRequest object (asynchronously).
        Parameters:
        context - context to be used to process this request
        request - the request object
        Returns:
        the Future object
      • retrieveOQLDataTableAsync

        java.util.concurrent.Future<IDataTable> retrieveOQLDataTableAsync​(IContext context,
                                                                          java.lang.String oqlQuery,
                                                                          int amount,
                                                                          int offset)
        Retrieve raw data (IDataTable) using an OQL query (asynchronously).
        Parameters:
        context - context to be used to process this request
        oqlQuery - the OQL query to execute
        amount - maximum number of objects to retrieve
        offset - index of first object to retrieve
        Returns:
        the Future object
      • retrieveXPathQuery

        java.util.List<IMendixObject> retrieveXPathQuery​(IContext context,
                                                         java.lang.String xpathQuery,
                                                         int amount,
                                                         int offset,
                                                         java.util.Map<java.lang.String,​java.lang.String> sort)
                                                  throws CoreException
        Retrieves object list based on the given XPath query (synchronously).
        Parameters:
        context - context to be used to process this request
        xpathQuery - the XPath query to execute
        amount - maximum number of objects to retrieve
        offset - index of first object to retrieve
        sort - sorting of returned objects when retrieved from the database (e.g. <"Name", "ASC">, <"Age", "DESC">)
        Returns:
        the list of retrieved objects
        Throws:
        CoreException
      • retrieveXPathQuery

        java.util.List<IMendixObject> retrieveXPathQuery​(IContext context,
                                                         java.lang.String xpathQuery)
                                                  throws CoreException
        Retrieves object list based on the given XPath query (synchronously).
        Parameters:
        context - context to be used to process this request
        xpathQuery - the XPath query to execute
        Returns:
        the list of retrieved objects
        Throws:
        CoreException
      • retrieveXPathQuery

        java.util.List<IMendixObject> retrieveXPathQuery​(IContext context,
                                                         java.lang.String xpathQuery,
                                                         int amount,
                                                         int offset,
                                                         java.util.Map<java.lang.String,​java.lang.String> sort,
                                                         int depth)
                                                  throws CoreException
        Retrieves object list based on the given XPath query (synchronously).
        Parameters:
        context - context to be used to process this request
        xpathQuery - the XPath query to execute
        amount - maximum number of objects to retrieve
        offset - index of first object to retrieve
        sort - sorting of returned objects when retrieved from the database (e.g. <"Name", "ASC">, <"Age", "DESC">)
        depth - indicates the level until which each reference (IMendixIdentifier) is also retrieved as an IMendixObject
        Returns:
        the list of retrieved objects
        Throws:
        CoreException
      • retrieveXPathQueryAggregate

        java.lang.Long retrieveXPathQueryAggregate​(IContext context,
                                                   java.lang.String xpathQuery)
                                            throws CoreException
        Retrieves a long aggregate value based on the given query.

        The root element of the query should be an aggregate function.

        Parameters:
        context - context to be used to process this request
        xpathQuery - the aggregate xpath query (e.g. "COUNT(//System.User)")
        Returns:
        the aggregated result
        Throws:
        CoreException
      • retrieveXPathQueryAggregateDouble

        java.lang.Double retrieveXPathQueryAggregateDouble​(IContext context,
                                                           java.lang.String xpathQuery)
                                                    throws CoreException
        Retrieves a double aggregate value based on the given query.

        The root element of the query should be an aggregate function.

        Parameters:
        context - context to be used to process this request
        xpathQuery - the aggregate xpath query (e.g. "COUNT(//System.User)")
        Returns:
        the aggregated result
        Throws:
        CoreException
      • retrieveXPathQueryAggregateDecimal

        java.math.BigDecimal retrieveXPathQueryAggregateDecimal​(IContext context,
                                                                java.lang.String xpathQuery)
        Retrieves a Decimal aggregate value based on the given query.

        The root element of the query should be an aggregate function.

        Parameters:
        context - context to be used to process this request
        xpathQuery - the aggregate xpath query (e.g. "COUNT(//System.User)")
        Returns:
        the aggregated result
      • retrieveXPathQueryRaw

        IDataTable retrieveXPathQueryRaw​(IContext context,
                                         java.lang.String xpathQuery,
                                         int amount,
                                         int offset,
                                         java.util.Map<java.lang.String,​java.lang.String> sort,
                                         int depth)
                                  throws CoreException
        Retrieves raw data (IDataTables) based on the given XPath query (synchronously).
        Parameters:
        context - context to be used to process this request
        xpathQuery - the XPath query to execute
        amount - maximum number of objects to retrieve
        offset - index of first object to retrieve
        sort - sorting of returned objects when retrieved from the database (e.g. <"Name", "ASC">, <"Age", "DESC">)
        depth - indicates the level until which each reference (IMendixIdentifier) is also retrieved as an IMendixObject
        Returns:
        the data table containing the raw data
        Throws:
        CoreException
      • retrieveXPathQueryAggregateSchema

        java.lang.Long retrieveXPathQueryAggregateSchema​(IContext context,
                                                         java.lang.String xpathQuery,
                                                         IRetrievalSchema retrievalSchema)
                                                  throws CoreException
        Retrieves long aggregate value based on the given query and schema (root element of the query should be an aggregate function). (synchronously)
        Parameters:
        context - context to be used to process this request
        xpathQuery - the aggregate xpath query (e.g. "COUNT(//System.User)")
        retrievalSchema - the schema
        Returns:
        the aggregate value
        Throws:
        CoreException
      • retrieveXPathQueryAggregateSchema

        java.lang.Long retrieveXPathQueryAggregateSchema​(IContext context,
                                                         java.lang.String xpathQuery,
                                                         IRetrievalSchema retrievalSchema,
                                                         boolean disableSecurity)
                                                  throws CoreException
        Retrieves long aggregate value based on the given query and schema (root element of the query should be an aggregate function). (synchronously)
        Parameters:
        context - context to be used to process this request
        xpathQuery - the aggregate xpath query (e.g. "COUNT(//System.User)")
        retrievalSchema - the schema
        disableSecurity - whether security should be applied for this retrieval
        Returns:
        the aggregate value
        Throws:
        CoreException
      • retrieveXPathQueryAggregateAsyncDouble

        java.util.concurrent.Future<java.lang.Double> retrieveXPathQueryAggregateAsyncDouble​(IContext context,
                                                                                             java.lang.String xpathQuery)
        Retrieves long value based on the given query (query should have an aggregate function as root element).
        Parameters:
        context - context to be used to process this request
        xpathQuery - the aggregate XPath query (e.g. "COUNT(//System.User)")
        Returns:
        returns Future object for action control and return of action result
      • retrieveXPathQueryAggregateAsync

        java.util.concurrent.Future<java.lang.Long> retrieveXPathQueryAggregateAsync​(IContext context,
                                                                                     java.lang.String xpathQuery)
        Retrieves long aggregate value based on the given query (root element of the query should be an aggregate function) (asynchronously).
        Parameters:
        context - context to be used to process this request
        xpathQuery - the aggregate xpath query (e.g. "COUNT(//System.User)")
        Returns:
        the Future object
      • retrieveXPathQueryAsync

        java.util.concurrent.Future<java.util.List<IMendixObject>> retrieveXPathQueryAsync​(IContext context,
                                                                                           java.lang.String xpathQuery,
                                                                                           int amount,
                                                                                           int offset,
                                                                                           java.util.Map<java.lang.String,​java.lang.String> sort,
                                                                                           int depth)
        Retrieves object list based on the given XPath query (asynchronously).
        Parameters:
        context - the context
        xpathQuery - the XPath query to execute
        amount - maximum number of objects to retrieve
        offset - index of first object to retrieve
        sort - sorting of returned objects when retrieved from the database (e.g. <"Name", "ASC">, <"Age", "DESC">)
        depth - indicates the level until which each reference (IMendixIdentifier) is also retrieved as an IMendixObject
        Returns:
        the Future object
      • retrieveXPathSchema

        java.util.List<IMendixObject> retrieveXPathSchema​(IContext context,
                                                          java.lang.String xpathQuery,
                                                          IRetrievalSchema retrievalSchema,
                                                          boolean shouldRetrieveCount,
                                                          boolean disableSecurity)
                                                   throws CoreException
        Retrieves objects based on the XPath query and given schema (synchronously).
        Parameters:
        context - the context
        xpathQuery - the XPath query to execute
        retrievalSchema - the schema to apply
        shouldRetrieveCount - indicates whether the total number object corresponding to the given schema should be included in the result.
        disableSecurity - indicates whether security should be applied when this query is being executed
        Returns:
        the list of retrieved objects
        Throws:
        CoreException
      • retrieveXPathSchemaRaw

        IDataTable retrieveXPathSchemaRaw​(IContext context,
                                          java.lang.String xpathQuery,
                                          boolean shouldRetrieveCount,
                                          IRetrievalSchema retrievalSchema)
                                   throws CoreException
        Retrieves raw data (IDataTables) based on the XPath query and given schema (synchronously).
        Parameters:
        context - the context
        xpathQuery - the XPath query to execute
        shouldRetrieveCount - indicates whether the total number object corresponding to the given schema should be included in the result.
        retrievalSchema - the schema to apply
        Returns:
        the data table containing the raw data
        Throws:
        CoreException
      • rollback

        IMendixObject rollback​(IContext context,
                               IMendixObject object)
                        throws CoreException
        Rollback changes of the object with the given id (synchronously). When the object's state is NORMAL: Removes the object from the state store, all performed changes without commit will be lost. When the object's state is NEW: Removes the object from the database. This action is executed in a transaction.
        Parameters:
        context - the context
        object - the object to rollback
        Returns:
        returns the Future object
        Throws:
        CoreException
      • rollbackAsync

        java.util.concurrent.Future<IMendixObject> rollbackAsync​(IContext context,
                                                                 IMendixObject object)
        Rollback changes of the object with the given id (asynchronously). When the object's state is NORMAL: Removes the object from the state store, all performed changes without commit will be lost. When the object's state is NEW: Removes the object from the database. This action is not executed in a transaction.
        Parameters:
        context - the context
        object - the object to rollback
        Returns:
        returns the Future object
      • schedule

        java.util.concurrent.RunnableScheduledFuture<?> schedule​(java.lang.String actionName,
                                                                 java.util.Date date)
                                                          throws CoreException
        Schedule a microflow action / java action / registered action on a certain date. The execution will be tracked using a System.ScheduledEventInformation instance.
        Parameters:
        actionName - the name of a microflow or java action (format "ModuleName.ActionName")
        date - the date and time on which the action should be executed
        Returns:
        the RunnableScheduledFuture object for keeping track of the result
        Throws:
        CoreException
      • schedule

        <R> java.util.concurrent.RunnableScheduledFuture<?> schedule​(ICoreAction<R> action,
                                                                     long delay,
                                                                     java.util.concurrent.TimeUnit timeUnit)
        Schedule an action on a delay measured in timeUnit from now. The execution will not be tracked using a System.ScheduledEventInformation instance.
        Type Parameters:
        R - result type of the action, which should match the return value of the action
        Parameters:
        action - the action to execute
        delay - the delay after which the action should be executed
        timeUnit - time unit in which the delay is specified
        Returns:
        returns RunnableScheduleFuture object for keeping track of the result
      • scheduleAtFixedRate

        <R> void scheduleAtFixedRate​(ICoreAction<R> action,
                                     java.util.Date firstRun,
                                     long period,
                                     java.util.concurrent.TimeUnit timeUnit)
        Schedule a periodic action that run for the first time on the given date/time, and subsequently with the given period; that is executions will commence on firstRun then initialDelay+period, then initialDelay + 2 * period, and so on. The execution will not be tracked using a System.ScheduledEventInformation instance.
        No result will be returned.
        Type Parameters:
        R - result type of the action, which should be Object
        Parameters:
        action - the action to execute
        firstRun - the Date/time on which the action will be executed the first time
        period - the period between each start of the execution of the action
        timeUnit - the timeUnit in which the period is specified
      • scheduleAtFixedRate

        <R> void scheduleAtFixedRate​(ICoreAction<R> action,
                                     long initialDelay,
                                     long period,
                                     java.util.concurrent.TimeUnit timeUnit)
        Schedule a periodic action that runs for the first time after the given initial delay, and subsequently with the given period; that is executions will commence after initialDelay then initialDelay+period, then initialDelay + 2 * period, and so on. No result will be returned. The execution will not be tracked using a System.ScheduledEventInformation instance.
        Type Parameters:
        R - result type of the action, which should be Object
        Parameters:
        action - the action to execute
        initialDelay - the delay after which the action will be executed the first time
        period - the period between each start of the execution of the action
        timeUnit - the timeUnit in which the initialDelay and the period is specified
      • scheduleAtFixedRate

        void scheduleAtFixedRate​(java.lang.String actionName,
                                 java.util.Date firstRun,
                                 long period,
                                 java.util.concurrent.TimeUnit timeUnit,
                                 java.lang.String name,
                                 java.lang.String description)
        Schedule a periodic action that runs for the first time after the given initial delay (first run), and subsequently with the given period; that is executions will commence after initialDelay then initialDelay+period, then initialDelay + 2 * period, and so on. No result will be returned. The execution will be tracked using a System.ScheduledEventInformation instance.
        Parameters:
        actionName - the name of a microflow or java action (format "ModuleName.ActionName")
        firstRun - the date on which the action will be executed the first time
        period - the period between each start of the execution of the action
        timeUnit - the timeUnit in which the initialDelay and the period is specified
        name - the name of the scheduled event
        description - the description of the scheduled event
      • scheduleWithFixedDelay

        <R> void scheduleWithFixedDelay​(ICoreAction<R> action,
                                        long initialDelay,
                                        long delay,
                                        java.util.concurrent.TimeUnit timeUnit)
        Schedule a periodic action that runs for the first time after the given initial delay, and subsequently with the given delay between the termination of one execution and the commencement of the next. No result will be returned. The execution will not be tracked using a System.ScheduledEventInformation instance.
        Type Parameters:
        R - result type of the action, which should be Object
        Parameters:
        action - the action to execute
        initialDelay - the delay after which the action will be executed the first time
        delay - the delay between the end of the execution of the action and the start of the next time the action will be executed.
        timeUnit - the timeUnit in which the initialDelay and the delay is specified
      • storeFileDocumentContent

        void storeFileDocumentContent​(IContext context,
                                      IMendixObject fileDocument,
                                      java.io.InputStream inputStream)
        Physically stores a file using the given input stream and commits the file document. The passed input stream will be closed automatically. No security checks will be performed.
        Parameters:
        context - the context
        fileDocument - the file document to which the file to store is linked to
        inputStream - the content of the file
      • storeFileDocumentContent

        void storeFileDocumentContent​(IContext context,
                                      IMendixObject fileDocument,
                                      java.lang.String fileName,
                                      java.io.InputStream inputStream)
        Physically stores a file using the given input stream and commits the file document. The passed input stream will be closed automatically. User should have write access to "Name" attribute.
        Parameters:
        context - the context
        fileDocument - the file document to which the file to store is linked to
        fileName - the original name of the file (will be stored in the Name attribute)
        inputStream - the content of the file
      • storeImageDocumentContent

        void storeImageDocumentContent​(IContext context,
                                       IMendixObject imageDocument,
                                       java.io.InputStream inputStream,
                                       int thumbnailWidth,
                                       int thumbnailHeight)
        Physically stores an image using the given input stream and commits the image document. The passed input stream will be closed automatically. User should have read access to "Name" attribute.
        Parameters:
        context - the context
        imageDocument - the image document to which the image to store is linked to
        inputStream - the content of the file
        thumbnailWidth - the width of the thumbnail to create for this image
        thumbnailHeight - the width of the thumbnail to create for this image
      • unregisterProfiler

        void unregisterProfiler()
        Unregisters the current profiler. If no profiler is registered, nothing happens.
      • addRequestHandler

        void addRequestHandler​(java.lang.String path,
                               IRequestHandler requestHandler)
        Add a custom request handler to the Mendix runtime server. This request handler will process MxRuntimeRequests on the given path. Responses should be given by adding information to the MxRuntimeResponse.
        Parameters:
        path - the path for which request should be processed
        requestHandler - the custom request handler
      • addWebSocketEndpoint

        void addWebSocketEndpoint​(java.lang.String path,
                                  javax.websocket.Endpoint endpoint)
                           throws javax.websocket.DeploymentException
        Registers an instance of Endpoint to handle web socket requests on a path.
        Parameters:
        path - the path for which web socket requests should be processed. Must start with '/'
        endpoint - the endpoint to register
        Throws:
        javax.websocket.DeploymentException
      • getProjectId

        java.util.UUID getProjectId()
        Returns the project identifier of the project.
        Returns:
        The project identifier of the project
      • getModelVersion

        java.lang.String getModelVersion()
        Returns the model version of the project.
        Returns:
        The model version of the project