Orchestrator plugin

Default

abortWorkflow

Abort a workflow instance

Aborts a workflow instance identified by the provided instanceId.

/v2/workflows/instances/{instanceId}/abort

Usage and SDK Samples

curl -X DELETE \
 -H "Accept: text/plain,application/json" \
 "http://localhost/v2/workflows/instances/{instanceId}/abort"

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DefaultApi;

import java.io.File;
import java.util.*;

public class DefaultApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        String instanceId = instanceId_example; // String | The identifier of the workflow instance to abort.

        try {
            'String' result = apiInstance.abortWorkflow(instanceId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#abortWorkflow");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String instanceId = new String(); // String | The identifier of the workflow instance to abort.

try {
    final result = await api_instance.abortWorkflow(instanceId);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->abortWorkflow: $e\n');
}

import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String instanceId = instanceId_example; // String | The identifier of the workflow instance to abort.

        try {
            'String' result = apiInstance.abortWorkflow(instanceId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#abortWorkflow");
            e.printStackTrace();
        }
    }
}



// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
String *instanceId = instanceId_example; // The identifier of the workflow instance to abort. (default to null)

// Abort a workflow instance
[apiInstance abortWorkflowWith:instanceId
              completionHandler: ^('String' output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OrchestratorPlugin = require('orchestrator_plugin');

// Create an instance of the API class
var api = new OrchestratorPlugin.DefaultApi()
var instanceId = instanceId_example; // {String} The identifier of the workflow instance to abort.

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.abortWorkflow(instanceId, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class abortWorkflowExample
    {
        public void main()
        {

            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var instanceId = instanceId_example;  // String | The identifier of the workflow instance to abort. (default to null)

            try {
                // Abort a workflow instance
                'String' result = apiInstance.abortWorkflow(instanceId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.abortWorkflow: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$instanceId = instanceId_example; // String | The identifier of the workflow instance to abort.

try {
    $result = $api_instance->abortWorkflow($instanceId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->abortWorkflow: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::DefaultApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
my $instanceId = instanceId_example; # String | The identifier of the workflow instance to abort.

eval {
    my $result = $api_instance->abortWorkflow(instanceId => $instanceId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->abortWorkflow: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()
instanceId = instanceId_example # String | The identifier of the workflow instance to abort. (default to null)

try:
    # Abort a workflow instance
    api_response = api_instance.abort_workflow(instanceId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->abortWorkflow: %s\n" % e)

extern crate DefaultApi;

pub fn main() {
    let instanceId = instanceId_example; // String

    let mut context = DefaultApi::Context::default();
    let result = client.abortWorkflow(instanceId, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters

Name	Description
instanceId*	String The identifier of the workflow instance to abort. Required

Responses

Schema

Schema

executeWorkflow

Execute a workflow

/v2/workflows/{workflowId}/execute

Usage and SDK Samples

curl -X POST \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "http://localhost/v2/workflows/{workflowId}/execute" \
 -d '{
  "inputData" : "{}",
  "authTokens" : [ {
    "provider" : "provider",
    "token" : "token"
  }, {
    "provider" : "provider",
    "token" : "token"
  } ],
  "targetEntity" : "targetEntity"
}'

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DefaultApi;

import java.io.File;
import java.util.*;

public class DefaultApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        String workflowId = workflowId_example; // String | ID of the workflow to execute
        ExecuteWorkflowRequestDTO executeWorkflowRequestDTO = ; // ExecuteWorkflowRequestDTO | 

        try {
            ExecuteWorkflowResponseDTO result = apiInstance.executeWorkflow(workflowId, executeWorkflowRequestDTO);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#executeWorkflow");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String workflowId = new String(); // String | ID of the workflow to execute
final ExecuteWorkflowRequestDTO executeWorkflowRequestDTO = new ExecuteWorkflowRequestDTO(); // ExecuteWorkflowRequestDTO | 

try {
    final result = await api_instance.executeWorkflow(workflowId, executeWorkflowRequestDTO);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->executeWorkflow: $e\n');
}

import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String workflowId = workflowId_example; // String | ID of the workflow to execute
        ExecuteWorkflowRequestDTO executeWorkflowRequestDTO = ; // ExecuteWorkflowRequestDTO | 

        try {
            ExecuteWorkflowResponseDTO result = apiInstance.executeWorkflow(workflowId, executeWorkflowRequestDTO);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#executeWorkflow");
            e.printStackTrace();
        }
    }
}



// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
String *workflowId = workflowId_example; // ID of the workflow to execute (default to null)
ExecuteWorkflowRequestDTO *executeWorkflowRequestDTO = ; // 

// Execute a workflow
[apiInstance executeWorkflowWith:workflowId
    executeWorkflowRequestDTO:executeWorkflowRequestDTO
              completionHandler: ^(ExecuteWorkflowResponseDTO output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OrchestratorPlugin = require('orchestrator_plugin');

// Create an instance of the API class
var api = new OrchestratorPlugin.DefaultApi()
var workflowId = workflowId_example; // {String} ID of the workflow to execute
var executeWorkflowRequestDTO = ; // {ExecuteWorkflowRequestDTO} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.executeWorkflow(workflowId, executeWorkflowRequestDTO, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class executeWorkflowExample
    {
        public void main()
        {

            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var workflowId = workflowId_example;  // String | ID of the workflow to execute (default to null)
            var executeWorkflowRequestDTO = new ExecuteWorkflowRequestDTO(); // ExecuteWorkflowRequestDTO | 

            try {
                // Execute a workflow
                ExecuteWorkflowResponseDTO result = apiInstance.executeWorkflow(workflowId, executeWorkflowRequestDTO);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.executeWorkflow: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$workflowId = workflowId_example; // String | ID of the workflow to execute
$executeWorkflowRequestDTO = ; // ExecuteWorkflowRequestDTO | 

try {
    $result = $api_instance->executeWorkflow($workflowId, $executeWorkflowRequestDTO);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->executeWorkflow: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::DefaultApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
my $workflowId = workflowId_example; # String | ID of the workflow to execute
my $executeWorkflowRequestDTO = WWW::OPenAPIClient::Object::ExecuteWorkflowRequestDTO->new(); # ExecuteWorkflowRequestDTO | 

eval {
    my $result = $api_instance->executeWorkflow(workflowId => $workflowId, executeWorkflowRequestDTO => $executeWorkflowRequestDTO);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->executeWorkflow: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()
workflowId = workflowId_example # String | ID of the workflow to execute (default to null)
executeWorkflowRequestDTO =  # ExecuteWorkflowRequestDTO | 

try:
    # Execute a workflow
    api_response = api_instance.execute_workflow(workflowId, executeWorkflowRequestDTO)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->executeWorkflow: %s\n" % e)

extern crate DefaultApi;

pub fn main() {
    let workflowId = workflowId_example; // String
    let executeWorkflowRequestDTO = ; // ExecuteWorkflowRequestDTO

    let mut context = DefaultApi::Context::default();
    let result = client.executeWorkflow(workflowId, executeWorkflowRequestDTO, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters

Name	Description
workflowId*	String ID of the workflow to execute Required

Body parameters

Name	Description
executeWorkflowRequestDTO *

Responses

Schema

Schema

getInstanceById

Get Workflow Instance by ID

Get a workflow execution/run (instance)

/v2/workflows/instances/{instanceId}

Usage and SDK Samples

curl -X GET \
 -H "Accept: application/json" \
 "http://localhost/v2/workflows/instances/{instanceId}"

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DefaultApi;

import java.io.File;
import java.util.*;

public class DefaultApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        String instanceId = instanceId_example; // String | ID of the workflow instance

        try {
            ProcessInstanceDTO result = apiInstance.getInstanceById(instanceId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#getInstanceById");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String instanceId = new String(); // String | ID of the workflow instance

try {
    final result = await api_instance.getInstanceById(instanceId);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->getInstanceById: $e\n');
}

import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String instanceId = instanceId_example; // String | ID of the workflow instance

        try {
            ProcessInstanceDTO result = apiInstance.getInstanceById(instanceId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#getInstanceById");
            e.printStackTrace();
        }
    }
}



// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
String *instanceId = instanceId_example; // ID of the workflow instance (default to null)

// Get Workflow Instance by ID
[apiInstance getInstanceByIdWith:instanceId
              completionHandler: ^(ProcessInstanceDTO output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OrchestratorPlugin = require('orchestrator_plugin');

// Create an instance of the API class
var api = new OrchestratorPlugin.DefaultApi()
var instanceId = instanceId_example; // {String} ID of the workflow instance

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getInstanceById(instanceId, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class getInstanceByIdExample
    {
        public void main()
        {

            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var instanceId = instanceId_example;  // String | ID of the workflow instance (default to null)

            try {
                // Get Workflow Instance by ID
                ProcessInstanceDTO result = apiInstance.getInstanceById(instanceId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.getInstanceById: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$instanceId = instanceId_example; // String | ID of the workflow instance

try {
    $result = $api_instance->getInstanceById($instanceId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->getInstanceById: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::DefaultApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
my $instanceId = instanceId_example; # String | ID of the workflow instance

eval {
    my $result = $api_instance->getInstanceById(instanceId => $instanceId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->getInstanceById: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()
instanceId = instanceId_example # String | ID of the workflow instance (default to null)

try:
    # Get Workflow Instance by ID
    api_response = api_instance.get_instance_by_id(instanceId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->getInstanceById: %s\n" % e)

extern crate DefaultApi;

pub fn main() {
    let instanceId = instanceId_example; // String

    let mut context = DefaultApi::Context::default();
    let result = client.getInstanceById(instanceId, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters

Name	Description
instanceId*	String ID of the workflow instance Required

Responses

Schema

Schema

getInstances

Get instances

Retrieve an array of workflow executions (instances)

/v2/workflows/instances

Usage and SDK Samples

curl -X POST \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "http://localhost/v2/workflows/instances" \
 -d '{
  "paginationInfo" : {
    "offset" : 1.4658129805029452,
    "pageSize" : 6.027456183070403,
    "orderDirection" : "ASC",
    "orderBy" : "orderBy"
  },
  "filters" : {
    "filters" : [ null, null ],
    "operator" : "AND"
  }
}'

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DefaultApi;

import java.io.File;
import java.util.*;

public class DefaultApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        SearchRequest searchRequest = ; // SearchRequest | 

        try {
            ProcessInstanceListResultDTO result = apiInstance.getInstances(searchRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#getInstances");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final SearchRequest searchRequest = new SearchRequest(); // SearchRequest | 

try {
    final result = await api_instance.getInstances(searchRequest);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->getInstances: $e\n');
}

import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        SearchRequest searchRequest = ; // SearchRequest | 

        try {
            ProcessInstanceListResultDTO result = apiInstance.getInstances(searchRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#getInstances");
            e.printStackTrace();
        }
    }
}



// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
SearchRequest *searchRequest = ; //  (optional)

// Get instances
[apiInstance getInstancesWith:searchRequest
              completionHandler: ^(ProcessInstanceListResultDTO output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OrchestratorPlugin = require('orchestrator_plugin');

// Create an instance of the API class
var api = new OrchestratorPlugin.DefaultApi()
var opts = {
  'searchRequest':  // {SearchRequest} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getInstances(opts, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class getInstancesExample
    {
        public void main()
        {

            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var searchRequest = new SearchRequest(); // SearchRequest |  (optional) 

            try {
                // Get instances
                ProcessInstanceListResultDTO result = apiInstance.getInstances(searchRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.getInstances: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$searchRequest = ; // SearchRequest | 

try {
    $result = $api_instance->getInstances($searchRequest);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->getInstances: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::DefaultApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
my $searchRequest = WWW::OPenAPIClient::Object::SearchRequest->new(); # SearchRequest | 

eval {
    my $result = $api_instance->getInstances(searchRequest => $searchRequest);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->getInstances: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()
searchRequest =  # SearchRequest |  (optional)

try:
    # Get instances
    api_response = api_instance.get_instances(searchRequest=searchRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->getInstances: %s\n" % e)

extern crate DefaultApi;

pub fn main() {
    let searchRequest = ; // SearchRequest

    let mut context = DefaultApi::Context::default();
    let result = client.getInstances(searchRequest, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Body parameters

Name	Description
searchRequest	Parameters for retrieving instances

Responses

Schema

Schema

getWorkflowInputSchemaById

Get the workflow input schema. It defines the input fields of the workflow

/v2/workflows/{workflowId}/inputSchema

Usage and SDK Samples

curl -X GET \
 -H "Accept: application/json" \
 "http://localhost/v2/workflows/{workflowId}/inputSchema?instanceId=instanceId_example"

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DefaultApi;

import java.io.File;
import java.util.*;

public class DefaultApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        String workflowId = workflowId_example; // String | ID of the workflow to fetch
        String instanceId = instanceId_example; // String | ID of instance

        try {
            InputSchemaResponseDTO result = apiInstance.getWorkflowInputSchemaById(workflowId, instanceId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#getWorkflowInputSchemaById");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String workflowId = new String(); // String | ID of the workflow to fetch
final String instanceId = new String(); // String | ID of instance

try {
    final result = await api_instance.getWorkflowInputSchemaById(workflowId, instanceId);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->getWorkflowInputSchemaById: $e\n');
}

import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String workflowId = workflowId_example; // String | ID of the workflow to fetch
        String instanceId = instanceId_example; // String | ID of instance

        try {
            InputSchemaResponseDTO result = apiInstance.getWorkflowInputSchemaById(workflowId, instanceId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#getWorkflowInputSchemaById");
            e.printStackTrace();
        }
    }
}



// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
String *workflowId = workflowId_example; // ID of the workflow to fetch (default to null)
String *instanceId = instanceId_example; // ID of instance (optional) (default to null)

[apiInstance getWorkflowInputSchemaByIdWith:workflowId
    instanceId:instanceId
              completionHandler: ^(InputSchemaResponseDTO output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OrchestratorPlugin = require('orchestrator_plugin');

// Create an instance of the API class
var api = new OrchestratorPlugin.DefaultApi()
var workflowId = workflowId_example; // {String} ID of the workflow to fetch
var opts = {
  'instanceId': instanceId_example // {String} ID of instance
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getWorkflowInputSchemaById(workflowId, opts, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class getWorkflowInputSchemaByIdExample
    {
        public void main()
        {

            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var workflowId = workflowId_example;  // String | ID of the workflow to fetch (default to null)
            var instanceId = instanceId_example;  // String | ID of instance (optional)  (default to null)

            try {
                InputSchemaResponseDTO result = apiInstance.getWorkflowInputSchemaById(workflowId, instanceId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.getWorkflowInputSchemaById: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$workflowId = workflowId_example; // String | ID of the workflow to fetch
$instanceId = instanceId_example; // String | ID of instance

try {
    $result = $api_instance->getWorkflowInputSchemaById($workflowId, $instanceId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->getWorkflowInputSchemaById: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::DefaultApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
my $workflowId = workflowId_example; # String | ID of the workflow to fetch
my $instanceId = instanceId_example; # String | ID of instance

eval {
    my $result = $api_instance->getWorkflowInputSchemaById(workflowId => $workflowId, instanceId => $instanceId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->getWorkflowInputSchemaById: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()
workflowId = workflowId_example # String | ID of the workflow to fetch (default to null)
instanceId = instanceId_example # String | ID of instance (optional) (default to null)

try:
    api_response = api_instance.get_workflow_input_schema_by_id(workflowId, instanceId=instanceId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->getWorkflowInputSchemaById: %s\n" % e)

extern crate DefaultApi;

pub fn main() {
    let workflowId = workflowId_example; // String
    let instanceId = instanceId_example; // String

    let mut context = DefaultApi::Context::default();
    let result = client.getWorkflowInputSchemaById(workflowId, instanceId, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters

Name	Description
workflowId*	String ID of the workflow to fetch Required

Query parameters

Name	Description
instanceId	String ID of instance

Responses

Schema

Schema

getWorkflowInstances

Get instances for a specific workflow

Retrieve an array of workflow executions (instances) for the given workflow

/v2/workflows/{workflowId}/instances

Usage and SDK Samples

curl -X POST \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "http://localhost/v2/workflows/{workflowId}/instances" \
 -d '{
  "paginationInfo" : {
    "offset" : 1.4658129805029452,
    "pageSize" : 6.027456183070403,
    "orderDirection" : "ASC",
    "orderBy" : "orderBy"
  },
  "filters" : {
    "filters" : [ null, null ],
    "operator" : "AND"
  }
}'

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DefaultApi;

import java.io.File;
import java.util.*;

public class DefaultApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        String workflowId = workflowId_example; // String | ID of the workflow
        SearchRequest searchRequest = ; // SearchRequest | 

        try {
            ProcessInstanceListResultDTO result = apiInstance.getWorkflowInstances(workflowId, searchRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#getWorkflowInstances");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String workflowId = new String(); // String | ID of the workflow
final SearchRequest searchRequest = new SearchRequest(); // SearchRequest | 

try {
    final result = await api_instance.getWorkflowInstances(workflowId, searchRequest);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->getWorkflowInstances: $e\n');
}

import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String workflowId = workflowId_example; // String | ID of the workflow
        SearchRequest searchRequest = ; // SearchRequest | 

        try {
            ProcessInstanceListResultDTO result = apiInstance.getWorkflowInstances(workflowId, searchRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#getWorkflowInstances");
            e.printStackTrace();
        }
    }
}



// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
String *workflowId = workflowId_example; // ID of the workflow (default to null)
SearchRequest *searchRequest = ; //  (optional)

// Get instances for a specific workflow
[apiInstance getWorkflowInstancesWith:workflowId
    searchRequest:searchRequest
              completionHandler: ^(ProcessInstanceListResultDTO output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OrchestratorPlugin = require('orchestrator_plugin');

// Create an instance of the API class
var api = new OrchestratorPlugin.DefaultApi()
var workflowId = workflowId_example; // {String} ID of the workflow
var opts = {
  'searchRequest':  // {SearchRequest} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getWorkflowInstances(workflowId, opts, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class getWorkflowInstancesExample
    {
        public void main()
        {

            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var workflowId = workflowId_example;  // String | ID of the workflow (default to null)
            var searchRequest = new SearchRequest(); // SearchRequest |  (optional) 

            try {
                // Get instances for a specific workflow
                ProcessInstanceListResultDTO result = apiInstance.getWorkflowInstances(workflowId, searchRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.getWorkflowInstances: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$workflowId = workflowId_example; // String | ID of the workflow
$searchRequest = ; // SearchRequest | 

try {
    $result = $api_instance->getWorkflowInstances($workflowId, $searchRequest);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->getWorkflowInstances: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::DefaultApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
my $workflowId = workflowId_example; # String | ID of the workflow
my $searchRequest = WWW::OPenAPIClient::Object::SearchRequest->new(); # SearchRequest | 

eval {
    my $result = $api_instance->getWorkflowInstances(workflowId => $workflowId, searchRequest => $searchRequest);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->getWorkflowInstances: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()
workflowId = workflowId_example # String | ID of the workflow (default to null)
searchRequest =  # SearchRequest |  (optional)

try:
    # Get instances for a specific workflow
    api_response = api_instance.get_workflow_instances(workflowId, searchRequest=searchRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->getWorkflowInstances: %s\n" % e)

extern crate DefaultApi;

pub fn main() {
    let workflowId = workflowId_example; // String
    let searchRequest = ; // SearchRequest

    let mut context = DefaultApi::Context::default();
    let result = client.getWorkflowInstances(workflowId, searchRequest, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters

Name	Description
workflowId*	String ID of the workflow Required

Body parameters

Name	Description
searchRequest	Parameters for retrieving workflow instances

Responses

Schema

Schema

getWorkflowOverviewById

Returns the key fields of the workflow including data on the last run instance

/v2/workflows/{workflowId}/overview

Usage and SDK Samples

curl -X GET \
 -H "Accept: application/json" \
 "http://localhost/v2/workflows/{workflowId}/overview"

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DefaultApi;

import java.io.File;
import java.util.*;

public class DefaultApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        String workflowId = workflowId_example; // String | Unique identifier of the workflow

        try {
            WorkflowOverviewDTO result = apiInstance.getWorkflowOverviewById(workflowId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#getWorkflowOverviewById");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String workflowId = new String(); // String | Unique identifier of the workflow

try {
    final result = await api_instance.getWorkflowOverviewById(workflowId);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->getWorkflowOverviewById: $e\n');
}

import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String workflowId = workflowId_example; // String | Unique identifier of the workflow

        try {
            WorkflowOverviewDTO result = apiInstance.getWorkflowOverviewById(workflowId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#getWorkflowOverviewById");
            e.printStackTrace();
        }
    }
}



// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
String *workflowId = workflowId_example; // Unique identifier of the workflow (default to null)

[apiInstance getWorkflowOverviewByIdWith:workflowId
              completionHandler: ^(WorkflowOverviewDTO output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OrchestratorPlugin = require('orchestrator_plugin');

// Create an instance of the API class
var api = new OrchestratorPlugin.DefaultApi()
var workflowId = workflowId_example; // {String} Unique identifier of the workflow

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getWorkflowOverviewById(workflowId, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class getWorkflowOverviewByIdExample
    {
        public void main()
        {

            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var workflowId = workflowId_example;  // String | Unique identifier of the workflow (default to null)

            try {
                WorkflowOverviewDTO result = apiInstance.getWorkflowOverviewById(workflowId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.getWorkflowOverviewById: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$workflowId = workflowId_example; // String | Unique identifier of the workflow

try {
    $result = $api_instance->getWorkflowOverviewById($workflowId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->getWorkflowOverviewById: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::DefaultApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
my $workflowId = workflowId_example; # String | Unique identifier of the workflow

eval {
    my $result = $api_instance->getWorkflowOverviewById(workflowId => $workflowId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->getWorkflowOverviewById: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()
workflowId = workflowId_example # String | Unique identifier of the workflow (default to null)

try:
    api_response = api_instance.get_workflow_overview_by_id(workflowId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->getWorkflowOverviewById: %s\n" % e)

extern crate DefaultApi;

pub fn main() {
    let workflowId = workflowId_example; // String

    let mut context = DefaultApi::Context::default();
    let result = client.getWorkflowOverviewById(workflowId, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters

Name	Description
workflowId*	String Unique identifier of the workflow Required

Responses

Schema

Schema

getWorkflowSourceById

Get the workflow's definition

/v2/workflows/{workflowId}/source

Usage and SDK Samples

curl -X GET \
 -H "Accept: text/plain,application/json" \
 "http://localhost/v2/workflows/{workflowId}/source"

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DefaultApi;

import java.io.File;
import java.util.*;

public class DefaultApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        String workflowId = workflowId_example; // String | ID of the workflow to fetch

        try {
            'String' result = apiInstance.getWorkflowSourceById(workflowId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#getWorkflowSourceById");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String workflowId = new String(); // String | ID of the workflow to fetch

try {
    final result = await api_instance.getWorkflowSourceById(workflowId);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->getWorkflowSourceById: $e\n');
}

import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String workflowId = workflowId_example; // String | ID of the workflow to fetch

        try {
            'String' result = apiInstance.getWorkflowSourceById(workflowId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#getWorkflowSourceById");
            e.printStackTrace();
        }
    }
}



// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
String *workflowId = workflowId_example; // ID of the workflow to fetch (default to null)

[apiInstance getWorkflowSourceByIdWith:workflowId
              completionHandler: ^('String' output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OrchestratorPlugin = require('orchestrator_plugin');

// Create an instance of the API class
var api = new OrchestratorPlugin.DefaultApi()
var workflowId = workflowId_example; // {String} ID of the workflow to fetch

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getWorkflowSourceById(workflowId, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class getWorkflowSourceByIdExample
    {
        public void main()
        {

            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var workflowId = workflowId_example;  // String | ID of the workflow to fetch (default to null)

            try {
                'String' result = apiInstance.getWorkflowSourceById(workflowId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.getWorkflowSourceById: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$workflowId = workflowId_example; // String | ID of the workflow to fetch

try {
    $result = $api_instance->getWorkflowSourceById($workflowId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->getWorkflowSourceById: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::DefaultApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
my $workflowId = workflowId_example; # String | ID of the workflow to fetch

eval {
    my $result = $api_instance->getWorkflowSourceById(workflowId => $workflowId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->getWorkflowSourceById: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()
workflowId = workflowId_example # String | ID of the workflow to fetch (default to null)

try:
    api_response = api_instance.get_workflow_source_by_id(workflowId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->getWorkflowSourceById: %s\n" % e)

extern crate DefaultApi;

pub fn main() {
    let workflowId = workflowId_example; // String

    let mut context = DefaultApi::Context::default();
    let result = client.getWorkflowSourceById(workflowId, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters

Name	Description
workflowId*	String ID of the workflow to fetch Required

Responses

Schema

Schema

getWorkflowStatuses

Get workflow status list

Retrieve array with the status of all instances

/v2/workflows/instances/statuses

Usage and SDK Samples

curl -X GET \
 -H "Accept: application/json" \
 "http://localhost/v2/workflows/instances/statuses"

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DefaultApi;

import java.io.File;
import java.util.*;

public class DefaultApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();

        try {
            array[WorkflowRunStatusDTO] result = apiInstance.getWorkflowStatuses();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#getWorkflowStatuses");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();


try {
    final result = await api_instance.getWorkflowStatuses();
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->getWorkflowStatuses: $e\n');
}

import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();

        try {
            array[WorkflowRunStatusDTO] result = apiInstance.getWorkflowStatuses();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#getWorkflowStatuses");
            e.printStackTrace();
        }
    }
}



// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];

// Get workflow status list
[apiInstance getWorkflowStatusesWithCompletionHandler: 
              ^(array[WorkflowRunStatusDTO] output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OrchestratorPlugin = require('orchestrator_plugin');

// Create an instance of the API class
var api = new OrchestratorPlugin.DefaultApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getWorkflowStatuses(callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class getWorkflowStatusesExample
    {
        public void main()
        {

            // Create an instance of the API class
            var apiInstance = new DefaultApi();

            try {
                // Get workflow status list
                array[WorkflowRunStatusDTO] result = apiInstance.getWorkflowStatuses();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.getWorkflowStatuses: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();

try {
    $result = $api_instance->getWorkflowStatuses();
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->getWorkflowStatuses: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::DefaultApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DefaultApi->new();

eval {
    my $result = $api_instance->getWorkflowStatuses();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->getWorkflowStatuses: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()

try:
    # Get workflow status list
    api_response = api_instance.get_workflow_statuses()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->getWorkflowStatuses: %s\n" % e)

extern crate DefaultApi;

pub fn main() {

    let mut context = DefaultApi::Context::default();
    let result = client.getWorkflowStatuses(&context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Responses

Schema

Schema

getWorkflowsOverview

Returns the key fields of the workflow including data on the last run instance

/v2/workflows/overview

Usage and SDK Samples

curl -X POST \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "http://localhost/v2/workflows/overview" \
 -d '{
  "paginationInfo" : {
    "offset" : 1.4658129805029452,
    "pageSize" : 6.027456183070403,
    "orderDirection" : "ASC",
    "orderBy" : "orderBy"
  },
  "filters" : {
    "filters" : [ null, null ],
    "operator" : "AND"
  }
}'

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DefaultApi;

import java.io.File;
import java.util.*;

public class DefaultApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        SearchRequest searchRequest = ; // SearchRequest | 

        try {
            WorkflowOverviewListResultDTO result = apiInstance.getWorkflowsOverview(searchRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#getWorkflowsOverview");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final SearchRequest searchRequest = new SearchRequest(); // SearchRequest | 

try {
    final result = await api_instance.getWorkflowsOverview(searchRequest);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->getWorkflowsOverview: $e\n');
}

import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        SearchRequest searchRequest = ; // SearchRequest | 

        try {
            WorkflowOverviewListResultDTO result = apiInstance.getWorkflowsOverview(searchRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#getWorkflowsOverview");
            e.printStackTrace();
        }
    }
}



// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
SearchRequest *searchRequest = ; //  (optional)

[apiInstance getWorkflowsOverviewWith:searchRequest
              completionHandler: ^(WorkflowOverviewListResultDTO output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OrchestratorPlugin = require('orchestrator_plugin');

// Create an instance of the API class
var api = new OrchestratorPlugin.DefaultApi()
var opts = {
  'searchRequest':  // {SearchRequest} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getWorkflowsOverview(opts, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class getWorkflowsOverviewExample
    {
        public void main()
        {

            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var searchRequest = new SearchRequest(); // SearchRequest |  (optional) 

            try {
                WorkflowOverviewListResultDTO result = apiInstance.getWorkflowsOverview(searchRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.getWorkflowsOverview: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$searchRequest = ; // SearchRequest | 

try {
    $result = $api_instance->getWorkflowsOverview($searchRequest);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->getWorkflowsOverview: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::DefaultApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
my $searchRequest = WWW::OPenAPIClient::Object::SearchRequest->new(); # SearchRequest | 

eval {
    my $result = $api_instance->getWorkflowsOverview(searchRequest => $searchRequest);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->getWorkflowsOverview: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()
searchRequest =  # SearchRequest |  (optional)

try:
    api_response = api_instance.get_workflows_overview(searchRequest=searchRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->getWorkflowsOverview: %s\n" % e)

extern crate DefaultApi;

pub fn main() {
    let searchRequest = ; // SearchRequest

    let mut context = DefaultApi::Context::default();
    let result = client.getWorkflowsOverview(searchRequest, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Body parameters

Name	Description
searchRequest	Pagination and filters

Responses

Schema

Schema

getWorkflowsOverviewForEntity

Returns the key fields of the workflow including data on the last run instance

/v2/workflows/overview/entity

Usage and SDK Samples

curl -X POST \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "http://localhost/v2/workflows/overview/entity" \
 -d ''

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DefaultApi;

import java.io.File;
import java.util.*;

public class DefaultApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        GetWorkflowsOverviewForEntityRequest getWorkflowsOverviewForEntityRequest = ; // GetWorkflowsOverviewForEntityRequest | 

        try {
            WorkflowOverviewListResultDTO result = apiInstance.getWorkflowsOverviewForEntity(getWorkflowsOverviewForEntityRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#getWorkflowsOverviewForEntity");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final GetWorkflowsOverviewForEntityRequest getWorkflowsOverviewForEntityRequest = new GetWorkflowsOverviewForEntityRequest(); // GetWorkflowsOverviewForEntityRequest | 

try {
    final result = await api_instance.getWorkflowsOverviewForEntity(getWorkflowsOverviewForEntityRequest);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->getWorkflowsOverviewForEntity: $e\n');
}

import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        GetWorkflowsOverviewForEntityRequest getWorkflowsOverviewForEntityRequest = ; // GetWorkflowsOverviewForEntityRequest | 

        try {
            WorkflowOverviewListResultDTO result = apiInstance.getWorkflowsOverviewForEntity(getWorkflowsOverviewForEntityRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#getWorkflowsOverviewForEntity");
            e.printStackTrace();
        }
    }
}



// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
GetWorkflowsOverviewForEntityRequest *getWorkflowsOverviewForEntityRequest = ; //  (optional)

[apiInstance getWorkflowsOverviewForEntityWith:getWorkflowsOverviewForEntityRequest
              completionHandler: ^(WorkflowOverviewListResultDTO output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OrchestratorPlugin = require('orchestrator_plugin');

// Create an instance of the API class
var api = new OrchestratorPlugin.DefaultApi()
var opts = {
  'getWorkflowsOverviewForEntityRequest':  // {GetWorkflowsOverviewForEntityRequest} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getWorkflowsOverviewForEntity(opts, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class getWorkflowsOverviewForEntityExample
    {
        public void main()
        {

            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var getWorkflowsOverviewForEntityRequest = new GetWorkflowsOverviewForEntityRequest(); // GetWorkflowsOverviewForEntityRequest |  (optional) 

            try {
                WorkflowOverviewListResultDTO result = apiInstance.getWorkflowsOverviewForEntity(getWorkflowsOverviewForEntityRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.getWorkflowsOverviewForEntity: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$getWorkflowsOverviewForEntityRequest = ; // GetWorkflowsOverviewForEntityRequest | 

try {
    $result = $api_instance->getWorkflowsOverviewForEntity($getWorkflowsOverviewForEntityRequest);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->getWorkflowsOverviewForEntity: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::DefaultApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
my $getWorkflowsOverviewForEntityRequest = WWW::OPenAPIClient::Object::GetWorkflowsOverviewForEntityRequest->new(); # GetWorkflowsOverviewForEntityRequest | 

eval {
    my $result = $api_instance->getWorkflowsOverviewForEntity(getWorkflowsOverviewForEntityRequest => $getWorkflowsOverviewForEntityRequest);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->getWorkflowsOverviewForEntity: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()
getWorkflowsOverviewForEntityRequest =  # GetWorkflowsOverviewForEntityRequest |  (optional)

try:
    api_response = api_instance.get_workflows_overview_for_entity(getWorkflowsOverviewForEntityRequest=getWorkflowsOverviewForEntityRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->getWorkflowsOverviewForEntity: %s\n" % e)

extern crate DefaultApi;

pub fn main() {
    let getWorkflowsOverviewForEntityRequest = ; // GetWorkflowsOverviewForEntityRequest

    let mut context = DefaultApi::Context::default();
    let result = client.getWorkflowsOverviewForEntity(getWorkflowsOverviewForEntityRequest, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Body parameters

Name	Description
getWorkflowsOverviewForEntityRequest	Target entity reference and annotation workflow ids

Responses

Schema

Schema

pingWorkflowServiceById

Returns true if the workflow service is up for the given workflow ID.

/v2/workflows/{workflowId}/pingWorkflowService

Usage and SDK Samples

curl -X GET \
 -H "Accept: application/json" \
 "http://localhost/v2/workflows/{workflowId}/pingWorkflowService"

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DefaultApi;

import java.io.File;
import java.util.*;

public class DefaultApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        String workflowId = workflowId_example; // String | ID of the workflow to fetch

        try {
            'Boolean' result = apiInstance.pingWorkflowServiceById(workflowId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#pingWorkflowServiceById");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String workflowId = new String(); // String | ID of the workflow to fetch

try {
    final result = await api_instance.pingWorkflowServiceById(workflowId);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->pingWorkflowServiceById: $e\n');
}

import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String workflowId = workflowId_example; // String | ID of the workflow to fetch

        try {
            'Boolean' result = apiInstance.pingWorkflowServiceById(workflowId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#pingWorkflowServiceById");
            e.printStackTrace();
        }
    }
}



// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
String *workflowId = workflowId_example; // ID of the workflow to fetch (default to null)

[apiInstance pingWorkflowServiceByIdWith:workflowId
              completionHandler: ^('Boolean' output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OrchestratorPlugin = require('orchestrator_plugin');

// Create an instance of the API class
var api = new OrchestratorPlugin.DefaultApi()
var workflowId = workflowId_example; // {String} ID of the workflow to fetch

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.pingWorkflowServiceById(workflowId, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class pingWorkflowServiceByIdExample
    {
        public void main()
        {

            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var workflowId = workflowId_example;  // String | ID of the workflow to fetch (default to null)

            try {
                'Boolean' result = apiInstance.pingWorkflowServiceById(workflowId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.pingWorkflowServiceById: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$workflowId = workflowId_example; // String | ID of the workflow to fetch

try {
    $result = $api_instance->pingWorkflowServiceById($workflowId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->pingWorkflowServiceById: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::DefaultApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
my $workflowId = workflowId_example; # String | ID of the workflow to fetch

eval {
    my $result = $api_instance->pingWorkflowServiceById(workflowId => $workflowId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->pingWorkflowServiceById: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()
workflowId = workflowId_example # String | ID of the workflow to fetch (default to null)

try:
    api_response = api_instance.ping_workflow_service_by_id(workflowId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->pingWorkflowServiceById: %s\n" % e)

extern crate DefaultApi;

pub fn main() {
    let workflowId = workflowId_example; // String

    let mut context = DefaultApi::Context::default();
    let result = client.pingWorkflowServiceById(workflowId, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters

Name	Description
workflowId*	String ID of the workflow to fetch Required

Responses

Schema

Schema

retriggerInstance

Retrigger an instance

/v2/workflows/{workflowId}/{instanceId}/retrigger

Usage and SDK Samples

curl -X POST \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "http://localhost/v2/workflows/{workflowId}/{instanceId}/retrigger" \
 -d '{
  "authTokens" : [ {
    "provider" : "provider",
    "token" : "token"
  }, {
    "provider" : "provider",
    "token" : "token"
  } ]
}'

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DefaultApi;

import java.io.File;
import java.util.*;

public class DefaultApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        DefaultApi apiInstance = new DefaultApi();
        String workflowId = workflowId_example; // String | ID of the workflow
        String instanceId = instanceId_example; // String | ID of the instance to retrigger
        RetriggerInstanceRequestDTO retriggerInstanceRequestDTO = ; // RetriggerInstanceRequestDTO | 

        try {
            Object result = apiInstance.retriggerInstance(workflowId, instanceId, retriggerInstanceRequestDTO);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#retriggerInstance");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String workflowId = new String(); // String | ID of the workflow
final String instanceId = new String(); // String | ID of the instance to retrigger
final RetriggerInstanceRequestDTO retriggerInstanceRequestDTO = new RetriggerInstanceRequestDTO(); // RetriggerInstanceRequestDTO | 

try {
    final result = await api_instance.retriggerInstance(workflowId, instanceId, retriggerInstanceRequestDTO);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->retriggerInstance: $e\n');
}

import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String workflowId = workflowId_example; // String | ID of the workflow
        String instanceId = instanceId_example; // String | ID of the instance to retrigger
        RetriggerInstanceRequestDTO retriggerInstanceRequestDTO = ; // RetriggerInstanceRequestDTO | 

        try {
            Object result = apiInstance.retriggerInstance(workflowId, instanceId, retriggerInstanceRequestDTO);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#retriggerInstance");
            e.printStackTrace();
        }
    }
}



// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
String *workflowId = workflowId_example; // ID of the workflow (default to null)
String *instanceId = instanceId_example; // ID of the instance to retrigger (default to null)
RetriggerInstanceRequestDTO *retriggerInstanceRequestDTO = ; // 

// Retrigger an instance
[apiInstance retriggerInstanceWith:workflowId
    instanceId:instanceId
    retriggerInstanceRequestDTO:retriggerInstanceRequestDTO
              completionHandler: ^(Object output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OrchestratorPlugin = require('orchestrator_plugin');

// Create an instance of the API class
var api = new OrchestratorPlugin.DefaultApi()
var workflowId = workflowId_example; // {String} ID of the workflow
var instanceId = instanceId_example; // {String} ID of the instance to retrigger
var retriggerInstanceRequestDTO = ; // {RetriggerInstanceRequestDTO} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.retriggerInstance(workflowId, instanceId, retriggerInstanceRequestDTO, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class retriggerInstanceExample
    {
        public void main()
        {

            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var workflowId = workflowId_example;  // String | ID of the workflow (default to null)
            var instanceId = instanceId_example;  // String | ID of the instance to retrigger (default to null)
            var retriggerInstanceRequestDTO = new RetriggerInstanceRequestDTO(); // RetriggerInstanceRequestDTO | 

            try {
                // Retrigger an instance
                Object result = apiInstance.retriggerInstance(workflowId, instanceId, retriggerInstanceRequestDTO);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.retriggerInstance: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$workflowId = workflowId_example; // String | ID of the workflow
$instanceId = instanceId_example; // String | ID of the instance to retrigger
$retriggerInstanceRequestDTO = ; // RetriggerInstanceRequestDTO | 

try {
    $result = $api_instance->retriggerInstance($workflowId, $instanceId, $retriggerInstanceRequestDTO);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->retriggerInstance: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::DefaultApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DefaultApi->new();
my $workflowId = workflowId_example; # String | ID of the workflow
my $instanceId = instanceId_example; # String | ID of the instance to retrigger
my $retriggerInstanceRequestDTO = WWW::OPenAPIClient::Object::RetriggerInstanceRequestDTO->new(); # RetriggerInstanceRequestDTO | 

eval {
    my $result = $api_instance->retriggerInstance(workflowId => $workflowId, instanceId => $instanceId, retriggerInstanceRequestDTO => $retriggerInstanceRequestDTO);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->retriggerInstance: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Create an instance of the API class
api_instance = openapi_client.DefaultApi()
workflowId = workflowId_example # String | ID of the workflow (default to null)
instanceId = instanceId_example # String | ID of the instance to retrigger (default to null)
retriggerInstanceRequestDTO =  # RetriggerInstanceRequestDTO | 

try:
    # Retrigger an instance
    api_response = api_instance.retrigger_instance(workflowId, instanceId, retriggerInstanceRequestDTO)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->retriggerInstance: %s\n" % e)

extern crate DefaultApi;

pub fn main() {
    let workflowId = workflowId_example; // String
    let instanceId = instanceId_example; // String
    let retriggerInstanceRequestDTO = ; // RetriggerInstanceRequestDTO

    let mut context = DefaultApi::Context::default();
    let result = client.retriggerInstance(workflowId, instanceId, retriggerInstanceRequestDTO, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters

Name	Description
workflowId*	String ID of the workflow Required
instanceId*	String ID of the instance to retrigger Required

Body parameters

Name	Description
retriggerInstanceRequestDTO *

Responses

Schema

Schema

Orchestrator plugin

API and SDK Documentation

Default

abortWorkflow

Usage and SDK Samples

Scopes

Parameters

Responses

executeWorkflow

Usage and SDK Samples

Scopes

Parameters

Responses

getInstanceById

Usage and SDK Samples

Scopes

Parameters

Responses

getInstances

Usage and SDK Samples

Scopes

Parameters

Responses

getWorkflowInputSchemaById

Usage and SDK Samples

Scopes

Parameters

Responses

getWorkflowInstances

Usage and SDK Samples

Scopes

Parameters

Responses

getWorkflowOverviewById

Usage and SDK Samples

Scopes

Parameters

Responses

getWorkflowSourceById

Usage and SDK Samples

Scopes

Parameters

Responses

getWorkflowStatuses

Usage and SDK Samples

Scopes

Parameters

Responses

getWorkflowsOverview

Usage and SDK Samples

Scopes

Parameters

Responses

getWorkflowsOverviewForEntity

Usage and SDK Samples

Scopes

Parameters

Responses

pingWorkflowServiceById

Usage and SDK Samples

Scopes

Parameters

Responses

retriggerInstance

Usage and SDK Samples

Scopes

Parameters

Responses