<div style="border:1px solid #dfdfdf;padding:0.5em 1em 0.5em 1em;background-color:#E7EAEC;margin:10px 0px 0px 10px;">
When updating, please read the [[QPR_ProcessAnalyzer_Release_Notes|release notes]] between the original and target releases, to check any special considerations regarding the update.
</div>

==QPR ProcessAnalyzer ScriptLauncher==
[[QPR_ProcessAnalyzer_ScriptLauncher#Installing_ScriptLauncher|Installation instructions]] for QPR ProcessAnalyzer ScriptLauncher.
* QPR ProcessAnalyzer ScriptLauncher 2026.2 (build 10910): https://files.qpr.com/releases/QPRProcessAnalyzerScriptLauncher_10910.zip
* QPR ProcessAnalyzer ScriptLauncher 2026.1 (build 10870): https://files.qpr.com/releases/QPRProcessAnalyzerScriptLauncher_10870.zip
* QPR ProcessAnalyzer ScriptLauncher 2025.7 (build 10845): https://files.qpr.com/releases/QPRProcessAnalyzerScriptLauncher_10845.zip
* QPR ProcessAnalyzer ScriptLauncher 2025.6 (build 10690): https://files.qpr.com/releases/QPRProcessAnalyzerScriptLauncher_10690.zip
* QPR ProcessAnalyzer ScriptLauncher 2025.5 (build 10361): https://files.qpr.com/releases/QPRProcessAnalyzerScriptLauncher_10361.zip
* QPR ProcessAnalyzer ScriptLauncher 2025.4 (build 9985): https://files.qpr.com/releases/QPRProcessAnalyzerScriptLauncher_9985.zip

==QPR ProcessAnalyzer Server (on Windows)==
[[Installing_QPR_ProcessAnalyzer_Server_on_Windows|Windows installation instructions]] for QPR ProcessAnalyzer Server.
* QPR ProcessAnalyzer Server 2026.2 (build 10910): https://files.qpr.com/releases/QPRProcessAnalyzerServer_10910.zip
* QPR ProcessAnalyzer Server 2026.1 (build 10870): https://files.qpr.com/releases/QPRProcessAnalyzerServer_10870.zip
* QPR ProcessAnalyzer Server 2025.7 (build 10845): https://files.qpr.com/releases/QPRProcessAnalyzerServer_10845.zip
* QPR ProcessAnalyzer Server 2025.6 (build 10690): https://files.qpr.com/releases/QPRProcessAnalyzerServer_10690.zip
* QPR ProcessAnalyzer Server 2025.5 (build 10361): https://files.qpr.com/releases/QPRProcessAnalyzerServer_10361.zip
* QPR ProcessAnalyzer Server 2025.4 (build 9985): https://files.qpr.com/releases/QPRProcessAnalyzerServer_9985.zip

If you need older releases, please contact customercare@qpr.com.

==QPR ProcessAnalyzer Server (on Linux)==
QPR ProcessAnalyzer is available as a [[Deploy_QPR_ProcessAnalyzer_from_Container|Linux container]] distributed using a private container registry. Please, contact customercare@qpr.com to get an access.
__NOTOC__

2026-04-09T08:49:26Z

Ollvihe:

QPR ProcessAnalyzer is able to connect to a QPR MEA (QPR Suite) instance and call its Web Service operations. QPR MEA Web Service documentation: https://kb.qpr.com/qpr2025-1/qpr_web_service.html.

To use the MEA connection, the following steps are required:
# Create connection string and store the secret.
# Create connection object.
# Call web service operations using the connection object.

== MEA Connection String ==
To connect to QPR MEA, the MEA connection string needs to be created and stored as a [[Storing_Secrets_for_Scripts|secret]].

The MEA connection string is a json object with following properties:
* '''url''': URL of the QPR MEA Web Service endpoint.
* '''logOnName''': Log on name of the user who will access the QPR MEA Web Service.
* '''password''': User's password in QPR MEA.

Example connection string:
<pre>
{ "url": "https://<hostname>/QPR/Portal/QPR.Isapi.dll/wsforward/MainService.svc/webHttp", "logOnName": "MyUser", "password": "MyPassword" }
</pre>

Example to store the secret:
<pre>
ProjectById(1).SetSecret("QprMea", "MeaConnection", `{ "url": "https://<hostname>/QPR/Portal/QPR.Isapi.dll/wsforward/MainService.svc/webHttp", "logOnName": "MyUser", "password": "MyPassword" }`);
</pre>

== MEA Web Service Operations ==
=== CreateObject ===
Calls CreateObject and returns the MEA ID of the created object. More information: https://kb.qpr.com/qpr2025-1/createobject2.html.

Parameters:
* '''namespaceId''' (String): MEA ID of the namespace into which the object is to be created.
* '''objectTypeName''' (String): Defines type of the new object.
* '''name''' (String): Defines name for the new object.
* '''parentIds''' (String or String*): MEA ID of parent object. If array is given, every array element specifies one ID.
* '''attributes''' (Dictionary): Key/value pairs of <attribute>/<attribute value> to be set for the created object.
* '''options''' (String): Optional options for the operation. See https://kb.qpr.com/qpr2025-1/parameters_and_options.html?anchor=options.

Example: Connect to the configured QPR MEA and create a new top-level comment action.
<pre>
ProjectByName("TestProject")
.CreateMeaConnection(#{"ConnectionStringKey": "MeaConnection"})
.CreateObject("PO", "Comment", "Test comment", "", #{"description": "Test comment description"});
</pre>

===DeleteObject ===
Calls DeleteObject. More information: https://kb.qpr.com/qpr2025-1/deleteobject2.html.

Parameters:
* '''objectIds''' (String or String*): One or more MEA IDs of objects to be deleted. If array is given, every array element specifies one ID of object to be deleted.
* '''options''' (String): Optional options for the query. See https://kb.qpr.com/qpr2025-1/parameters_and_options.html?anchor=options.

Example: Connect to the configured QPR MEA and delete an object.
<pre>
ProjectByName("TestProject")
.CreateMeaConnection(#{"ConnectionStringKey": "MeaConnection"})
.DeleteObject("PO.0.985518423");
</pre>

=== GetAttribute ===
Calls GetAttribute and returns the value of given object attribute as a string. More information: https://kb.qpr.com/qpr2025-1/getattributeasstring.html.

Parameters:
* '''objectId''' (String): MEA ID of an object from which the attribute is fetched.
* '''attribute''' (String): Name of the attribute that is queried. See https://kb.qpr.com/qpr2025-1/supported_parameters.html.
* '''options''' (String): Optional options for the query. See https://kb.qpr.com/qpr2025-1/parameters_and_options.html?anchor=options.

Example: Returns the name of an object.
<pre>
ProjectByName("TestProject")
.CreateMeaConnection(#{"ConnectionStringKey": "MeaConnection"})
.GetAttribute(
"[PG.785401983.683494101]",
"name"
);
</pre>

=== QueryObjects ===
Calls QueryObjects and returns query results as a hierarchical dictionary following the hierarchy of ResultSet object returned by QPR MEA. More information: https://kb.qpr.com/qpr2025-1/queryobjects.html

Parameters:
* '''query''' (String): The actual query. See https://kb.qpr.com/qpr2025-1/query_syntax.html.
* '''attributes''' (String): Comma-separated list of attributes that are included in the results. See https://kb.qpr.com/qpr2025-1/supported_parameters.html.
* '''criteria''' (String): Criteria used to filter the results by. See https://kb.qpr.com/qpr2025-1/parameters_and_options.html?anchor=globalparameters.
* '''sortBy''' (String): Comma-separated list of attributes to sort the results by.
* '''options''' (String): Optional options for the query. See https://kb.qpr.com/qpr2025-1/parameters_and_options.html?anchor=options.

Example: Return name and typename of all the subprocesses in a model whose name contains text "Account". Results are ordered by name and only at most three results are returned.
<pre>
ProjectByName("TestProject")
.CreateMeaConnection(#{"ConnectionStringKey": "MeaConnection"})
.QueryObjects(
"[PG.1374444994].Subprocess",
"name, typename",
`Find("Account", Name)`,
"name",
"MaxCount=3"
);
</pre>

=== SetAttribute ===
Calls SetAttribute to set an attribute value. More information: https://kb.qpr.com/qpr2025-1/setattribute.html.

Parameters:
* '''objectIds''' (String or String*): MEA ID of an object from which the attribute is fetched. If array is given, every array element specifies one ID.
* '''attribute''' (String): Name of the attribute that is queried. See https://kb.qpr.com/qpr2025-1/supported_parameters.html.
* '''value''' (String): Value to be set for given attribute.
* '''options''': Optional options for the query. See https://kb.qpr.com/qpr2025-1/parameters_and_options.html?anchor=options.

Example: Change the name of a user to "ChangedUser".
<pre>
ProjectByName("TestProject")
.CreateMeaConnection(#{"ConnectionStringKey": "MeaConnection"})
.SetAttribute(
"[UM.0.123]",
"name",
"ChangedUser"
);
</pre>

2026-04-08T12:50:33Z

Ollvihe:

This page contains preliminary information about new features and fixed issues in the next release.

==New features in next release==
* Units can be specified for counts of each type of objects in object-centric models. (''B-08992'')
* Dashboard variables can be used in External Content component urls for dynamically changing web page. (''B-08998'')
* QPR ProcessAnalyzer acts as MCP server where MCP tools are implemented using scripts. (''B-09004'')
* Project export to file and import from file support filters stored in models. (''B-09007'')
* Frontend components have been updated. (''B-09028'')

==Issues fixed in next release==
* Table column filter is not entire visible in narrow tables located in bottom of screen. (''D-14783'')
* Fixed issue where object-centric model queries sometimes gave inconsistent results. (''D-14854'')

==Features under work==
* Datatables data model visualization with ER diagram. (''B-09023'')
* Connection to MEA using expression language. (''B-09030'')

Note: Features and fixes currently under work are not necessarily targeting to the next release.
__NOTOC__

QPR ProcessAnalyzer Objects in Expression Language

2026-04-08T12:43:28Z

Ollvihe: /* Project */

==Filter==
Filters contain a set of filter rules used to filter cases and events in models. Filters are objects located in the models. Filters are owned by the creator user, and when a filter publish mode is private, only the creator can use it.

{| class="wikitable"
!'''Filter properties'''
! '''Description'''
|-
||CreatedBy (User)
||Returns the user who created the filter.
|-
||CreatedDate (DateTime)
||Returns date when the filter created date.
|-
||Description (String)
||Returns description of the filter.
|-
||Id (Integer)
||Returns id of the filter.
|-
||LastModifiedBy (User)
||Returns user who modified the filter.
|-
||LastModifiedDate (DateTime)
||Returns date when the filter last modified.
|-
||Model
||Returns model where the filter belongs to.
|-
||ModelId (Integer)
||Returns model where the filter belongs to.
|-
||Name (String)
||Returns the name of the filter.
|-
||Project
||Returns project where the filter belongs to.
|-
||ProjectId (Integer)
||Returns project id where the filter belongs to.
|-
||PublishMode (String)
||Returns publish mode of the filter, one of the following: '''Private''', '''Public''', or '''Default'''.
|-
||Rules (Dictionary)
||Returns a dictionary containing the filter rules in the filter.
|}

{| class="wikitable"
!'''Filter functions'''
!'''Parameters'''
! '''Description'''
|-
||DeletePermanently
||(none)
||
Deletes the filter permanently. To delete own filters, the '''Filtering''' permission is needed, and to delete any filters the '''ManageViews''' permission is needed.
|-
||Modify
||Dictionary
||
Modifies filter properties. The parameter is a dictionary containing the properties to be changed. Following properties can be changed: ''Name'', ''Description'', ''PublishMode'', and ''Rules''.

The function returns the updated filter object. Requires ''GenericWrite'' permission for the Project and global ''CreateModel'' permission.

Example:
<pre>
FilterById(1)
.Modify(#{
"Name": "My filter",
"Description": "My description",
"PublishMode": "Public",
"Rules": #{
"Items": [
#{
"Type": "IncludeCases",
"Items": [
#{
"Type": "CaseAttributeValue",
"Attribute": "Account Manager",
"StringifiedValues": [
"0Mary Wilson"
]
}
]
}
]
}
}
)
</pre>
|}

Function to get filter id:
{| class="wikitable"
!'''Functions'''
!'''Parameters'''
! '''Description'''
|-
||FilterById
||
* Filter id (Integer)
||
Returns Filter object corresponding to the provided filter id.
|}

==Model==
Notes:
* For in-memory models that are offline, the object counts represent the situation when the model was last time online (loaded into the memory). ''null'' is returned if the model has never been loaded into the memory.
* If [[Case_Level_Permissions|Case permissions]] are used for the model, and user doesn't have '''GenericWrite''' permission for the model, ''null'' is returned for data security reasons. Users that have the '''GenericWrite''' permission, see null when the model is offline, and when online, they see counts where the case level permissions settings are applied.
* Properties ''CaseAttributes'', ''EventAttributes'' and ''Eventlog'' work only for the in-memory models and they require the model to be loaded into the memory. If the model is not in the memory, it is loaded when these properties is used. Other model properties down require the model to be in the memory.

{| class="wikitable"
!'''Model properties'''
! '''Description'''
|-
||AllFilters (Filter*)
||Returns an array of all [[#Filter|filters]] in the model where the user has access to. In addition to the ''Filters'' property, ''AllFilters'' also returns private filters of other users. The ''ManageViews'' permission is required to use this property.
|-
||Calendars (BusinessCalendar*)
||
Returns all [[Business_Calendar|business calendars]] stored to the Model as an array. Returns an empty array, if there are no business calendars stored to the model. Note: UI allows to set only one business calendar for a Model.
|-
||CaseAttributes (AttributeType*)
||[[#AttributeType|CaseAttributes]] in the model returned in the alphabetical order. Using this property requires that the model is loaded in the memory. If the model is not in the memory, it's loaded when this property is used.
|-
||CasesDatatable (Datatable)
||Returns the Datatable the model uses as a datasource for cases. Returns ''null'' if the cases Datatable is not defined or if model uses other than the Datatable datasource.
|-
||Configuration (Dictionary)
||Returns the Model configuration as dictionary. Example:
<pre>
ModelById(123).Configuration.DataSource.Events.DataTableName
</pre>
|-
||ConfigurationJson (String)
||Returns the Model configuration as JSON string.
|-
||CreatedBy (User)
||User who created the model.
|-
||CreatedDate (DateTime)
||Timestamp when the model was created.
|-
||DefaultCalendar (BusinessCalendar)
||Returns the default [[Business_Calendar|business calendar]] of the Model. Returns ''null'', if there are no calendars in the Model or no calendar has been set as a default calendar. Note: UI allows to set only one business calendar for a Model, which is also the default calendar.
|-
||DefaultFilter (Filter)
||Default filter of the model. Returns ''null'' if the model does not have a default filter.
|-
||DefaultFilterId (Integer)
||Default filter id of the model. Returns ''null'' if the model does not have a default filter.
|-
||Description (String)
||Model description. The model description may contain line breaks.
|-
||DeletedDate (DateTime)
||Timestamp when Model was deleted (moved to the recycle bin).
|-
||DeletedBy (User)
||User how deleted the Model.
|-
||Diagrams (Diagram*)
||Returns an array of all [[Diagram_in_Expression_Language|diagrams]] in the model.
|-
||EstimatedMemory (Integer)
||Returns an estimation of how much memory in bytes the model requires.
|-
||EventsDatatable (Datatable)
||Returns the Datatable the model uses as a datasource for events. Returns ''null'' if the events Datatable is not defined or if model uses other than the Datatable datasource.
|-
||EventAttributes (AttributeType*)
||[[#AttributeType|EventAttributes]] in the model returned in the alphabetical order. Using this property requires that the model is loaded in the memory. If the model is not in the memory, it's loaded when this property is used.
|-
||EventLog (EventLog)
||EventLog containing the entire model (i.e. event log where no filters have been applied). Using this property requires that the model is loaded in the memory. If the model is not in the memory, it's loaded when this property is used.
|-
||Filters (Filter*)
||Returns an array of all public [[#Filter|filters]], the default filter (if any) and the user's own private filters in the model. Note that the other users's private filters are not returned even for administrators.
|-
||Id (Integer)
||Model Id. Model Id is generated by QPR ProcessAnalyzer when the model is created.
|-
||IsValidInMemoryModel (boolean)
||Returns ''true'' if all the following conditions are met:
* CheckModelValidity function doesn't return any issues (because invalid models are assumed to be Snowflake models).
* Model is not an object-centric model.
* Data source of the model is ''ODBC'' or ''Expression'', or the referred datatable has ''DataSourceType'' either ''Local'' or ''SqlServer''.
|-
||LastModifiedBy (User)
||User who last time modified the model properties. Note that datatables containing the eventlog data are separate objects having similar fields to track the last modification and last data import.
|-
||LastModifiedDate (DateTime)
||Timestamp when the model was modified the last time.
|-
||Name (String)
||Model name.
|-
||NCache (Integer)
||Number of objects related to the model when the model is loaded into the memory.
|-
||NCaseAttributes (Integer)
||Number of [[#AttributeType|CaseAttributes]] in model. Works only for in-memory models.
|-
||NCases (Integer)
||Number of [[#Case|Cases]] in the model. Works only for in-memory models.
|-
||NEventAttributes (Integer)
||Number of [[#AttributeType|EventAttributes]] in model. Works only for in-memory models.
|-
||NEvents (Integer)
||Number of [[#Event|Events]] in model. Works only for in-memory models.
|-
||NEventTypes (Integer)
||Number of [[#EventType|EventTypes]] in the model. Works only for in-memory models.
|-
||Project (Project)
||[[#Project|Project]] where the model belongs to.
|-
||ProjectId (Integer)
||[[#Project|Project]] id where the model belongs to.
|-
||Status (String)
||
Memory availability status of the model. There are the following statuses:
* '''Loading''': The model is currently loading into the memory. When the loading is ready, the status changes to ''online''. If the loading fails, the status changes to ''offline''.
* '''Offline''': The model is currently not loaded into the memory. The model needs to be loaded into the memory, so that analyses can be calculated from the model (occurs automatically when an analysis is requested).
* '''Online''': The model is in the memory and ready for analysis calculation. If the model is dropped from the memory, its status changes to ''offline''.
|-
||UsedDatatables (Datatable*)
||Returns all datatables the model uses as a datasource.

Example: List datatables used by a model:
<pre>
StringJoin(", ", OrderByValue(ModelById(1).UsedDataTables.Name))
</pre>
|}

{| class="wikitable"
!'''Model functions'''
!'''Parameters'''
! '''Description'''
|-
||CalendarByName (BusinessCalendar)
||
name (String)
||
Returns a [[Business_Calendar|business calendar]] stored to the Model by the name of the calendar. Business calendars can be stored to models in the model properties. Returns ''null'', if a calendar with the provided name is not stored to the model.

Examples:
<pre>
ModelById(123).CalendarByName("MyCalendar")
</pre>
|-
||CreateDiagram (Diagram)
||Parameters dictionary
||
Creates a [[Diagram_in_Expression_Language|diagram]] to the model. Parameters is a dictionary containing diagram properties. Following properties are available:
* '''Name''' (string): Diagram name that distinguishes diagrams in a model.
* '''Description''' (string): Diagram description text.
* '''Content''' (dictionary): Diagram content as dictionary.

Example:
<pre>
ModelById(1)
.CreateDiagram(#{
"Name": "My diagram",
"Description": "This is my new diagram",
"Content": #{ ... },
})
</pre>
|-
||CreateFilter (Filter)
||Parameters dictionary
||Creates a filter to a model. Requires ''GenericWrite'' permission for the project and global ''CreateModel'' permission. If a filter with that name already exists in the model, an exception is thrown.
The parameters dictionary may have the following properties:
* '''Name''': Name of the filter. This property is mandatory.
* '''Description''': Description of the filter. This property is optional.
* '''Rules''': Filter rules for the filter defined as a dictionary according to the [[Filtering_in_QPR_ProcessAnalyzer_Queries|filter json format]]. This property is mandatory.
* '''PublishMode''': Publish mode of the filter which is one of the following: ''Private'', ''Public'' or ''Default''. This property is optional, and the default value is ''Private''.

Example:
<pre>
let newFilter = modelById(1).CreateFilter(#{
"Name": "My Filter",
"Rules": #{
"Items": [#{
"Type": "IncludeCases",
"Items": [#{
"Type": "CaseAttributeValue",
"Attribute": "Account Manager",
"StringifiedValues": [ "0Robert Miller" ]
}]
}]
},
"PublishMode": "Public"
});
}
</pre>
|-
||DeletePermanently
||(none)
||Deletes the Model permanently. The model doesn't need to be in the recycle bin to be able to delete it permanently.
|-
||Modify (Model)
||Dictionary
||
Modifies model properties. The parameter is a dictionary containing the properties to be changed. Following properties can be changed: ''Name'', ''Description'', ''ProjectId'', and ''Configuration''.

The function returns the updated model object. Requires the ''GenericWrite'' permission for the project and the global ''CreateModel'' permission.

Example:
<pre>
ModelById(1)
.Modify(#{
"Name": "My model",
"Description": "My description",
"ProjectId": 2,
"Configuration": #{
"DataSource": #{
"Cases": #{
"DataSourceType": "datatable",
"DataTableName": "My cases datatable",
"Columns": #{
"CaseId": "Case Name"
}
},
"Events": #{
"DataSourceType": "datatable",
"DataTableName": "My events datatable",
"Columns": #{
"CaseId": "Case Name",
"EventType": "Event Type",
"Timestamp": "Start Time"
}
}
}
}
}
)
</pre>
|-
||ResetModelCache
||(none)
||
Synchronously clears all cached model data. For a Snowflake model, deletes all cache tables related to the model from Snowflake. For an in-memory model, drops the model from the memory and also drops all other model related caches from the memory.
|-
||ResetPreprocessings
||(none)
||
Removes all cached items related to the Model, e.g. preprocessings and calculation results. In practice, the Model is reset to a state where it was right after the model was loaded into memory.
|-
||Restore
||(none)
||Restores the Model from the recycle bin back to the original location.
|-
||<span id="ToSqlDataFrame">ToSqlDataFrame</span>
||In-memory dataframe
||Converts an in-memory dataframe to an SQL dataframe. In practice, an SQL query is created from the in-memory dataframe and the query is executed in the datasource so that the data is available in the datasource for further SQL operations. This function is intended only to small amounts of data which is less than 16384 rows.

Example: Select matching cases from events data using in-memory dataframe:
<pre>
let model = ModelById(1);
let dfEvents = model.EventsDatatable.SqlDataFrame;
let inMemoryDf = ToDataFrame(
[["1"], ["2"], ["3"]],
[#{"Name": "id", "DataType": "String"}]
);
model.ToSqlDataFrame(inMemoryDf)
.Join(dfEvents, ["id": "CaseId"])
.SelectDistinct(["CaseId"])
.Collect();
</pre>
|-
||<span id="TriggerNotifications">TriggerNotifications</span> (Boolean)
||Notification names (String*)
||Triggers the given notifications for the Model. Notifications are given by their names. Triggering means that the configured rules are run and notification emails are sent as defined by the rules. If the notification names parameter is not provided, all notifications in the Model are triggered.

The function return ''true'' if any notification were triggered, otherwise ''false''.
<pre>
ModelById(123).TriggerNotifications(["Notification 1", "Notification 2"]);
Triggers notifications Notification 1 and Notification 2 in model id 123.

ModelById(123).TriggerNotifications();
Triggers all notifications in model id 123.
</pre>
|-
||<span id="CheckModelValidity">CheckModelValidity</span> (Object array)
||CheckData field in dictionary
||Checks the model validity and returns found issues. The returned data is an array of objects where each object represents one validity error and contains the following properties:
* '''IssueType''' (String): Specifies the issue type.
* '''ContextType''' (String): Context in which the issue was found, and it can be '''EventDataSource''', '''CaseDataSource''', '''OcelDataSource'''.
* '''Details''' (Dictionary): Additional details which depend on the type of the issue.

There are two types of checks available (based on whether the '''CheckData''' parameter is defined):
* ''Lightweight check'': The check is based on only the configuration data stored in QPR ProcessAnalyzer. This check is very quick and does not require running queries in datasource (e.g., in Snowflake).
* ''Full check'': The check is comprehensive and it's able to detect any validity issues the model may have. The full check requires running queries to the actual data which makes the check slower, and in case of Snowflake, it uses the Snowflake warehouse to run the queries.

The lightweight check is performed automatically by the [[QPR_ProcessAnalyzer_Project_Workspace|Workspace]], so if there are any validity issues that the lightweight check can detect, the Workspace notifies about them immediately. If there are any problems with the model calculation results, it might be a good idea to run the full validity check to confirm whether the problems are due to the model being invalid.

Example: Lightweight check:
<pre>
ToJson(ModelById(1).CheckModelValidity())
</pre>

Example: Full check:
<pre>
ToJson(ModelById(1).CheckModelValidity(#{ "CheckData": true }))
</pre>
|-
||CortexAgentsQuery
||
||Creates a Snowflake Cortex semantic model (see ''GetSemanticModel'' function) for the process mining model and makes a natural language query on it using Snowflake Cortex Agents. More information: https://docs.snowflake.com/en/user-guide/snowflake-cortex/cortex-agents.

There are the following parameters:
# '''Parameters''': Dictionary parameters given to the Cortex Agents REST API query (https://docs.snowflake.com/en/user-guide/snowflake-cortex/cortex-agents-rest-api). There is a special handling for the following parameters:
#* '''model''': If not defined, uses the default Cortex Agents model name configured into the database, or if that is not defined, uses "llama3.1-70b".
#* '''_tools''': Additional tool_spec of type "cortex_analyst_text_to_sql" will be added to this value with a reference to the generated semantic model.
#* '''_tool_resources''': Generated semantic model is added as an additional resource.
# '''Filter configuration''': Can be a string containing filter JSON or a dictionary containing the filter configuration. The semantic model is created for the filtered eventlog. If not defined, the entire model eventlog will be used.
# '''Event column role nappings''': Mappings to apply for event columns. If not defined, default column mappings are used.
# '''Case column role mappings''': Mappings to apply for case columns. If not defined, default column mappings are used.

The function returns a dictionary with the following keys:
# '''Response''': Actual response as a dictionary returned by the Cortex Agents.
# '''Response items''': Contains processed response consisting of an array of objects having the following properties:
#* '''Text''': Textual response.
#* '''Sql''': Response SQL query string. Not mandatory.
#* '''SqlDataFrame''': SqlDataFrame created for the SQL query in the Sql property. Only present if Sql is present.
|-
||GetSemanticModel
||
||Creates a Snowflake Cortex Analyst semantic model for the process mining model and returns it as a dictionary. More information: https://docs.snowflake.com/en/user-guide/snowflake-cortex/cortex-analyst/semantic-model-spec.

There are the following parameters:
# '''Filter configuration''': Can be a string containing filter JSON or a dictionary containing the filter. The semantic model is created for the filtered eventlog. If not defined, the entire model eventlog will be used.
# '''Event column role mappings''': Mappings to apply for event columns. If not defined, default column mappings are used.
# '''Case column role mappings''': Mappings to apply for case columns. If not defined, default column mappings are used.

Examples: Returns a semantic model without any filtering applied.
<pre>
ModelById(1).GetSemanticModel();
</pre>
|}

Function to get Model by model id:
{| class="wikitable"
!'''Functions'''
!'''Parameters'''
! '''Description'''
|-
||ModelById
||
* Model id (Integer)
||
Returns [[QPR_ProcessAnalyzer_Objects_in_Expression_Language#Model|Model]] object corresponding to the provided model id.
|}

==Object-centric model==
Object-centric models additionally have the following properties and functions.

{| class="wikitable"
!'''Object-Centric model properties'''
! '''Description'''
|-
||IsOcelModel (boolean)
||Returns ''true'' when the model is an OCEL model.
|-
||OcelEvents (Datatable)
||Datatable containing event data for the OCEL model. Value ''null'' is returned if event datatable has not been configured for the model. Throws an unsupported operation exception if the model is not an OCEL model.
|-
||OcelEventToObject (Datatable)
||Datatable containing event-to-object relations data for the OCEL model. Value ''null'' is returned if event-to-object relation datatable has not been configured for the model. Throws an unsupported operation exception if the model is not an OCEL model.
|-
||OcelEventTypes (Dictionary)
||Returns a dictionary containing event type names as keys and the datatables holding event data for that event type in this OCEL model as value. An empty array is returned if event types datatable has not been configured for the model. Throws an unsupported operation exception if the model is not an OCEL model.

Example: Get datatable for "Create order" events:
<pre>
ModelById(1).OcelEventTypes.Get("Create order")
</pre>
|-
||OcelObjects (Datatable)
||Datatable containing objects data for the OCEL model. Value ''null'' is returned if object datatable has not been configured for the model. Throws an unsupported operation exception if the model is not an OCEL model.
|-
||OcelObjectToObject (Datatable)
||Datatable containing object-to-object relations data for the OCEL model. Value ''null'' is returned if object-to-object relation datatable has not been configured for the model. Throws an unsupported operation exception if the model is not an OCEL model.
|-
||OcelObjectTypes (Dictionary)
||Returns a dictionary containing object type names as keys and the datatables holding data for that object type in this OCEL model as value. An empty array is returned if object types have not been configured for this model. Throws an unsupported operation exception if the model is not an OCEL model.
|}

{| class="wikitable"
!'''Object-centric model functions'''
!'''Parameters'''
! '''Description'''
|-
||OcelEventType
||Event type name (String)
||
Datatable containing event type attributes of given event type in this OCEL model. Value ''null'' is returned if a datatable is not configured for this model for given event type. Throws an unsupported operation exception if the model is not an OCEL model.

Example: Get datatable for "Create order" events:
<pre>
ModelById(1).OcelEventType("Create order")
</pre>
|-
||OcelObjectType
||Object type name (String)
||Datatable containing object type attributes of given object type in this OCEL model. Value ''null'' is returned if a datatable is not configured for this model for given object type. Throws an unsupported operation exception if the model is not an OCEL model.
|-
||OcelObjectTypeConfiguration
||Object type name (String)
||Returns a matching configuration object with the following properties:<br>
# Datatable: name of the datatable
# Unit: unit label for object type items
''Null'' is returned if the given object type is not found in the model configuration.
If the object type name is not specified or ''null'', the function returns a dictionary containing configurations for all defined object types.
|}

== Project ==
{| class="wikitable"
!'''Project properties'''
! '''Description'''
|-
||CreatedBy (User)
||User who created the Project.
|-
||CreatedDate (DateTime)
||Timestamp when the Project was created.
|-
||Configuration (Dictionary)
||Project settings as Dictionary object. See example in ''ConfigurationJson'' property.
|-
||ConfigurationJson (String)
||Project settings as json string.
<pre>
{
"DefaultLocationInDataSource": {
"Database": "MyDatabase",
"Schema": "MySchema"
},
"ConnectionStringKeys": {
"Snowflake": "MyKey1",
"SqlServer": "MyKey2"
}
}
</pre>
|-
||Dashboards (Dashboard*)
||Returns all [[Dashboard_in_Expression_Language|dashboards]] in the project.
|-
||Datatables (Datatable*)
||Returns all Datatables in the project.
|-
||DeletedDate (DateTime)
||Timestamp when the Project was deleted (moved to the recycle bin).
|-
||Description (String)
||Project description. The project description may contain line breaks.
|-
||DeletedBy (User)
||User who deleted the Project (moved to the recycle bin).
|-
||Id (Integer)
||Id of the Project.
|-
||LastModifiedBy (User)
||User who last modified the Project.
|-
||LastModifiedDate (DateTime)
||Timestamp when the Project was last modified (refers to the project name, description and parent, not the contents of the project).
|-
||Name (String)
||Name of the Project.
|-
||Models (Model*)
||Models that are in the Project.
|-
||Parent (Project)
||Parent project, i.e. a Project where the Project is located in the hierarchy of Projects. Returns ''null'' for root level Projects. Throws an error if user doesn't have access to the parent project.
|-
||ParentProjectId (Integer)
||Parent project id. Returns ''null'' for root level Projects. The parent project id is returned even if user doesn't have access to the parent project.
|-
||Scripts (Script*)
||Scripts that are in the Project.
|-
||Secrets (Dictionary*)
||Returns array of all [[Storing_Secrets_for_Scripts|secrets]] in the project as Dictionary with following properties:
* '''Name''' (string): Name of the secret.
* '''Type''' (string): Type of the secret which is one of the following: "odbc", "sap", "salesforce".
|}

{| class="wikitable"
!'''Project functions'''
!'''Parameters'''
! '''Description'''
|-
||CreateDashboard (Dashboard)
||Parameters dictionary
||Creates a dashboard to the project. ''EditDashboards'' permission to the project is required. The parameter is dictionary with following supported dashboard properties:
* '''Name''' (String): Name of the dashboard.
* '''Identifier''' (String): Identifier of the dashboard.
* '''Description''' (String): Description of the dashboard.
* '''Content''' (Dictionary): Content of the dashboard.

Example: Create empty dashboard.
<pre>
ProjectById(1)
.CreateDashboard(#{
"Name": "My dashboard",
"Identifier": "MyDashboard"
});
</pre>

Example: Create dashboard with a chart.
<pre>
ProjectById(1)
.CreateDashboard(#{
"Name": "My dashboard",
"Content": #{
"version": 4,
"typeName": "View",
"name": "My dashboard",
"subElements": [
#{
"position": #{
"x": 0,
"y": 0,
"width": 0.5,
"height": 0.5,
"zOrder": 0
},
"element": #{
"typeName": "Chart",
"configuration": #{
"root": #{
"expressionType": "Cases",
"expressionParameters": #{}
},
"measures": [#{
"expressionType": "Count",
"expressionParameters": #{}
}]
}
}
}
]
}
});
</pre>
|-
||<span id="CreateDatatable">CreateDatatable</span> (Datatable)
||
* Parameters dictionary
||Creates datatable to the project. After creation, there are no columns or rows in the datatable. The function returns the created datatable entity. Following properties can be set for the datatable:
* '''Name''' (string): Name of the datatable. This parameter is mandatory.
* '''Description''' (string): Description for the datatable. This parameter is optional.
* '''NameInDataSource''' (string): Table name in the datasource (e.g., in Snowflake) which this datatable is linked to. This parameter is optional.
* '''SchemaNameInDataSource''' (string): Schema name in the datasource (e.g., in Snowflake) which this datatable is linked to. This parameter is optional.
* '''DatabaseNameInDataSource''' (string): Database name in the datasource (e.g., in Snowflake) which this datatable is linked to. This parameter is optional.
* '''Type''' (string): Defines where the data for the datatable is located. Available values are '''Snowflake''', '''SqlServer''', and '''Local'''. This parameter is optional and default value is defined by the [[PA_Configuration_database_table#General_Settings|DefaultDataSource]] setting.
* '''Connection''': Connection object for the datatable. This parameter is optional.

Example: Create a new datatable:
<pre>
ProjectById(1).CreateDatatable(#{
"Name": "My datatable"
});
</pre>

Example: Create Snowflake datatable linked to a custom table:
<pre>
ProjectById(1).CreateDatatable(#{
"Name": "My datatable",
"Description": "My description",
"NameInDataSource": "MyTable",
"SchemaNameInDataSource": "MySchema",
"DatabaseNameInDataSource": "MyDatabase",
"Type": "Snowflake"
});
</pre>

Example: Create Snowflake datatable where connection string is stored as a [[Storing_Secrets_for_Scripts|secret]]:
<pre>
ProjectById(1).CreateDatatable(#{
"Name": "My datatable",
"Type": "Snowflake",
"Connection": ProjectById(1).CreateSnowflakeConnection(#{ "OdbcConnectionStringKey": "MyKey" })
});
</pre>
|-
||CreateMeaConnection
||
||
Creates an object representing connection to QPR MEA (QPR Suite) Web Service. The parameter is an optional dictionary specifying connection parameters. Supported parameters are:
* '''ConnectionStringKey''': If given, this string will be used to connect to the target cluster using ODBC.
1. The actual value of the used QPR MEA connection string (#2603041520319#) is stored into the secure value store using "QprMea" item type.

Example to create the connection:
<pre>
let connectionObject = ProjectByName("MyProject")
.CreateMeaConnection( #{"ConnectionStringKey": "MyMeaConnection"} );
</pre>

Example to use the connection:
<pre>
connectionObject.QueryObjects(
"[PG.785401983.683494101]",
"name, typename"
);
</pre>
|-
||CreateModel (Model)
||
* Parameters dictionary
||Creates a model to a project. Requires ''GenericWrite'' permission for the Project and global ''CreateModel'' permission. If a model with that name already exists, an exception is thrown.

Parameters dictionary has the following properties:
* '''Name''': Name of the model. This property is mandatory.
* '''Description''': Description of the model. This property is optional.
* '''Configuration''': Configuration dictionary for the model. This property is technically optional, but a working model requires at least datasource settings to be defined.

Example:
<pre>
ProjectById(1).CreateModel(#{
"Name": "My model",
"Description": "My description",
"Configuration": #{
"DataSource": #{
"Cases": #{
"DataSourceType": "datatable",
"DataTableName": "My cases datatable",
"Columns": #{
"CaseId": "Case Name"
}
},
"Events": #{
"DataSourceType": "datatable",
"DataTableName": "My events datatable",
"Columns": #{
"CaseId": "Case Name",
"EventType": "Event Type",
"Timestamp": "Start Time"
}
}
}
}
});
</pre>
|-
||<span id="CreateProject">CreateProject</span> (Project)
||
* Parameters dictionary
||Create a project as a sub-project of the context project. Returns the created project. Requires the ''ManageProject'' permission.

Parameters dictionary has the following properties:
* '''Name''' (string): Name of the project. This property is required.
* '''Description''' (string): Description of the project.
* '''ParentProjectId''' (integer): Id of the parent project where the new project is created. This parameter is usually not needed because the parent project is the context project. The CreateProject function is also available in the generic context where the ''ParentProjectId'' parameter is needed to create sub-projects.
* '''DatabaseNameInDataSource''' (string): Snowflake database the project is linked to. Data for the datatables in this project will be located in this database.
* '''SchemaNameInDataSource''' (string): Snowflake schema the project is linked to. Data for the datatables in this project will be located in this schema. If the schema is defined, also the ''DatabaseNameInDataSource'' needs to be defined.
* '''SnowflakeConnectionStringKey''' (string): Snowflake connection string key to be used for the datatables in this project.

Example:
<pre>
ProjectById(1).CreateProject(#{
"Name": "My project",
"Description": "My description",
"DatabaseNameInDataSource": "My database",
"SchemaNameInDataSource": "My schema"
})
</pre>
|-
||DatatableByName (Datatable)
||Datatable name (String)
||
Returns Datatable by its name located in the project. Returns null, if Datatable with that name does not exist in the project.

Example:
<pre>
ProjectById(123).DatatableByName("MyDatatable1")
</pre>

Example: Get datatable by name, and create it if it doesn't exist:
<pre>
let project = ProjectById(123);
let datatableName = "MyDatatable1";
let datatable = project.DatatableByName(datatableName);
if (datatable == null) {
datatable = project.CreateDatatable(datatableName);
}
</pre>
|-
||DeletePermanently
||(none)
||Deletes the Project permanently. Note that the Project doesn't need to be in the recycle bin to be able to delete it permanently.
|-
||Export (String)
||(none)
||Exports the project and its content to a json string. The json format is described in [[Projects Export File Format]].

Example: Export project id 1 to json data:
<pre>
ProjectById(1).Export();
</pre>
|-
||Import
||JSON string
||Creates one or several projects from a json string. The project(s) are created as child projects of the context project. The json format is described in [[Projects Export File Format]]. The function returns the created project objects. In case the project names already exist, the import operation automatically adjusts the names to be unique.

Example: Create project from json data (as child of project id 1):
<pre>
let jsonData = `{ "Projects": [ { "Name": "My project" } ] }`;
let result = ProjectById(1).Import(jsonData);
let createdProjectId = result["Projects"][0].Id;
</pre>
|-
||Restore
||(none)
||Restores the Project from the recycle bin back to the original location.
|-
||ModelByName (Model)
||Model name (String)
||
Returns Model by its name located in the project. Returns null, if Model with that name does not exist in the project.

Example:
<pre>
ProjectById(123).ModelByName("My Model 1")
</pre>
|-
||<span id="ModifyProject">Modify</span> (Project)
||Dictionary of settings to change
||
Change project settings. Following settings are supported:
* '''Name''' (String): Name of the project.
* '''Description''' (String): Description text of the project.
* '''ParentProjectId''' (Integer): Parent project id. Changing this effectively moves the project into different parent project.
* '''DatabaseNameInDataSource''': Name of the Snowflake database where the project's datatables are located. The database needs to exist in the same Snowflake account configured in the Snowflake connection string. When defining this setting, define also the ''SchemaNameInDataSource''.
* '''SchemaNameInDataSource''': Name of the Snowflake schema where the project's datatables are located. The schema needs to exist in the same Snowflake account configured in the Snowflake connection string. When defining this setting, define also the ''DatabaseNameInDataSource''.
* '''SnowflakeConnectionStringKey''' (String): Snowflake connection string key for the project. Snowflake datatables in the project will use connection string behind this key (unless specified by the datatatable).
* '''SqlServerConnectionStringKey''' (String): SQL Server connection string key. SQL Server datatables in the project will use connection string behind this key (unless specified by the datatatable).

''ManageProject'' permission is needed to change project properties.

Example: Change project name and move project into other parent project:
<pre>
ProjectById(1)
.Modify(#{
"Name": "Project 1"
"ParentProjectId": 2
});
</pre>

Example: Set Snowflake connection string key for the project:
<pre>
ProjectById(1)
.Modify(#{
"SnowflakeConnectionStringKey": "MyKey1"
});
</pre>
|-
||ScriptByName (Script)
||Script name (String)
||
Returns Script by its name located in the project. Returns null, if Script with that name does not exist in the project.

Example:
<pre>
ProjectById(123).ScriptByName("MyScript1")
</pre>
|-
||<span id="SetSecret">SetSecret</span>
||
# Secret type (string)
# Secret name (string)
# Secret value (string)
||Sets or adds a [[Storing_Secrets_for_Scripts|secret]] for the project. Setting the secret value to ''null'' removes the secret. There can be several secrets with the same name in the same project if the type of the secret is different. Setting secrets requires the project specific ''ManageProject'' permission.

Parameters:
# '''Type''' (string): Secret type which is one of the following:
#* "externaldatatableconnection": Snowflake ODBC connection string for datatables.
#* "odbc": ODBC connection string (e.g., to extract data in scripts, or load an in-memory model).
#* "oledb": OleDB connection string (e.g., to extract data in scripts, or load an in-memory model).
#* "sap": SAP password.
#* "salesforce": Salesforce password.
#* "sql": SQL Server connection string.
#* "qprmea": QPR MEA connection string.
# '''Name''' (string): Secret name, used to refer to the secret in the commands.
# '''Value''' (string): Secret value which contains the confidential information.

Example: Set SAP password:
<pre>
ProjectById(1).SetSecret("sap", "MySapPassword", "I l0ve 5AP!");
</pre>

Example: Remove SAP password:
<pre>
ProjectById(1).SetSecret("sap", "MySapPassword", null);
</pre>
|}

Functions to get project:
{| class="wikitable"
!'''Functions'''
!'''Parameters'''
! '''Description'''
|-
||ProjectById
||Project id (Integer)
||
Returns project object corresponding to the provided project id.
|-
||ProjectByName
||Project name (String)
||
Returns project object by given project name. If there is no such project or user doesn't have access to it, ''null'' value is returned. If there are multiple projects with the same name, one of them is returned.

Example:
<pre>
let project = ProjectByName("My Project");
</pre>
|}

Functions to create project:
{| class="wikitable"
!'''Functions'''
!'''Parameters'''
! '''Description'''
|-
||<span id="CreateProject">CreateProject</span> (Project)
||Parameters dictionary
||Create a project. This is a similar function as the [[QPR_ProcessAnalyzer_Objects_in_Expression_Language#CreateProject|CreateProject function]] in the project context. This function in the generic context is needed to create root-level projects (which don't have parent project).

Example: create a root project:
<pre>
CreateProject(#{
"Name": "My project"
})
</pre>

Example: create a sub-project:
<pre>
CreateProject(#{
"Name": "My project"
"ParentProjectId": 1
})
</pre>
|-
||<span id="Import">Import</span> (Project*)
||JSON string
||Creates one or several projects from a json string. The project(s) are created as the root level projects. The json format is described in [[Projects Export File Format]]. The function returns the created project objects. In case the project names already exist, the import operation automatically adjusts the names to be unique.

Example: Create a root level project from json data:
<pre>
let jsonData = `{ "Projects": [ { "Name": "My project" } ] }`;
let result = Import(jsonData);
let createdProjectId = result["Projects"][0].Id;
</pre>
|}

== Script ==
Scripts are entities that contain executable code, that can be run. Usually scripts contains ETL routines but also other kind of tasks are possible.

{| class="wikitable"
!'''Script properties'''
! '''Description'''
|-
||Code (String)
||Script code.
|-
||CreatedBy (User)
||User who created the Script.
|-
||CreatedDate (DateTime)
||Timestamp when the Script was created.
|-
||CurrentRunStart (DateTime)
||Timestamp of the current run start. Null if the script is currently not running.
|-
||Description (String)
||Description of the Script.
|-
||Id (Integer)
||Id of the Script.
|-
||Language (String)
||Either of the following scripting language: '''Expression''' or '''SQL'''. When language is Expression, the script is run as an expression script, and when language is SQL, the script is run as an SQL script (using the sandbox database).
|-
||LastModifiedBy (User)
||User who last modified the Script.
|-
||LastModifiedDate (DateTime)
||Timestamp when the Script was last modified.
|-
||LastRunEnd (DateTime)
||Timestamp of the last completed script run end (either successful completion or failure). Null if the Script hasn't been run yet.
|-
||LastRunResult (String)
||Result of the last run. Options are:
* '''Completed''': The last run was completed successfully.
* '''Failed''': An error occurred during the last run, so likely the script did not complete as intended.
* '''Aborted''': Script run was manually stopped prematurely by a user, so the script did not proceeded in the end.

Null if the Script hasn't been run yet.
|-
||LastRunStart (DateTime)
||Timestamp of the last completed script run start time. Null if the Script hasn't been run yet.
|-
||Name (String)
||Name of the Script.
|-
||OperationId (Integer)
||Id of the operation which runs the Script. Null if the script is currently not running.
|-
||Project (Project)
||Project where the Script is located. Null if the script is in the global context.
|-
||ProjectId (Integer)
||Id of the project where the Script is located. Null if the script is in the global context.
|-
||Status (String)
||Current status of the script. Options are:
* '''Ready''': Script is not running. In this status, the script can be started (changing the status to ''Running'').
* '''Running''': Script is running. In this status, the script can be stopped (changing the status to ''Stopping''). Calling stop just requests a script to stop, and the actual stopping occurs some time later.
* '''Stopping''': Script has been requested to be stopped, but it's still running. In this status, neither start nor stop can be called for the script. When the script eventually stops, its status changes to ''Ready''.
|}

{| class="wikitable"
!'''Script functions'''
!'''Parameters'''
! '''Description'''
|-
||Run (Object)
||Dictionary of parameters
||
Runs the script using the provided parameters. The parameters are available in the script as variables (see the example). Any type of variables can be passed to the script. Note that if the script assumes certain variables, but that they are not passed to the script, the script run will throw an error.

For SQL scripts, the passed parameters are available in the script as variables in format '''@_parameter_<ParameterName>''' where <ParameterName> is the name of the parameter, e.g. ''parameter_myParameter1''. Only string type of parameters can be used, so any other type of data in parameter values is converted into strings.

The return value of the script is returned by the Run function. Expression scripts return a value with the ''return'' statement or alternatively the result of the last line of the script is the return value. If the script does not return any value, the Run function returns ''_empty''. For SQL scripts, the return value is the last dataset produced by the script (returned as a DataFrame) (SQL scripts might create several datasets using the ''--#ShowReport'' command or the ''Show'' parameter).

When a script is called using the Run function, the called script status does not change, because it's the parent script that is ''Running''. Also the called script log is not filled, but instead the logging goes to the calling script.

It's possible to call a script using the Run function several times simultaneously.

If there is an error when running the called script, the Run function throws the error to the calling script.

Scripts are run in the script entity context, so for example the following properties are available:
* Id: Script id
* Name: Script name
* Project.Id: Project id where the script is located
* Project.Name: Name of the project where the script is located

Example: Following script (id 123) raises a specified number to a specified power:
<pre>
return Pow(numberToRaise, exponent);
</pre>

The script can be called as follows (returning 16):
<pre>
let runResult = ScriptById(123).Run(#{
"numberToRaise": 4,
"exponent": 2
})
</pre>
|-
||<span id="Start">Start</span>
||Dictionary of parameters
||Starts the script. The function call doesn't wait for the script run to complete (i.e., asynchronous behavior) which is same as starting the script in the [[Managing_Scripts#Starting_Script|Workspace]].

Parameters to the script can be provided as a dictionary of name-value pairs (which is not possible when script is started in the Workspace). Return value is the script run id (integer) if the script was started. If the script is already running, return value is ''null''.

Example: Start script (without parameters) and store the script run id:
<pre>
let runId = ScriptById(1).Start();
</pre>

Example: Start script with passing parameters:
<pre>
ScriptById(1).Start(#{
"variable1": "val1",
"variable2": 5
});
</pre>
|-
||Stop
||
||Stops the script. The operation doesn't wait for the stopping to complete (i.e., asynchronous behavior) which is same as stopping the script in the [[Managing_Scripts#Stopping_Script|Workspace]]. Depending on the operation that the script is performing, the stopping might take some time.

Return value is the script run id (integer) if the script was running. If the script isn't running, the return value is ''null''.

Example:
<pre>
let runId = ScriptById(1).Stop();
</pre>
|}

Function to get a script by the script id:
{| class="wikitable"
!'''Functions'''
!'''Parameters'''
! '''Description'''
|-
||ScriptById
||
* Script id (Integer)
||
Returns Script object corresponding to the given script id. If script with the given id doesn't exist or user doesn't have permissions to it, an error is given.
|}

== User/Group ==
User objects represents users and user groups. Note that some properties can only be used for users and some for groups.

{| class="wikitable"
!'''User/group properties'''
! '''Description'''
|-
||CreatedBy (User)
||Returns the user who created the user.
|-
||CreatedDate (DateTime)
||Returns the date when the user was created.
|-
||DefaultDashboard (String)
||Returns the configured [[User_Settings#Starting_dashboard|starting dashboard]] ("default dashboard") identifier for a group (for users, the starting dashboard cannot be configured). The starting dashboard is automatically opened when a user logs in.
|-
||Description (String)
||Description of the user.
|-
||EffectiveDefaultDashboard (String)
||Returns the [[User_Settings#Starting_dashboard|starting dashboard]] of a user. Value ''null'' means that the user doesn't have a starting dashboard. The starting dashboard comes from the user's groups. If multiple of user's groups have the starting dashboard defined, the user's starting dashboard will be taken from a group having alphabetically the first name.
|-
||Email (String)
||Email address of the user.
|-
||FullName (String)
||Full name of the user or group name.
|-
||GlobalPermissions (String*)
||Array of global [[Roles and Permissions#Global_and_Project_Roles|permissions]] of the user. Global permissions come from the global roles assigned to the user and groups that the user belongs to. Note that to get the effective permissions for certain objects, also project specific permissions need to be taken into account.
|-
||GroupMemberNames (String*)
||Array of names of members of a user group. This property is available for groups.
|-
||GroupMembers (User*)
||Array of members of a user group. This property is available for groups.
|-
||GroupNames (String*)
||Array of names of user groups the user belongs to. This property is available for users.
|-
||Groups (User*)
||Array of user groups the user belongs to. This property is available for users.
|-
||HasPassword (Boolean)
||Returns true if user has a password defined in QPR ProcessAnalyzer and thus user can authenticate using the password. If user doesn't have a password, the SAML authentication is the only way to log in. ''ManageUsers'' permission is needed to access this property for other users.
|-
||Id (Integer)
||Id of the user, which is unique for every user.
|-
||IsActive (Boolean)
||Returns true only if the user is active (not disabled).
|-
||IsGroup (Boolean)
||Returns true if the user is a user group.
|-
||IsLocked (Boolean)
||Returns true if user account is currently [[User_Session_Management#Preventing_password_guessing_attacks|locked]]. ''ManageUsers'' permission is needed to access this property.
|-
||LastLockedDate (DateTime)
||Returns date when user account was locked the last time. Returns ''null'' if the user account has never been locked. ''ManageUsers'' permission is needed to access this property.
|-
||LastLoginDate (DateTime)
||Returns date when the user made last successful login. ''ManageUsers'' permission is needed to access this property for other users.
|-
||LastModifiedBy (User)
||Returns the user who last modified this user.
|-
||LastModifiedDate (DateTime)
||Returns the date when the user was last modified.
|-
||Name (String)
||Login name of the user or group.
|-
||Roles (Object**)
||
Returns all roles of the user (both global and project roles) as a nested array structure.

Example:
<pre>
ToJson(Users.Where(name == "qpr").Roles)
Returns (for example):
[
[{"calcId": "Project:1"}, "Administrator"],
[{"calcId": "Project:2"}, "Analyzer"],
[{"calcId": "Project:3"}, "Viewer"],
[null, "RunScripts"],
[null, "Administrator"]
]
</pre>
|}

{| class="wikitable"
!'''User/group functions'''
!'''Parameters'''
! '''Description'''
|-
||EffectivePermissionsFor (String Array)
||
* Project to get permissions
||
Returns effective (actual) permission of the user to the given project. Project is given as a [[#Project|project object]] (not as a project id). Effective permissions determine the actual permissions that the user has, i.e. a combination of all permissions assigned to the user and groups the user belong to, including both project specific and global roles.

Permissions for the EffectivePermissionsFor function are as follows:
* All users can query their own permissions
* To get permissions for any user, the user needs to have [[Roles_and_Permissions|ManageUsers permission]].

Note that ''inactive'' users don't have any effective permissions, so the EffectivePermissionsFor function does not return any permissions for those users.

Examples:
<pre>
UserById(1).EffectivePermissionsFor(ModelById(2).Project)
Returns (for example): ["EditDashboards", "Filtering", "GenericRead"]
</pre>
|-
||GetAttribute
||
||
Returns user attribute value by given attribute name and optionally by the model/project/dashboard context. Supported data types are String, Integer, Float, and DateTime. To store more complex data types, data can be converted into json and stored as string. If the attribute doesn't exist, null is returned.

For example, if using dashboard as context, the attributes are effectively bound to each user and each dashboard separately. Thus, there can be several attributes with the same name as long as the dashboard is different.

Parameters:
# '''Attribute name''' (String): Name of the attribute.
# '''Attribute context''' (Project/Model/Dashboard): Optional context object the attribute is linked to.

Users have permissions to get attributes for themselves, and also (administrator) users with global ''ManageUsers'' permission can get attributes for all users. In addition, if using the context object, the ''GenericRead'' permission is required for the context object.

Example: Get user attribute MyDataValue for myself:
<pre>
CurrentUser
.GetAttribute("MyDataValue");
</pre>

Example: Get user attribute MyDataValue for user John:
<pre>
Users
.Where(Name=="John")
.GetAttribute("MyDataValue");
</pre>

Example: Get user attribute MyDataValue for user 1 related to dashboard id 1:
<pre>
UserById(1)
.GetAttribute("MyDataValue", DashboardById(1));
</pre>
|-
||SetAttribute
||
||
Sets user attribute value for given attribute name and optionally for the model/project/dashboard context. Supported data types are String, Integer, Float, and DateTime. To store more complex data types, data can be converted into json and stored as string. If setting value ''null'', the user attribute is removed. Required permissions are same as in the GetAttribute function.

Parameters:
# '''Attribute name''' (String): Name of the attribute.
# '''Attribute value''' (String/Integer/Float/DateTime): Attribute value to be stored.
# '''Attribute context''' (Project/Model/Dashboard): Optional context object the attribute value is linked to.

Example: Set user attribute MyDataValue for myself:
<pre>
CurrentUser
.SetAttribute("MyDataValue ", "value");
</pre>

Example: Set value 123 as user attribute MyDataValue for user John:
<pre>
Users
.Where(Name=="John")
.SetAttribute("MyDataValue", 123);
</pre>

Example: Set current time as user attribute MyDataValue for user 1 related to dashboard id 1:
<pre>
UserById(1)
.GetAttribute("MyDataValue", Now, DashboardById(1));
</pre>
|}

Function to get User by user id:
{| class="wikitable"
!'''Functions'''
!'''Parameters'''
! '''Description'''
|-
||UserById (User)
||
* User id (Integer)
||
Returns User object that has the provided user id. Also groups can be queried with this function. Returns an access denied error if the user with given id does not exist or the current user does not have access to it.
|}

Storing Secrets for Scripts

2026-04-08T12:39:38Z

Ollvihe: /* Using secrets */