QPR ProcessAnalyzer API: Difference between revisions

From QPR ProcessAnalyzer Wiki
Jump to navigation Jump to search
 
(3 intermediate revisions by the same user not shown)
Line 66: Line 66:
def startQprProcessAnalyzerScript(serverUrl: str, username: str, password: str, scriptId: int):
def startQprProcessAnalyzerScript(serverUrl: str, username: str, password: str, scriptId: int):
   loginData = {
   loginData = {
      "grant_type": "password",
    "grant_type": "password",
      "username": username,
    "username": username,
      "password": password
    "password": password
   }
   }
   loginResponse = requests.post(
   loginResponse = requests.post(
Line 107: Line 107:
The script id can be found in the scripts list in the Workspace.
The script id can be found in the scripts list in the Workspace.


=== Synchronize users and group memberships ===
=== Synchronize users and groups ===
Following function written in Python updates QPR ProcessAnalyzer users and group memberships based on the provided dataset. This script can be extended to fetch the user data from an external source (e.g., Azure AD) to implement a complete user management integration between the systems.
Following script written in Python updates QPR ProcessAnalyzer users and groups based on the provided dataset. This script can be extended to fetch the user data from an external source (e.g., Azure AD) to implement a complete user management integration between the systems.


The script performs following steps:
This script performs following steps:
# Parse the provided dataset.
# Read the provided dataset and store it to in-memory structures.
# Read all users from QPR ProcessAnalyzer including which groups the users belong to. (POST /api/expression/query)
# Read all users from QPR ProcessAnalyzer (including which groups the users belong to). (POST /api/expression/query)
# Read all groups from QPR ProcessAnalyzer. (POST /api/expression/query)
# Read all groups from QPR ProcessAnalyzer. (POST /api/expression/query)
# Create new users (that exist in the dataset but not in QPR ProcessAnalyzer. (POST /api/users)
# Determine the gap between the current state in the user management and the provided dataset.
# Inactivate users (that don't exist dataset but do exist in QPR ProcessAnalyzer). (PUT /api/users)
# Create new users appearing in the dataset to QPR ProcessAnalyzer. (POST /api/users)
# Add users to groups they should belong to but they aren't yet members. (PUT /api/users/memberships)
# Inactivate non-existing users in the dataset from QPR ProcessAnalyzer. (PUT /api/users)
# Remove users from groups they should not belong to but they are members. (DELETE /api/users/memberships)
# Activate existing inactive users in QPR ProcessAnalyzer that exist in the dataset. (PUT /api/users)
# Add users to groups and remove from groups based on the determined gap in the state. (PUT/DELETE /api/users/memberships)


Users are queried as follows:
Users are queried as follows:
<pre>
<pre>
{
{
   "Dimensions":null,
   "Dimensions": null,
   "Values":[
   "Values": [
       {
       {
         "Name":"Id",
         "Name": "Id",
         "Expression":"ToString(Id)"
         "Expression": "Id"
       },
       },
       {
       {
         "Name":"Name",
         "Name": "Name",
         "Expression":"Name"
         "Expression": "Name"
       },
       },
       {
       {
         "Name":"Groups",
        "Name": "IsActive",
         "Expression":"ToJson(OrderByValue(Groups.Id))"
        "Expression": "IsActive"
      },
      {
         "Name": "Groups",
         "Expression": "ToJson(OrderByValue(Groups.Id))"
       }
       }
   ],
   ],
   "Root":"Users",
   "Root": "Users",
   "ContextType":"generic"
   "ContextType": "generic"
}
}
</pre>
</pre>


Groups are queries as follows:
Groups are queried as follows:
<pre>
<pre>
{
{
   "Dimensions":null,
   "Dimensions": null,
   "Values":[
   "Values": [
       {
       {
         "Name":"Id",
         "Name": "Id",
         "Expression":"Id"
         "Expression": "Id"
       },
       },
       {
       {
         "Name":"Name",
         "Name": "Name",
         "Expression":"Name"
         "Expression": "Name"
       }
       }
   ],
   ],
   "Root":"UserGroups",
   "Root": "UserGroups",
   "ContextType":"generic"
   "ContextType": "generic"
}
</pre>
 
Request /api/users/memberships body:
<pre>
{
  "GroupId": 1,
  "MemberId": 2,
  "RoleName": "Member"
}
}
</pre>
</pre>
<syntaxhighlight lang="python" line>
<syntaxhighlight lang="python" line>
...
...

Latest revision as of 19:04, 13 October 2024

QPR ProcessAnalyzer API can be used to build integrations with other applications and automate operations in the process mining system.

QPR ProcessAnalyzer API is a JSON based API following the REST design principles. All methods (except the token and serverinfo) require a prior login to establish a session. The session is initialized with the token call with username and password, and the access token is returned as a response for a successful login. The methods requiring prior authenticated session, need to have a HTTP request header Authorization with value Bearer <access token> to identify the session.

Url for calling the API has the following form (replace the server hostname with a correct one):

https://customer.onqpr.com/qprpa/api/<methodName>

Following methods are available:

Method Description
token Login user using username and password and get a session token as a response.
api/signout Logs out a user session.
api/expression Runs an expression.
api/expression/query Runs query written using the expression language and returns result data as response.
api/filters Get filters for all models or filters for a single model.
api/serverinfo Returns common system information needed by UI, such as the default UI language and in whether SSO has been configured.
api/importfile Import data into datatable from .csv, .xes or .pacm file.
api/usersettings Save user specific settings to the server.
api/operations/terminate Stops the defined tasks (by the task id) to save computing resources.
api/analysis/cancel Stops currently running tasks (by the task identifier) to save computing resources.
api/saml2/acs Identity provider (IdP) will send the SAML 2.0 assertion to this endpoint, which responses with 302 to redirect to QPR ProcessAnalyzer UI.
api/saml2 Returns the SAML 2.0 service provider (SP) metadata, if SAML 2.0 authentication has been configured.

In addition, there are methods for

Examples

Trigger script run

Following function written in Python starts a script in QPR ProcessAnalyzer by calling the REST API. The function does following: (1) login to QPR ProcessAnalyzer, (2) start the script, and (3) log out. The call just starts the script without waiting for it to complete (asynchronous behavior).

def startQprProcessAnalyzerScript(serverUrl: str, username: str, password: str, scriptId: int):
  loginData = {
    "grant_type": "password",
    "username": username,
    "password": password
  }
  loginResponse = requests.post(
    url = serverUrl + "/token",
    data = loginData
  )
  loginResponse.raise_for_status()
  sessionToken = loginResponse.json().get("access_token")
  
  startScriptResponse = requests.post(
    url = serverUrl + "/api/scripts/run/" + str(scriptId),
    headers = {
      "Authorization": "Bearer " + sessionToken,
      "Content-type": "application/json"
    }
  )
  startScriptResponse.raise_for_status()

  logOutResponse = requests.post(
    url = serverUrl + "/api/signout",
    headers = {
      "Authorization": "Bearer " + sessionToken,
      "Content-type": "application/json"
    }
  )
  logOutResponse.raise_for_status()

The function can be called as follows:

startQprProcessAnalyzerScript(
  serverUrl = "https://server.onqpr.com/qprpa",
  username = "qpr",
  password = "demo",
  scriptId = 1
)

The script id can be found in the scripts list in the Workspace.

Synchronize users and groups

Following script written in Python updates QPR ProcessAnalyzer users and groups based on the provided dataset. This script can be extended to fetch the user data from an external source (e.g., Azure AD) to implement a complete user management integration between the systems.

This script performs following steps:

  1. Read the provided dataset and store it to in-memory structures.
  2. Read all users from QPR ProcessAnalyzer (including which groups the users belong to). (POST /api/expression/query)
  3. Read all groups from QPR ProcessAnalyzer. (POST /api/expression/query)
  4. Determine the gap between the current state in the user management and the provided dataset.
  5. Create new users appearing in the dataset to QPR ProcessAnalyzer. (POST /api/users)
  6. Inactivate non-existing users in the dataset from QPR ProcessAnalyzer. (PUT /api/users)
  7. Activate existing inactive users in QPR ProcessAnalyzer that exist in the dataset. (PUT /api/users)
  8. Add users to groups and remove from groups based on the determined gap in the state. (PUT/DELETE /api/users/memberships)

Users are queried as follows:

{
   "Dimensions": null,
   "Values": [
      {
         "Name": "Id",
         "Expression": "Id"
      },
      {
         "Name": "Name",
         "Expression": "Name"
      },
      {
         "Name": "IsActive",
         "Expression": "IsActive"
      },
      {
         "Name": "Groups",
         "Expression": "ToJson(OrderByValue(Groups.Id))"
      }
   ],
   "Root": "Users",
   "ContextType": "generic"
}

Groups are queried as follows:

{
   "Dimensions": null,
   "Values": [
      {
         "Name": "Id",
         "Expression": "Id"
      },
      {
         "Name": "Name",
         "Expression": "Name"
      }
   ],
   "Root": "UserGroups",
   "ContextType": "generic"
}

Request /api/users/memberships body:

{
  "GroupId": 1,
  "MemberId": 2,
  "RoleName": "Member"
}
...