NAV Navigation
Shell HTTP JavaScript Node.JS Ruby Python Java Go

Vettd Data Observatory (VDO) API Documentation v0.9.0.0

Scroll down for code samples, example requests and responses. Select a language for code samples from the tabs above or the mobile navigation menu.

Vettd Data Observatory API allows clients to utilize Vettd's services to do some cool Data Science processing.

NOTE: Most calls require the Authorization to be set above. Status Code 401 means you are not logged in while 403 means you are logged in but just do not have permissions to perform the action.

Base URLs: /

Onboarding

You will need six values issued to you by Vettd to begin working with the API. Those values are below with different values to access our TEST and PRODUCTION environments:

Value Description
Client Id Your unique Id
Client Secret Your unique secret/password
API Key A value passed into every call (except authentication) as second factor of authentication

NOTE1: The client secret can be reset by contacting Vettd and the API Key can be reset on demand here .

The above information should be treated like you would treat a username and password. We can also lock down the access even further if you provide a while list of valid IPs that will be allowed to access the VDO API. This list can be as a range and/or single IPs.

High Level API Concepts

Value Definition
Asset A physical file.
Dataset A reference to 1 or more assets.
Workflow A series of 1 or more tasks to perform. Workflows can call other workflows (building complex series of tasks)
Job An instance of workflow. When you tell the API to do perform some workflow it creates a JobId which is used to check on the status of the job and retrieve the output (an asset or a dataset) of what the job produced.

Concept 1: What is data

The system was built to be able to handle a variety of incoming data types (text files, pdfs, word docs, etc.…). These files are saved as assets and often time converted down to text for further processing. Each step that is taken during this processing will produce either an Asset or a Dataset (a group of assets) for easy review.

Concept 2: What is a Workflow

Workflows are just a series of steps you are asking our system to perform. You don’t care that the work is broken down into X number of steps, all that you need to be concerned about is that you ask it to perform a high-level task by giving in a reference to some input data and as the result it produces some output data. In the background workflows can reference other workflows so you can build very complex processing, but still the consuming user only cares about the input and the output. Vettd will work with you and create custom workflows for your company, then all you need to do is call and consume the results

Concept 3: What is a Job

A job is just an instance of workflow in action. This allows you to call a workflow multiple times and still keep track of each individual job. We keep track of the instance by a Job Id. The time it takes to process the job depends on the complexity of the workflow and the volume of data the tasks have to process.

Basic Usage Steps

sampe steps

Step Name Call
1 Authenticate Jump to Call
2 List Workflows Jump to Call
3 Upload Files Jump to Call
4 Call Workflow/ Add Job Jump to Call
5 Retrieve Job Results Jump to Call
6 Download Results Call Asset or Call Dataset

sampe steps Download New User Getting Started Guide (PDF)

The above guide will walk you through a basic creation of job using a workflow and files you upload.

Authentication

The VDO API is JSON based. In order to make an authenticated call to the API, you must include your access token with the call. OAuth2 uses a BEARER token that is passed along in an Authorization header.

To get a token make the following call:

Authenticate

Code samples

# You can also use wget
curl -X POST https://vettd.auth0.com/oauth/token \
  -H 'Cache-Control: no-cache'
  -H 'Content-Type: application/x-www-form-urlencoded'
  -d 'grant_type=client_credentials&audience=api.vettd.com%2Fvdo&client_id={CLIENT_ID_HERE}&client_secret={CLIENT_SECRET_HERE}

see shell

see shell

see shell

see shell

see shell

see shell

see shell

POST https://vettd.auth0.com/oauth/token

Example responses

200 Response

{
    "access_token": "eyJ0eXAiO…DhgE-Q3-cycw",
    "scope": "",
    "expires_in": 14400,
    "token_type": "Bearer"
}

Responses

Status Meaning Description Schema
200 OK Success AuthenicationResponse
400 Bad Request Bad Request None

Storage

Upload Files (Assets and Datasets)

Code samples

# You can also use wget
curl -X POST //vdo/v1/storage/assets?assigntodataset=true \
  -H 'Accept: text/plain'
  -H 'Authorization: Bearer YOUR_TOKEN'
  -H 'X-Api-Key: string

POST //vdo/v1/storage/assets?assigntodataset=true HTTP/1.1
Host: null

Accept: text/plain
X-Api-Key: string
Authorization: Bearer YOUR_TOKEN

var headers = {
  'Accept':'text/plain',
  'Authorization': 'Bearer YOUR_TOKEN',
  'X-Api-Key':'string'

};

$.ajax({
  url: '//vdo/v1/storage/assets',
  method: 'post',
  data: '?assigntodataset=true',
  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const request = require('node-fetch');

const headers = {
  'Accept':'text/plain',
  'Authorization': 'Bearer YOUR_TOKEN',
  'X-Api-Key':'string'

};

fetch('//vdo/v1/storage/assets?assigntodataset=true',
{
  method: 'POST',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'text/plain',
  'Authorization' => 'Bearer YOUR_TOKEN',
  'X-Api-Key' => 'string'
}

result = RestClient.post '//vdo/v1/storage/assets',
  params: {
  'assigntodataset' => 'boolean'
}, headers: headers

p JSON.parse(result)

import requests
headers = {
'Accept': 'text/plain',
'Authorization' : 'Bearer YOUR_TOKEN',
  'X-Api-Key': 'string'
}

r = requests.post('//vdo/v1/storage/assets', params={
  'assigntodataset': 'true'
}, headers = headers)

print r.json()

URL obj = new URL("//vdo/v1/storage/assets?assigntodataset=true");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("POST");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"text/plain"},
		"Authorization": []string{"Bearer YOURTOKEN"},
        "X-Api-Key": []string{"string"},
        
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "//vdo/v1/storage/assets", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

POST /vdo/v1/storage/assets

Send assets/files into a DataSet Content-Type: application/x-www-form-urlencoded. Zip files are allowed and will be unzipped on upload

Parameters

Parameter In Type Required Description
files query array[any] false Except ZIP or single files (txt, doc, docx, json, pdf)
datatype query string false Eg. 'JobDescription' or 'Applicant'
datasetname query string false Optional: Give the name of your DataSet a friendly name - one will be generated if blank
assigntodataset query boolean true Optional: [Default to true] Usually an asset will be assigned to a dataset - set flag to false to supress connection
X-Api-Key header string false Your assigned application id

Example responses

200 Response

{
  "datasetid": "string",
  "datasetname": "string",
  "assets": [
    {
      "id": "string",
      "createdate": "2018-05-15T17:51:34Z",
      "updatedate": "2018-05-15T17:51:34Z",
      "datatype": "string",
      "name": "string"
    }
  ]
}
{
  "datasetid": "string",
  "datasetname": "string",
  "assets": [
    {
      "id": "string",
      "createdate": "2018-05-15T17:51:34Z",
      "updatedate": "2018-05-15T17:51:34Z",
      "datatype": "string",
      "name": "string"
    }
  ]
}

Responses

Status Meaning Description Schema
200 OK Success AssetUploadResponse
400 Bad Request Bad Request None

Single Asset

Code samples

# You can also use wget
curl -X GET //vdo/v1/storage/assets/{assetid} \
  -H 'Accept: text/plain'
  -H 'Authorization: Bearer YOUR_TOKEN'
  -H 'X-Api-Key: string

GET //vdo/v1/storage/assets/{assetid} HTTP/1.1
Host: null

Accept: text/plain
X-Api-Key: string
Authorization: Bearer YOUR_TOKEN

var headers = {
  'Accept':'text/plain',
  'Authorization': 'Bearer YOUR_TOKEN',
  'X-Api-Key':'string'

};

$.ajax({
  url: '//vdo/v1/storage/assets/{assetid}',
  method: 'get',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const request = require('node-fetch');

const headers = {
  'Accept':'text/plain',
  'Authorization': 'Bearer YOUR_TOKEN',
  'X-Api-Key':'string'

};

fetch('//vdo/v1/storage/assets/{assetid}',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'text/plain',
  'Authorization' => 'Bearer YOUR_TOKEN',
  'X-Api-Key' => 'string'
}

result = RestClient.get '//vdo/v1/storage/assets/{assetid}',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
'Accept': 'text/plain',
'Authorization' : 'Bearer YOUR_TOKEN',
  'X-Api-Key': 'string'
}

r = requests.get('//vdo/v1/storage/assets/{assetid}', params={

}, headers = headers)

print r.json()

URL obj = new URL("//vdo/v1/storage/assets/{assetid}");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"text/plain"},
		"Authorization": []string{"Bearer YOURTOKEN"},
        "X-Api-Key": []string{"string"},
        
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "//vdo/v1/storage/assets/{assetid}", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /vdo/v1/storage/assets/{assetid}

Get Asset details by Id

Parameters

Parameter In Type Required Description
assetid path string(uuid) true none
X-Api-Key header string false Your assigned application id

Example responses

200 Response

{
  "id": "string",
  "createdate": "2018-05-15T17:51:34Z",
  "updatedate": "2018-05-15T17:51:34Z",
  "datatype": "string",
  "name": "string"
}
{
  "id": "string",
  "createdate": "2018-05-15T17:51:34Z",
  "updatedate": "2018-05-15T17:51:34Z",
  "datatype": "string",
  "name": "string"
}

Responses

Status Meaning Description Schema
200 OK Success AssetDTO
400 Bad Request Bad Request None

List Assets

Code samples

# You can also use wget
curl -X GET //vdo/v1/storage/assets \
  -H 'Accept: text/plain'
  -H 'Authorization: Bearer YOUR_TOKEN'
  -H 'X-Api-Key: string

GET //vdo/v1/storage/assets HTTP/1.1
Host: null

Accept: text/plain
X-Api-Key: string
Authorization: Bearer YOUR_TOKEN

var headers = {
  'Accept':'text/plain',
  'Authorization': 'Bearer YOUR_TOKEN',
  'X-Api-Key':'string'

};

$.ajax({
  url: '//vdo/v1/storage/assets',
  method: 'get',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const request = require('node-fetch');

const headers = {
  'Accept':'text/plain',
  'Authorization': 'Bearer YOUR_TOKEN',
  'X-Api-Key':'string'

};

fetch('//vdo/v1/storage/assets',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'text/plain',
  'Authorization' => 'Bearer YOUR_TOKEN',
  'X-Api-Key' => 'string'
}

result = RestClient.get '//vdo/v1/storage/assets',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
'Accept': 'text/plain',
'Authorization' : 'Bearer YOUR_TOKEN',
  'X-Api-Key': 'string'
}

r = requests.get('//vdo/v1/storage/assets', params={

}, headers = headers)

print r.json()

URL obj = new URL("//vdo/v1/storage/assets");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"text/plain"},
		"Authorization": []string{"Bearer YOURTOKEN"},
        "X-Api-Key": []string{"string"},
        
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "//vdo/v1/storage/assets", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /vdo/v1/storage/assets

List of all the assets/files you have uploaded to Vettd.

Parameters

Parameter In Type Required Description
X-Api-Key header string false Your assigned application id

Example responses

200 Response

[
  {
    "id": "string",
    "createdate": "2018-05-15T17:51:34Z",
    "updatedate": "2018-05-15T17:51:34Z",
    "datatype": "string",
    "name": "string"
  }
]
[
  {
    "id": "string",
    "createdate": "2018-05-15T17:51:34Z",
    "updatedate": "2018-05-15T17:51:34Z",
    "datatype": "string",
    "name": "string"
  }
]

Responses

Status Meaning Description Schema
200 OK Success Inline
400 Bad Request Bad Request None

Response Schema

Status Code 200

Name Type Required Restrictions Description
anonymous [AssetDTO] false none none
» id string(uuid) false none none
» createdate string(date-time) false none none
» updatedate string(date-time) false none none
» datatype string false none none
» name string false none none

Single Dataset

Code samples

# You can also use wget
curl -X GET //vdo/v1/storage/datasets \
  -H 'Accept: text/plain'
  -H 'Authorization: Bearer YOUR_TOKEN'
  -H 'X-Api-Key: string

GET //vdo/v1/storage/datasets HTTP/1.1
Host: null

Accept: text/plain
X-Api-Key: string
Authorization: Bearer YOUR_TOKEN

var headers = {
  'Accept':'text/plain',
  'Authorization': 'Bearer YOUR_TOKEN',
  'X-Api-Key':'string'

};

$.ajax({
  url: '//vdo/v1/storage/datasets',
  method: 'get',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const request = require('node-fetch');

const headers = {
  'Accept':'text/plain',
  'Authorization': 'Bearer YOUR_TOKEN',
  'X-Api-Key':'string'

};

fetch('//vdo/v1/storage/datasets',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'text/plain',
  'Authorization' => 'Bearer YOUR_TOKEN',
  'X-Api-Key' => 'string'
}

result = RestClient.get '//vdo/v1/storage/datasets',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
'Accept': 'text/plain',
'Authorization' : 'Bearer YOUR_TOKEN',
  'X-Api-Key': 'string'
}

r = requests.get('//vdo/v1/storage/datasets', params={

}, headers = headers)

print r.json()

URL obj = new URL("//vdo/v1/storage/datasets");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"text/plain"},
		"Authorization": []string{"Bearer YOURTOKEN"},
        "X-Api-Key": []string{"string"},
        
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "//vdo/v1/storage/datasets", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /vdo/v1/storage/datasets

Returns list of all datasets

Parameters

Parameter In Type Required Description
X-Api-Key header string false Your assigned application id

Example responses

200 Response

[
  {
    "id": "string",
    "createdate": "2018-05-15T17:51:34Z",
    "name": "string",
    "datatype": "string"
  }
]
[
  {
    "id": "string",
    "createdate": "2018-05-15T17:51:34Z",
    "name": "string",
    "datatype": "string"
  }
]

Responses

Status Meaning Description Schema
200 OK Success Inline
400 Bad Request Bad Request None

Response Schema

Status Code 200

Name Type Required Restrictions Description
anonymous [DataSetDTO] false none none
» id string(uuid) false none none
» createdate string(date-time) false none none
» name string false none none
» datatype string false none none

Create Empty Dataset

Code samples

# You can also use wget
curl -X POST //vdo/v1/storage/datasets \
  -H 'Content-Type: application/json-patch+json' \
  -H 'Accept: text/plain'
  -H 'Authorization: Bearer YOUR_TOKEN'
  -H 'X-Api-Key: string

POST //vdo/v1/storage/datasets HTTP/1.1
Host: null
Content-Type: application/json-patch+json
Accept: text/plain
X-Api-Key: string
Authorization: Bearer YOUR_TOKEN

var headers = {
  'Content-Type':'application/json-patch+json',
  'Accept':'text/plain',
  'Authorization': 'Bearer YOUR_TOKEN',
  'X-Api-Key':'string'

};

$.ajax({
  url: '//vdo/v1/storage/datasets',
  method: 'post',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const request = require('node-fetch');
const inputBody = '{
  "name": "string",
  "datatype": "string"
}';
const headers = {
  'Content-Type':'application/json-patch+json',
  'Accept':'text/plain',
  'Authorization': 'Bearer YOUR_TOKEN',
  'X-Api-Key':'string'

};

fetch('//vdo/v1/storage/datasets',
{
  method: 'POST',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Content-Type' => 'application/json-patch+json',
  'Accept' => 'text/plain',
  'Authorization' => 'Bearer YOUR_TOKEN',
  'X-Api-Key' => 'string'
}

result = RestClient.post '//vdo/v1/storage/datasets',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Content-Type': 'application/json-patch+json',
'Accept': 'text/plain',
'Authorization' : 'Bearer YOUR_TOKEN',
  'X-Api-Key': 'string'
}

r = requests.post('//vdo/v1/storage/datasets', params={

}, headers = headers)

print r.json()

URL obj = new URL("//vdo/v1/storage/datasets");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("POST");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Content-Type": []string{"application/json-patch+json"},
        "Accept": []string{"text/plain"},
		"Authorization": []string{"Bearer YOURTOKEN"},
        "X-Api-Key": []string{"string"},
        
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "//vdo/v1/storage/datasets", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

POST /vdo/v1/storage/datasets

Create an empty dataset for future use of adding assets into it

Body parameter

{
  "name": "string",
  "datatype": "string"
}

Parameters

Parameter In Type Required Description
X-Api-Key header string false Your assigned application id
body body DataSetCreateRequest false none

Example responses

200 Response

{
  "id": "string",
  "datatype": "string",
  "name": "string"
}
{
  "id": "string",
  "datatype": "string",
  "name": "string"
}

Responses

Status Meaning Description Schema
200 OK Unique identifier for dataset UniqueIdentifier
400 Bad Request Error: Dataset not created None

List Assets in a Dataset

Code samples

# You can also use wget
curl -X GET //vdo/v1/storage/datasets/{datasetid}/assets \
  -H 'Accept: text/plain'
  -H 'Authorization: Bearer YOUR_TOKEN'
  -H 'X-Api-Key: string

GET //vdo/v1/storage/datasets/{datasetid}/assets HTTP/1.1
Host: null

Accept: text/plain
X-Api-Key: string
Authorization: Bearer YOUR_TOKEN

var headers = {
  'Accept':'text/plain',
  'Authorization': 'Bearer YOUR_TOKEN',
  'X-Api-Key':'string'

};

$.ajax({
  url: '//vdo/v1/storage/datasets/{datasetid}/assets',
  method: 'get',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const request = require('node-fetch');

const headers = {
  'Accept':'text/plain',
  'Authorization': 'Bearer YOUR_TOKEN',
  'X-Api-Key':'string'

};

fetch('//vdo/v1/storage/datasets/{datasetid}/assets',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'text/plain',
  'Authorization' => 'Bearer YOUR_TOKEN',
  'X-Api-Key' => 'string'
}

result = RestClient.get '//vdo/v1/storage/datasets/{datasetid}/assets',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
'Accept': 'text/plain',
'Authorization' : 'Bearer YOUR_TOKEN',
  'X-Api-Key': 'string'
}

r = requests.get('//vdo/v1/storage/datasets/{datasetid}/assets', params={

}, headers = headers)

print r.json()

URL obj = new URL("//vdo/v1/storage/datasets/{datasetid}/assets");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"text/plain"},
		"Authorization": []string{"Bearer YOURTOKEN"},
        "X-Api-Key": []string{"string"},
        
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "//vdo/v1/storage/datasets/{datasetid}/assets", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /vdo/v1/storage/datasets/{datasetid}/assets

Return Assets associatted with a DataSet

Parameters

Parameter In Type Required Description
datasetid path string(uuid) true none
X-Api-Key header string false Your assigned application id

Example responses

200 Response

[
  {
    "id": "string",
    "createdate": "2018-05-15T17:51:34Z",
    "updatedate": "2018-05-15T17:51:34Z",
    "datatype": "string",
    "name": "string"
  }
]
[
  {
    "id": "string",
    "createdate": "2018-05-15T17:51:34Z",
    "updatedate": "2018-05-15T17:51:34Z",
    "datatype": "string",
    "name": "string"
  }
]

Responses

Status Meaning Description Schema
200 OK Success Inline
400 Bad Request Bad Request None

Response Schema

Status Code 200

Name Type Required Restrictions Description
anonymous [AssetDTO] false none none
» id string(uuid) false none none
» createdate string(date-time) false none none
» updatedate string(date-time) false none none
» datatype string false none none
» name string false none none

Download Dataset

Code samples

# You can also use wget
curl -X GET //vdo/v1/storage/datasets/{datasetid}/download \
  -H 'Accept: text/plain'
  -H 'Authorization: Bearer YOUR_TOKEN'
  -H 'X-Api-Key: string

GET //vdo/v1/storage/datasets/{datasetid}/download HTTP/1.1
Host: null

Accept: text/plain
X-Api-Key: string
Authorization: Bearer YOUR_TOKEN

var headers = {
  'Accept':'text/plain',
  'Authorization': 'Bearer YOUR_TOKEN',
  'X-Api-Key':'string'

};

$.ajax({
  url: '//vdo/v1/storage/datasets/{datasetid}/download',
  method: 'get',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const request = require('node-fetch');

const headers = {
  'Accept':'text/plain',
  'Authorization': 'Bearer YOUR_TOKEN',
  'X-Api-Key':'string'

};

fetch('//vdo/v1/storage/datasets/{datasetid}/download',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'text/plain',
  'Authorization' => 'Bearer YOUR_TOKEN',
  'X-Api-Key' => 'string'
}

result = RestClient.get '//vdo/v1/storage/datasets/{datasetid}/download',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
'Accept': 'text/plain',
'Authorization' : 'Bearer YOUR_TOKEN',
  'X-Api-Key': 'string'
}

r = requests.get('//vdo/v1/storage/datasets/{datasetid}/download', params={

}, headers = headers)

print r.json()

URL obj = new URL("//vdo/v1/storage/datasets/{datasetid}/download");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"text/plain"},
		"Authorization": []string{"Bearer YOURTOKEN"},
        "X-Api-Key": []string{"string"},
        
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "//vdo/v1/storage/datasets/{datasetid}/download", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /vdo/v1/storage/datasets/{datasetid}/download

Download all assets of a dataset as a zip file

Parameters

Parameter In Type Required Description
datasetid path string(uuid) true none
X-Api-Key header string false Your assigned application id

Example responses

200 Response

{
  "contentType": "string",
  "fileDownloadName": "string",
  "lastModified": "2018-05-15T17:51:34Z",
  "entityTag": {
    "tag": {
      "buffer": "string",
      "offset": 0,
      "length": 0,
      "value": "string",
      "hasValue": true
    },
    "isWeak": true
  }
}

Responses

Status Meaning Description Schema
200 OK Success FileResult
400 Bad Request Bad Request None

Download Asset

Code samples

# You can also use wget
curl -X GET //vdo/v1/storage/assets/{assetid}/download \
  -H 'Accept: text/plain'
  -H 'Authorization: Bearer YOUR_TOKEN'
  -H 'X-Api-Key: string

GET //vdo/v1/storage/assets/{assetid}/download HTTP/1.1
Host: null

Accept: text/plain
X-Api-Key: string
Authorization: Bearer YOUR_TOKEN

var headers = {
  'Accept':'text/plain',
  'Authorization': 'Bearer YOUR_TOKEN',
  'X-Api-Key':'string'

};

$.ajax({
  url: '//vdo/v1/storage/assets/{assetid}/download',
  method: 'get',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const request = require('node-fetch');

const headers = {
  'Accept':'text/plain',
  'Authorization': 'Bearer YOUR_TOKEN',
  'X-Api-Key':'string'

};

fetch('//vdo/v1/storage/assets/{assetid}/download',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'text/plain',
  'Authorization' => 'Bearer YOUR_TOKEN',
  'X-Api-Key' => 'string'
}

result = RestClient.get '//vdo/v1/storage/assets/{assetid}/download',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
'Accept': 'text/plain',
'Authorization' : 'Bearer YOUR_TOKEN',
  'X-Api-Key': 'string'
}

r = requests.get('//vdo/v1/storage/assets/{assetid}/download', params={

}, headers = headers)

print r.json()

URL obj = new URL("//vdo/v1/storage/assets/{assetid}/download");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"text/plain"},
		"Authorization": []string{"Bearer YOURTOKEN"},
        "X-Api-Key": []string{"string"},
        
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "//vdo/v1/storage/assets/{assetid}/download", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /vdo/v1/storage/assets/{assetid}/download

Download an Asset by its Id

Parameters

Parameter In Type Required Description
assetid path string(uuid) true none
X-Api-Key header string false Your assigned application id

Example responses

200 Response

{
  "contentType": "string",
  "fileDownloadName": "string",
  "lastModified": "2018-05-15T17:51:34Z",
  "entityTag": {
    "tag": {
      "buffer": "string",
      "offset": 0,
      "length": 0,
      "value": "string",
      "hasValue": true
    },
    "isWeak": true
  }
}

Responses

Status Meaning Description Schema
200 OK Success FileResult
400 Bad Request Bad Request None

Job

List Jobs

Code samples

# You can also use wget
curl -X GET //vdo/v1/jobs \
  -H 'Accept: text/plain'
  -H 'Authorization: Bearer YOUR_TOKEN'
  -H 'X-Api-Key: string

GET //vdo/v1/jobs HTTP/1.1
Host: null

Accept: text/plain
X-Api-Key: string
Authorization: Bearer YOUR_TOKEN

var headers = {
  'Accept':'text/plain',
  'Authorization': 'Bearer YOUR_TOKEN',
  'X-Api-Key':'string'

};

$.ajax({
  url: '//vdo/v1/jobs',
  method: 'get',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const request = require('node-fetch');

const headers = {
  'Accept':'text/plain',
  'Authorization': 'Bearer YOUR_TOKEN',
  'X-Api-Key':'string'

};

fetch('//vdo/v1/jobs',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'text/plain',
  'Authorization' => 'Bearer YOUR_TOKEN',
  'X-Api-Key' => 'string'
}

result = RestClient.get '//vdo/v1/jobs',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
'Accept': 'text/plain',
'Authorization' : 'Bearer YOUR_TOKEN',
  'X-Api-Key': 'string'
}

r = requests.get('//vdo/v1/jobs', params={

}, headers = headers)

print r.json()

URL obj = new URL("//vdo/v1/jobs");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"text/plain"},
		"Authorization": []string{"Bearer YOURTOKEN"},
        "X-Api-Key": []string{"string"},
        
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "//vdo/v1/jobs", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /vdo/v1/jobs

Parameters

Parameter In Type Required Description
X-Api-Key header string false Your assigned application id

Example responses

200 Response

[
  {
    "id": "string",
    "name": "string",
    "workflowcontnent": "string",
    "parameters": "string",
    "status": "string",
    "isarchived": true,
    "createdate": "2018-05-15T17:51:34Z",
    "updatedate": "2018-05-15T17:51:34Z",
    "workflowid": "string",
    "companyid": "string",
    "userid": "string",
    "ouputypename": "string",
    "ouputvalue": "string",
    "workFlow": {
      "id": "string",
      "name": "string",
      "workflowtemplateid": "string",
      "content": "string",
      "accesslevel": "string",
      "createdate": "2018-05-15T17:51:34Z",
      "version": 0,
      "ispublished": true,
      "companyid": "string"
    }
  }
]

Responses

Status Meaning Description Schema
200 OK Success Inline
400 Bad Request Bad Request None

Response Schema

Status Code 200

Name Type Required Restrictions Description
anonymous [Job] false none none
» id string(uuid) false none none
» name string false none none
» workflowcontnent string false none none
» parameters string false none none
» status string false none none
» isarchived boolean false none none
» createdate string(date-time) false none none
» updatedate string(date-time) false none none
» workflowid string(uuid) false none none
» companyid string(uuid) false none none
» userid string(uuid) false none none
» ouputypename string false none none
» ouputvalue string false none none
» workFlow WorkFlowResponse false none none
»» id string(uuid) false none none
»» name string false none none
»» workflowtemplateid string(uuid) false none none
»» content string false none none
»» accesslevel string false none none
»» createdate string(date-time) false none none
»» version integer(int32) false none none
»» ispublished boolean false none none
»» companyid string(uuid) false none none

Add Job

Code samples

# You can also use wget
curl -X POST //vdo/v1/jobs \
  -H 'Content-Type: application/json-patch+json' \
  -H 'Accept: text/plain'
  -H 'Authorization: Bearer YOUR_TOKEN'
  -H 'X-Api-Key: string

POST //vdo/v1/jobs HTTP/1.1
Host: null
Content-Type: application/json-patch+json
Accept: text/plain
X-Api-Key: string
Authorization: Bearer YOUR_TOKEN

var headers = {
  'Content-Type':'application/json-patch+json',
  'Accept':'text/plain',
  'Authorization': 'Bearer YOUR_TOKEN',
  'X-Api-Key':'string'

};

$.ajax({
  url: '//vdo/v1/jobs',
  method: 'post',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const request = require('node-fetch');
const inputBody = '{
  "workflowid": "string",
  "name": "string",
  "parameters": [
    {
      "id": "string",
      "value": "string"
    }
  ]
}';
const headers = {
  'Content-Type':'application/json-patch+json',
  'Accept':'text/plain',
  'Authorization': 'Bearer YOUR_TOKEN',
  'X-Api-Key':'string'

};

fetch('//vdo/v1/jobs',
{
  method: 'POST',
  body: inputBody,
  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Content-Type' => 'application/json-patch+json',
  'Accept' => 'text/plain',
  'Authorization' => 'Bearer YOUR_TOKEN',
  'X-Api-Key' => 'string'
}

result = RestClient.post '//vdo/v1/jobs',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'Content-Type': 'application/json-patch+json',
'Accept': 'text/plain',
'Authorization' : 'Bearer YOUR_TOKEN',
  'X-Api-Key': 'string'
}

r = requests.post('//vdo/v1/jobs', params={

}, headers = headers)

print r.json()

URL obj = new URL("//vdo/v1/jobs");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("POST");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Content-Type": []string{"application/json-patch+json"},
        "Accept": []string{"text/plain"},
		"Authorization": []string{"Bearer YOURTOKEN"},
        "X-Api-Key": []string{"string"},
        
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("POST", "//vdo/v1/jobs", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

POST /vdo/v1/jobs

Body parameter

{
  "workflowid": "string",
  "name": "string",
  "parameters": [
    {
      "id": "string",
      "value": "string"
    }
  ]
}

Parameters

Parameter In Type Required Description
X-Api-Key header string false Your assigned application id
body body JobRequest false none

Example responses

200 Response

{
  "id": "string",
  "datatype": "string",
  "name": "string"
}
{
  "id": "string",
  "datatype": "string",
  "name": "string"
}

400 Response

"string"
"string"

Responses

Status Meaning Description Schema
200 OK Success UniqueIdentifier
400 Bad Request Bad Request string

Get Job

Code samples

# You can also use wget
curl -X GET //vdo/v1/jobs/{jobid} \
  -H 'Accept: text/plain'
  -H 'Authorization: Bearer YOUR_TOKEN'
  -H 'X-Api-Key: string

GET //vdo/v1/jobs/{jobid} HTTP/1.1
Host: null

Accept: text/plain
X-Api-Key: string
Authorization: Bearer YOUR_TOKEN

var headers = {
  'Accept':'text/plain',
  'Authorization': 'Bearer YOUR_TOKEN',
  'X-Api-Key':'string'

};

$.ajax({
  url: '//vdo/v1/jobs/{jobid}',
  method: 'get',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const request = require('node-fetch');

const headers = {
  'Accept':'text/plain',
  'Authorization': 'Bearer YOUR_TOKEN',
  'X-Api-Key':'string'

};

fetch('//vdo/v1/jobs/{jobid}',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'text/plain',
  'Authorization' => 'Bearer YOUR_TOKEN',
  'X-Api-Key' => 'string'
}

result = RestClient.get '//vdo/v1/jobs/{jobid}',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
'Accept': 'text/plain',
'Authorization' : 'Bearer YOUR_TOKEN',
  'X-Api-Key': 'string'
}

r = requests.get('//vdo/v1/jobs/{jobid}', params={

}, headers = headers)

print r.json()

URL obj = new URL("//vdo/v1/jobs/{jobid}");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"text/plain"},
		"Authorization": []string{"Bearer YOURTOKEN"},
        "X-Api-Key": []string{"string"},
        
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "//vdo/v1/jobs/{jobid}", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /vdo/v1/jobs/{jobid}

Use to check on status of a job

Check the status of a specific job as well as details of what assets/datasets where generated during the processing

Parameters

Parameter In Type Required Description
jobid path string(uuid) true none
X-Api-Key header string false Your assigned application id

Example responses

200 Response

{
  "job": {
    "id": "string",
    "name": "string",
    "inputvalues": [
      {
        "id": "string",
        "value": "string"
      }
    ],
    "status": "string",
    "createdate": "2018-05-15T17:51:34Z",
    "workflowid": "string",
    "ouputypename": "string",
    "ouputvalue": "string"
  },
  "steps": [
    {
      "id": "string",
      "jobid": "string",
      "iocounter": 0,
      "name": "string",
      "isinput": true,
      "value": "string",
      "type": "string",
      "status": "string",
      "stepid": "string"
    }
  ]
}
{
  "job": {
    "id": "string",
    "name": "string",
    "inputvalues": [
      {
        "id": "string",
        "value": "string"
      }
    ],
    "status": "string",
    "createdate": "2018-05-15T17:51:34Z",
    "workflowid": "string",
    "ouputypename": "string",
    "ouputvalue": "string"
  },
  "steps": [
    {
      "id": "string",
      "jobid": "string",
      "iocounter": 0,
      "name": "string",
      "isinput": true,
      "value": "string",
      "type": "string",
      "status": "string",
      "stepid": "string"
    }
  ]
}

Responses

Status Meaning Description Schema
200 OK Job JobDetails
400 Bad Request No Content: Job not found None

Job Details

Code samples

# You can also use wget
curl -X GET //vdo/v1/jobs/{jobid}/workflow \
  -H 'Accept: text/plain'
  -H 'Authorization: Bearer YOUR_TOKEN'
  -H 'X-Api-Key: string

GET //vdo/v1/jobs/{jobid}/workflow HTTP/1.1
Host: null

Accept: text/plain
X-Api-Key: string
Authorization: Bearer YOUR_TOKEN

var headers = {
  'Accept':'text/plain',
  'Authorization': 'Bearer YOUR_TOKEN',
  'X-Api-Key':'string'

};

$.ajax({
  url: '//vdo/v1/jobs/{jobid}/workflow',
  method: 'get',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const request = require('node-fetch');

const headers = {
  'Accept':'text/plain',
  'Authorization': 'Bearer YOUR_TOKEN',
  'X-Api-Key':'string'

};

fetch('//vdo/v1/jobs/{jobid}/workflow',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'text/plain',
  'Authorization' => 'Bearer YOUR_TOKEN',
  'X-Api-Key' => 'string'
}

result = RestClient.get '//vdo/v1/jobs/{jobid}/workflow',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
'Accept': 'text/plain',
'Authorization' : 'Bearer YOUR_TOKEN',
  'X-Api-Key': 'string'
}

r = requests.get('//vdo/v1/jobs/{jobid}/workflow', params={

}, headers = headers)

print r.json()

URL obj = new URL("//vdo/v1/jobs/{jobid}/workflow");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"text/plain"},
		"Authorization": []string{"Bearer YOURTOKEN"},
        "X-Api-Key": []string{"string"},
        
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "//vdo/v1/jobs/{jobid}/workflow", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /vdo/v1/jobs/{jobid}/workflow

Retrieves current list of job flow processing

Parameters

Parameter In Type Required Description
jobid path string(uuid) true none
X-Api-Key header string false Your assigned application id

Example responses

200 Response

{
  "id": "string",
  "name": "string",
  "isservice": true,
  "iteratortype": 0,
  "inputs": [
    {
      "id": "string",
      "name": "string",
      "typename": "string",
      "iocounter": 0
    }
  ],
  "children": [
    null
  ],
  "outputs": [
    {
      "id": "string",
      "name": "string",
      "typename": "string",
      "iocounter": 0
    }
  ]
}
{
  "id": "string",
  "name": "string",
  "isservice": true,
  "iteratortype": 0,
  "inputs": [
    {
      "id": "string",
      "name": "string",
      "typename": "string",
      "iocounter": 0
    }
  ],
  "children": [
    null
  ],
  "outputs": [
    {
      "id": "string",
      "name": "string",
      "typename": "string",
      "iocounter": 0
    }
  ]
}

Responses

Status Meaning Description Schema
200 OK Success WorkFlowTemplateDTO
400 Bad Request Bad Request None

Restart Job

Code samples

# You can also use wget
curl -X GET //vdo/v1/jobs/{jobid}/process \
  -H 'Accept: text/plain'
  -H 'Authorization: Bearer YOUR_TOKEN'
  -H 'X-Api-Key: string

GET //vdo/v1/jobs/{jobid}/process HTTP/1.1
Host: null

Accept: text/plain
X-Api-Key: string
Authorization: Bearer YOUR_TOKEN

var headers = {
  'Accept':'text/plain',
  'Authorization': 'Bearer YOUR_TOKEN',
  'X-Api-Key':'string'

};

$.ajax({
  url: '//vdo/v1/jobs/{jobid}/process',
  method: 'get',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const request = require('node-fetch');

const headers = {
  'Accept':'text/plain',
  'Authorization': 'Bearer YOUR_TOKEN',
  'X-Api-Key':'string'

};

fetch('//vdo/v1/jobs/{jobid}/process',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'text/plain',
  'Authorization' => 'Bearer YOUR_TOKEN',
  'X-Api-Key' => 'string'
}

result = RestClient.get '//vdo/v1/jobs/{jobid}/process',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
'Accept': 'text/plain',
'Authorization' : 'Bearer YOUR_TOKEN',
  'X-Api-Key': 'string'
}

r = requests.get('//vdo/v1/jobs/{jobid}/process', params={

}, headers = headers)

print r.json()

URL obj = new URL("//vdo/v1/jobs/{jobid}/process");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"text/plain"},
		"Authorization": []string{"Bearer YOURTOKEN"},
        "X-Api-Key": []string{"string"},
        
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "//vdo/v1/jobs/{jobid}/process", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /vdo/v1/jobs/{jobid}/process

Restart a Job process. Rarely needed and only used when backend services go down and are restarted

Parameters

Parameter In Type Required Description
jobid path string(uuid) true none
X-Api-Key header string false Your assigned application id

Example responses

200 Response

true
true

Responses

Status Meaning Description Schema
200 OK Success boolean
400 Bad Request Bad Request None

WorkFlow

List Avaliable Workflows

Code samples

# You can also use wget
curl -X GET //vdo/v1/workflow \
  -H 'Accept: text/plain'
  -H 'Authorization: Bearer YOUR_TOKEN'
  -H 'X-Api-Key: string

GET //vdo/v1/workflow HTTP/1.1
Host: null

Accept: text/plain
X-Api-Key: string
Authorization: Bearer YOUR_TOKEN

var headers = {
  'Accept':'text/plain',
  'Authorization': 'Bearer YOUR_TOKEN',
  'X-Api-Key':'string'

};

$.ajax({
  url: '//vdo/v1/workflow',
  method: 'get',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const request = require('node-fetch');

const headers = {
  'Accept':'text/plain',
  'Authorization': 'Bearer YOUR_TOKEN',
  'X-Api-Key':'string'

};

fetch('//vdo/v1/workflow',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'text/plain',
  'Authorization' => 'Bearer YOUR_TOKEN',
  'X-Api-Key' => 'string'
}

result = RestClient.get '//vdo/v1/workflow',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
'Accept': 'text/plain',
'Authorization' : 'Bearer YOUR_TOKEN',
  'X-Api-Key': 'string'
}

r = requests.get('//vdo/v1/workflow', params={

}, headers = headers)

print r.json()

URL obj = new URL("//vdo/v1/workflow");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"text/plain"},
		"Authorization": []string{"Bearer YOURTOKEN"},
        "X-Api-Key": []string{"string"},
        
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "//vdo/v1/workflow", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

List of workflows avaliable to your account which you can initiate jobs.

GET /vdo/v1/workflow

Parameters

Parameter In Type Required Description
X-Api-Key header string false Your assigned application id

Example responses

200 Response

[
  {
    "id": "string",
    "name": "string",
    "workflow": {},
    "version": 0
  }
]
[
  {
    "id": "string",
    "name": "string",
    "workflow": {},
    "version": 0
  }
]

Responses

Status Meaning Description Schema
200 OK Success Inline
400 Bad Request Bad Request None

Response Schema

Status Code 200

Name Type Required Restrictions Description
anonymous [WorkFlowDTO] false none none
» id string(uuid) false none none
» name string false none none
» workflow object false read-only none
» version integer(int32) false none none

Workflow Overview

Code samples

# You can also use wget
curl -X GET //vdo/v1/workflow/{workflowid} \
  -H 'Accept: text/plain'
  -H 'Authorization: Bearer YOUR_TOKEN'
  -H 'X-Api-Key: string

GET //vdo/v1/workflow/{workflowid} HTTP/1.1
Host: null

Accept: text/plain
X-Api-Key: string
Authorization: Bearer YOUR_TOKEN

var headers = {
  'Accept':'text/plain',
  'Authorization': 'Bearer YOUR_TOKEN',
  'X-Api-Key':'string'

};

$.ajax({
  url: '//vdo/v1/workflow/{workflowid}',
  method: 'get',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const request = require('node-fetch');

const headers = {
  'Accept':'text/plain',
  'Authorization': 'Bearer YOUR_TOKEN',
  'X-Api-Key':'string'

};

fetch('//vdo/v1/workflow/{workflowid}',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'text/plain',
  'Authorization' => 'Bearer YOUR_TOKEN',
  'X-Api-Key' => 'string'
}

result = RestClient.get '//vdo/v1/workflow/{workflowid}',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
'Accept': 'text/plain',
'Authorization' : 'Bearer YOUR_TOKEN',
  'X-Api-Key': 'string'
}

r = requests.get('//vdo/v1/workflow/{workflowid}', params={

}, headers = headers)

print r.json()

URL obj = new URL("//vdo/v1/workflow/{workflowid}");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"text/plain"},
		"Authorization": []string{"Bearer YOURTOKEN"},
        "X-Api-Key": []string{"string"},
        
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "//vdo/v1/workflow/{workflowid}", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

Select single workflow (compact)

GET /vdo/v1/workflow/{workflowid}

Parameters

Parameter In Type Required Description
workflowid path string(uuid) true none
X-Api-Key header string false Your assigned application id

Example responses

200 Response

{
  "id": "string",
  "name": "string",
  "isservice": true,
  "iteratortype": 0,
  "inputs": [
    {
      "id": "string",
      "name": "string",
      "typename": "string",
      "iocounter": 0
    }
  ],
  "children": [
    null
  ],
  "outputs": [
    {
      "id": "string",
      "name": "string",
      "typename": "string",
      "iocounter": 0
    }
  ]
}

Responses

Status Meaning Description Schema
200 OK Success WorkFlowTemplateDTO
400 Bad Request Bad Request None

Workflow with Details

Code samples

# You can also use wget
curl -X GET //vdo/v1/workflow/{workflowid}/content \
  -H 'Accept: text/plain'
  -H 'Authorization: Bearer YOUR_TOKEN'
  -H 'X-Api-Key: string

GET //vdo/v1/workflow/{workflowid}/content HTTP/1.1
Host: null

Accept: text/plain
X-Api-Key: string
Authorization: Bearer YOUR_TOKEN

var headers = {
  'Accept':'text/plain',
  'Authorization': 'Bearer YOUR_TOKEN',
  'X-Api-Key':'string'

};

$.ajax({
  url: '//vdo/v1/workflow/{workflowid}/content',
  method: 'get',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const request = require('node-fetch');

const headers = {
  'Accept':'text/plain',
  'Authorization': 'Bearer YOUR_TOKEN',
  'X-Api-Key':'string'

};

fetch('//vdo/v1/workflow/{workflowid}/content',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'text/plain',
  'Authorization' => 'Bearer YOUR_TOKEN',
  'X-Api-Key' => 'string'
}

result = RestClient.get '//vdo/v1/workflow/{workflowid}/content',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
'Accept': 'text/plain',
'Authorization' : 'Bearer YOUR_TOKEN',
  'X-Api-Key': 'string'
}

r = requests.get('//vdo/v1/workflow/{workflowid}/content', params={

}, headers = headers)

print r.json()

URL obj = new URL("//vdo/v1/workflow/{workflowid}/content");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"text/plain"},
		"Authorization": []string{"Bearer YOURTOKEN"},
        "X-Api-Key": []string{"string"},
        
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "//vdo/v1/workflow/{workflowid}/content", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

Select single workflow with details of workflow included

GET /vdo/v1/workflow/{workflowid}/content

Parameters

Parameter In Type Required Description
workflowid path string(uuid) true none
X-Api-Key header string false Your assigned application id

Example responses

200 Response

{
  "id": "string",
  "name": "string",
  "isservice": true,
  "iteratortype": 0,
  "inputs": [
    {
      "id": "string",
      "name": "string",
      "typename": "string",
      "iocounter": 0
    }
  ],
  "children": [
    null
  ],
  "outputs": [
    {
      "id": "string",
      "name": "string",
      "typename": "string",
      "iocounter": 0
    }
  ]
}

Responses

Status Meaning Description Schema
200 OK Success WorkFlowTemplateDTO
400 Bad Request Bad Request None

Information

Ping

Code samples

# You can also use wget
curl -X GET //vdo/v1/info/ping \
  -H 'Accept: text/plain'
  -H 'Authorization: Bearer YOUR_TOKEN'
  -H 'X-Api-Key: string

GET //vdo/v1/info/ping HTTP/1.1
Host: null

Accept: text/plain
X-Api-Key: string
Authorization: Bearer YOUR_TOKEN

var headers = {
  'Accept':'text/plain',
  'Authorization': 'Bearer YOUR_TOKEN',
  'X-Api-Key':'string'

};

$.ajax({
  url: '//vdo/v1/info/ping',
  method: 'get',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const request = require('node-fetch');

const headers = {
  'Accept':'text/plain',
  'Authorization': 'Bearer YOUR_TOKEN',
  'X-Api-Key':'string'

};

fetch('//vdo/v1/info/ping',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'text/plain',
  'Authorization' => 'Bearer YOUR_TOKEN',
  'X-Api-Key' => 'string'
}

result = RestClient.get '//vdo/v1/info/ping',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
'Accept': 'text/plain',
'Authorization' : 'Bearer YOUR_TOKEN',
  'X-Api-Key': 'string'
}

r = requests.get('//vdo/v1/info/ping', params={

}, headers = headers)

print r.json()

URL obj = new URL("//vdo/v1/info/ping");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"text/plain"},
		"Authorization": []string{"Bearer YOURTOKEN"},
        "X-Api-Key": []string{"string"},
        
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "//vdo/v1/info/ping", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /vdo/v1/info/ping

Simple ping to see if API is alive

Parameters

Parameter In Type Required Description
X-Api-Key header string false Your assigned application id

Example responses

200 Response

"string"
"string"

Responses

Status Meaning Description Schema
200 OK Success string
400 Bad Request Bad Request None

Ver## VdoV1InfoVersionGet

Code samples

# You can also use wget
curl -X GET //vdo/v1/info/version \
  -H 'Accept: text/plain'
  -H 'Authorization: Bearer YOUR_TOKEN'
  -H 'X-Api-Key: string

GET //vdo/v1/info/version HTTP/1.1
Host: null

Accept: text/plain
X-Api-Key: string
Authorization: Bearer YOUR_TOKEN

var headers = {
  'Accept':'text/plain',
  'Authorization': 'Bearer YOUR_TOKEN',
  'X-Api-Key':'string'

};

$.ajax({
  url: '//vdo/v1/info/version',
  method: 'get',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const request = require('node-fetch');

const headers = {
  'Accept':'text/plain',
  'Authorization': 'Bearer YOUR_TOKEN',
  'X-Api-Key':'string'

};

fetch('//vdo/v1/info/version',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'text/plain',
  'Authorization' => 'Bearer YOUR_TOKEN',
  'X-Api-Key' => 'string'
}

result = RestClient.get '//vdo/v1/info/version',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
'Accept': 'text/plain',
'Authorization' : 'Bearer YOUR_TOKEN',
  'X-Api-Key': 'string'
}

r = requests.get('//vdo/v1/info/version', params={

}, headers = headers)

print r.json()

URL obj = new URL("//vdo/v1/info/version");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"text/plain"},
		"Authorization": []string{"Bearer YOURTOKEN"},
        "X-Api-Key": []string{"string"},
        
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "//vdo/v1/info/version", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /vdo/v1/info/version

Version number and release date of VDO API

Parameters

Parameter In Type Required Description
X-Api-Key header string false Your assigned application id

Example responses

200 Response

{
  "number": "string",
  "release_date": "2018-05-15T17:51:34Z",
  "lastRestartTime": "string",
  "redisDBNumber": "string",
  "environment": "string",
  "token_information": {
    "companyId": "string",
    "userId": "string",
    "auth0UserId": "string",
    "issuer": "string",
    "isUser": true,
    "userEmail": "string",
    "roles": [
      "string"
    ]
  }
}
{
  "number": "string",
  "release_date": "2018-05-15T17:51:34Z",
  "lastRestartTime": "string",
  "redisDBNumber": "string",
  "environment": "string",
  "token_information": {
    "companyId": "string",
    "userId": "string",
    "auth0UserId": "string",
    "issuer": "string",
    "isUser": true,
    "userEmail": "string",
    "roles": [
      "string"
    ]
  }
}

Responses

Status Meaning Description Schema
200 OK Success ApplicationVersion
400 Bad Request Bad Request None

Version

Code samples

# You can also use wget
curl -X GET //vdo/v1/info/version/admin \
  -H 'Accept: text/plain'
  -H 'Authorization: Bearer YOUR_TOKEN'
  -H 'X-Api-Key: string

GET //vdo/v1/info/version/admin HTTP/1.1
Host: null

Accept: text/plain
X-Api-Key: string
Authorization: Bearer YOUR_TOKEN

var headers = {
  'Accept':'text/plain',
  'Authorization': 'Bearer YOUR_TOKEN',
  'X-Api-Key':'string'

};

$.ajax({
  url: '//vdo/v1/info/version/admin',
  method: 'get',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const request = require('node-fetch');

const headers = {
  'Accept':'text/plain',
  'Authorization': 'Bearer YOUR_TOKEN',
  'X-Api-Key':'string'

};

fetch('//vdo/v1/info/version/admin',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'Accept' => 'text/plain',
  'Authorization' => 'Bearer YOUR_TOKEN',
  'X-Api-Key' => 'string'
}

result = RestClient.get '//vdo/v1/info/version/admin',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
'Accept': 'text/plain',
'Authorization' : 'Bearer YOUR_TOKEN',
  'X-Api-Key': 'string'
}

r = requests.get('//vdo/v1/info/version/admin', params={

}, headers = headers)

print r.json()

URL obj = new URL("//vdo/v1/info/version/admin");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "Accept": []string{"text/plain"},
		"Authorization": []string{"Bearer YOURTOKEN"},
        "X-Api-Key": []string{"string"},
        
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "//vdo/v1/info/version/admin", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /vdo/v1/info/version/admin

Version number and release date of VDO API

Parameters

Parameter In Type Required Description
X-Api-Key header string false Your assigned application id

Example responses

200 Response

{
  "number": "string",
  "release_date": "2018-05-15T17:51:34Z",
  "lastRestartTime": "string",
  "redisDBNumber": "string",
  "environment": "string",
  "token_information": {
    "companyId": "string",
    "userId": "string",
    "auth0UserId": "string",
    "issuer": "string",
    "isUser": true,
    "userEmail": "string",
    "roles": [
      "string"
    ]
  }
}
{
  "number": "string",
  "release_date": "2018-05-15T17:51:34Z",
  "lastRestartTime": "string",
  "redisDBNumber": "string",
  "environment": "string",
  "token_information": {
    "companyId": "string",
    "userId": "string",
    "auth0UserId": "string",
    "issuer": "string",
    "isUser": true,
    "userEmail": "string",
    "roles": [
      "string"
    ]
  }
}

Responses

Status Meaning Description Schema
200 OK Success ApplicationVersion
400 Bad Request Bad Request None

Role Claims

Code samples

# You can also use wget
curl -X GET //vdo/v1/info/claims \
  -H 'X-Api-Key: string

GET //vdo/v1/info/claims HTTP/1.1
Host: null

X-Api-Key: string
Authorization: Bearer YOUR_TOKEN

var headers = {
  'X-Api-Key':'string'

};

$.ajax({
  url: '//vdo/v1/info/claims',
  method: 'get',

  headers: headers,
  success: function(data) {
    console.log(JSON.stringify(data));
  }
})

const request = require('node-fetch');

const headers = {
  'X-Api-Key':'string'

};

fetch('//vdo/v1/info/claims',
{
  method: 'GET',

  headers: headers
})
.then(function(res) {
    return res.json();
}).then(function(body) {
    console.log(body);
});

require 'rest-client'
require 'json'

headers = {
  'X-Api-Key' => 'string'
}

result = RestClient.get '//vdo/v1/info/claims',
  params: {
  }, headers: headers

p JSON.parse(result)

import requests
headers = {
  'X-Api-Key': 'string'
}

r = requests.get('//vdo/v1/info/claims', params={

}, headers = headers)

print r.json()

URL obj = new URL("//vdo/v1/info/claims");
HttpURLConnection con = (HttpURLConnection) obj.openConnection();
con.setRequestMethod("GET");
int responseCode = con.getResponseCode();
BufferedReader in = new BufferedReader(
    new InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer response = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
    response.append(inputLine);
}
in.close();
System.out.println(response.toString());

package main

import (
       "bytes"
       "net/http"
)

func main() {

    headers := map[string][]string{
        "X-Api-Key": []string{"string"},
        
    }

    data := bytes.NewBuffer([]byte{jsonReq})
    req, err := http.NewRequest("GET", "//vdo/v1/info/claims", data)
    req.Header = headers

    client := &http.Client{}
    resp, err := client.Do(req)
    // ...
}

GET /vdo/v1/info/claims

Parameters

Parameter In Type Required Description
X-Api-Key header string false Your assigned application id

Responses

Status Meaning Description Schema
200 OK Success None

Schemas

ApplicationVersion

{
  "number": "string",
  "release_date": "2018-05-15T17:51:34Z",
  "lastRestartTime": "string",
  "redisDBNumber": "string",
  "environment": "string",
  "token_information": {
    "companyId": "string",
    "userId": "string",
    "auth0UserId": "string",
    "issuer": "string",
    "isUser": true,
    "userEmail": "string",
    "roles": [
      "string"
    ]
  }
}

Properties

Name Type Required Restrictions Description
number string false none none
release_date string(date-time) false none none
lastRestartTime string false none none
redisDBNumber string false none none
environment string false none none
token_information TokenInformation false none none

AuthenicationResponse

{
    "access_token": "string",
    "scope": "string",
    "expires_in": "integer",
    "token_type": "string"
}


Properties

Name Type Required Restrictions Description
access_token string true none none
scope string false none none
expires_in integer true read-only none
token_type string(int32) true none none

AssetDTO

{
  "id": "string",
  "createdate": "2018-05-15T17:51:34Z",
  "updatedate": "2018-05-15T17:51:34Z",
  "datatype": "string",
  "name": "string"
}

Properties

Name Type Required Restrictions Description
id string(uuid) false none none
createdate string(date-time) false none none
updatedate string(date-time) false none none
datatype string false none none
name string false none none

AssetUploadResponse

{
  "datasetid": "string",
  "datasetname": "string",
  "assets": [
    {
      "id": "string",
      "createdate": "2018-05-15T17:51:34Z",
      "updatedate": "2018-05-15T17:51:34Z",
      "datatype": "string",
      "name": "string"
    }
  ]
}

Properties

Name Type Required Restrictions Description
datasetid string(uuid) false none none
datasetname string false none none
assets [AssetDTO] false none none

ClientAsUser

{
  "thirdpartyid": "string",
  "companyname": "string",
  "username": "string",
  "email": "string",
  "workflowids": [
    "string"
  ]
}

Properties

Name Type Required Restrictions Description
thirdpartyid string false none none
companyname string false none none
username string false none none
email string false none none
workflowids [string] false none none

DataSetDTO

{
  "id": "string",
  "createdate": "2018-05-15T17:51:34Z",
  "name": "string",
  "datatype": "string"
}

Properties

Name Type Required Restrictions Description
id string(uuid) false none none
createdate string(date-time) false none none
name string false none none
datatype string false none none

DataSetCreateRequest

{
  "name": "string",
  "datatype": "string"
}

Properties

Name Type Required Restrictions Description
name string false none none
datatype string false none none

FileResult

{
  "contentType": "string",
  "fileDownloadName": "string",
  "lastModified": "2018-05-15T17:51:34Z",
  "entityTag": {
    "tag": {
      "buffer": "string",
      "offset": 0,
      "length": 0,
      "value": "string",
      "hasValue": true
    },
    "isWeak": true
  }
}

Properties

Name Type Required Restrictions Description
contentType string false read-only none
fileDownloadName string false none none
lastModified string(date-time) false none none
entityTag EntityTagHeaderValue false none none

EntityTagHeaderValue

{
  "tag": {
    "buffer": "string",
    "offset": 0,
    "length": 0,
    "value": "string",
    "hasValue": true
  },
  "isWeak": true
}

Properties

Name Type Required Restrictions Description
tag StringSegment false none none
isWeak boolean false read-only none

EntityDataSaveRequest

{
  "uniqueid": "string",
  "source": "string",
  "entity": {
    "data": "string",
    "type": "string"
  },
  "entityasset": {
    "data": "string",
    "type": "string"
  }
}

Properties

Name Type Required Restrictions Description
uniqueid string(uuid) false none none
source string false none none
entity EntityData false none none
entityasset EntityData false none none

EntityData

{
  "data": "string",
  "type": "string"
}

Properties

Name Type Required Restrictions Description
data string false none none
type string false none none

EntityResponse

{
  "enitityId": "string",
  "source": "string",
  "sourceId": "string",
  "type": "string",
  "object": {},
  "createDate": "2018-05-15T17:51:34Z",
  "entityAssets": [
    {
      "enitityAssetId": "string",
      "assetId": "string",
      "type": "string",
      "object": {},
      "createDate": "2018-05-15T17:51:34Z"
    }
  ]
}

Properties

Name Type Required Restrictions Description
enitityId string(uuid) false none none
source string false none none
sourceId string(uuid) false none none
type string false none none
object object false none none
createDate string(date-time) false none none
entityAssets [EntityAssetResponse] false none none

EntityAssetResponse

{
  "enitityAssetId": "string",
  "assetId": "string",
  "type": "string",
  "object": {},
  "createDate": "2018-05-15T17:51:34Z"
}

Properties

Name Type Required Restrictions Description
enitityAssetId string(uuid) false none none
assetId string(uuid) false none none
type string false none none
object object false none none
createDate string(date-time) false none none

IFormFile

{
  "contentType": "string",
  "contentDisposition": "string",
  "headers": {
    "property1": [
      "string"
    ],
    "property2": [
      "string"
    ]
  },
  "length": 0,
  "name": "string",
  "fileName": "string"
}

Properties

Name Type Required Restrictions Description
contentType string false read-only none
contentDisposition string false read-only none
headers object false read-only none
» additionalProperties [string] false none none
length integer(int64) false read-only none
name string false read-only none
fileName string false read-only none

JobRequest

{
  "workflowid": "string",
  "name": "string",
  "parameters": [
    {
      "id": "string",
      "value": "string"
    }
  ]
}

Properties

Name Type Required Restrictions Description
workflowid string(uuid) false none none
name string false none none
parameters [JobParameter] false none none

JobParameter

{
  "id": "string",
  "value": "string"
}

Properties

Name Type Required Restrictions Description
id string(uuid) false none none
value string false none none

Job

{
  "id": "string",
  "name": "string",
  "workflowcontnent": "string",
  "parameters": "string",
  "status": "string",
  "isarchived": true,
  "createdate": "2018-05-15T17:51:34Z",
  "updatedate": "2018-05-15T17:51:34Z",
  "workflowid": "string",
  "companyid": "string",
  "userid": "string",
  "ouputypename": "string",
  "ouputvalue": "string",
  "workFlow": {
    "id": "string",
    "name": "string",
    "workflowtemplateid": "string",
    "content": "string",
    "accesslevel": "string",
    "createdate": "2018-05-15T17:51:34Z",
    "version": 0,
    "ispublished": true,
    "companyid": "string"
  }
}

Properties

Name Type Required Restrictions Description
id string(uuid) false none none
name string false none none
workflowcontnent string false none none
parameters string false none none
status string false none none
isarchived boolean false none none
createdate string(date-time) false none none
updatedate string(date-time) false none none
workflowid string(uuid) false none none
companyid string(uuid) false none none
userid string(uuid) false none none
ouputypename string false none none
ouputvalue string false none none
workFlow WorkFlow false none none

JobDetails

{
  "job": {
    "id": "string",
    "name": "string",
    "inputvalues": [
      {
        "id": "string",
        "value": "string"
      }
    ],
    "status": "string",
    "createdate": "2018-05-15T17:51:34Z",
    "workflowid": "string",
    "ouputypename": "string",
    "ouputvalue": "string"
  },
  "steps": [
    {
      "id": "string",
      "jobid": "string",
      "iocounter": 0,
      "name": "string",
      "isinput": true,
      "value": "string",
      "type": "string",
      "status": "string",
      "stepid": "string"
    }
  ]
}

Properties

Name Type Required Restrictions Description
job JobDTO false none none
steps [JobFlowDTO] false none none

JobDTO

{
  "id": "string",
  "name": "string",
  "inputvalues": [
    {
      "id": "string",
      "value": "string"
    }
  ],
  "status": "string",
  "createdate": "2018-05-15T17:51:34Z",
  "workflowid": "string",
  "ouputypename": "string",
  "ouputvalue": "string"
}

Properties

Name Type Required Restrictions Description
id string(uuid) false none none
name string false none none
inputvalues [JobParameter] false read-only none
status string false none none
createdate string(date-time) false none none
workflowid string(uuid) false none none
ouputypename string false none none
ouputvalue string false none none

JobFlowDTO

{
  "id": "string",
  "jobid": "string",
  "iocounter": 0,
  "name": "string",
  "isinput": true,
  "value": "string",
  "type": "string",
  "status": "string",
  "stepid": "string"
}

Properties

Name Type Required Restrictions Description
id string(uuid) false none none
jobid string(uuid) false none none
iocounter number(double) false none none
name string false none none
isinput boolean false none none
value string false none none
type string false none none
status string false none none
stepid string(uuid) false none none

StringSegment

{
  "buffer": "string",
  "offset": 0,
  "length": 0,
  "value": "string",
  "hasValue": true
}

Properties

Name Type Required Restrictions Description
buffer string false read-only none
offset integer(int32) false read-only none
length integer(int32) false read-only none
value string false read-only none
hasValue boolean false read-only none

TokenInformation

{
  "companyId": "string",
  "userId": "string",
  "auth0UserId": "string",
  "issuer": "string",
  "isUser": true,
  "userEmail": "string",
  "roles": [
    "string"
  ]
}

Properties

Name Type Required Restrictions Description
companyId string(uuid) false none none
userId string(uuid) false none none
auth0UserId string false none none
issuer string false none none
isUser boolean false none none
userEmail string false none none
roles [string] false none none

TaskComplete

{
  "status": "string",
  "jobId": "string",
  "jobFlowId": "string",
  "dataType": "string",
  "dataId": "string"
}

Properties

Name Type Required Restrictions Description
status string false none none
jobId string(uuid) false none none
jobFlowId string(uuid) false none none
dataType string false none none
dataId string false none none

UniqueIdentifier

{
  "id": "string",
  "datatype": "string",
  "name": "string"
}

Properties

Name Type Required Restrictions Description
id string(uuid) false none none
datatype string false none none
name string false none none

WorkFlowResponse

{
  "id": "string",
  "name": "string",
  "workflowtemplateid": "string",
  "content": "string",
  "accesslevel": "string",
  "createdate": "2018-05-15T17:51:34Z",
  "version": 0,
  "ispublished": true,
  "companyid": "string"
}

Properties

Name Type Required Restrictions Description
id string(uuid) false none none
name string false none none
workflowtemplateid string(uuid) false none none
content string false none none
accesslevel string false none none
createdate string(date-time) false none none
version integer(int32) false none none
ispublished boolean false none none
companyid string(uuid) false none none

WorkFlowTemplateDTO

{
  "id": "string",
  "name": "string",
  "isservice": true,
  "iteratortype": 0,
  "inputs": [
    {
      "id": "string",
      "name": "string",
      "typename": "string",
      "iocounter": 0
    }
  ],
  "children": [
    null
  ],
  "outputs": [
    {
      "id": "string",
      "name": "string",
      "typename": "string",
      "iocounter": 0
    }
  ]
}

Properties

Name Type Required Restrictions Description
id string(uuid) false none none
name string false none none
isservice boolean false none none
iteratortype integer(int32) false none none
inputs [WorkFlowIODTO] false none none
children [WorkFlowTemplateDTO] false none none
outputs [WorkFlowIODTO] false none none

Enumerated Values

Property Value
iteratortype 0
iteratortype 1
iteratortype 2

WorkFlowIODTO

{
  "id": "string",
  "name": "string",
  "typename": "string",
  "iocounter": 0
}

Properties

Name Type Required Restrictions Description
id string(uuid) false none none
name string false none none
typename string false none none
iocounter integer(int32) false none none

WorkFlowDTO

{
  "id": "string",
  "name": "string",
  "workflow": {},
  "version": 0
}

Properties

Name Type Required Restrictions Description
id string(uuid) false none none
name string false none none
workflow object false read-only none
version integer(int32) false none none