Data export API

Default

deleteJobExecutionById

Delete a specific job execution


/job-executions/{jobExecutionId}

Usage and SDK Samples

curl -X DELETE \
 -H "Accept: text/plain" \
 "http://localhost/data-export/job-executions/{jobExecutionId}"

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();
        UUID jobExecutionId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

        try {
            apiInstance.deleteJobExecutionById(jobExecutionId);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#deleteJobExecutionById");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        UUID jobExecutionId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

        try {
            apiInstance.deleteJobExecutionById(jobExecutionId);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#deleteJobExecutionById");
            e.printStackTrace();
        }
    }
}


// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
UUID *jobExecutionId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; //  (default to null)

[apiInstance deleteJobExecutionByIdWith:jobExecutionId
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var DataExportApi = require('data_export_api');

// Create an instance of the API class
var api = new DataExportApi.DefaultApi()
var jobExecutionId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {UUID} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.deleteJobExecutionById(jobExecutionId, callback);

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

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

            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var jobExecutionId = 38400000-8cf0-11bd-b23e-10b96e4ef00d;  // UUID |  (default to null)

            try {
                apiInstance.deleteJobExecutionById(jobExecutionId);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.deleteJobExecutionById: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$jobExecutionId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

try {
    $api_instance->deleteJobExecutionById($jobExecutionId);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->deleteJobExecutionById: ', $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 $jobExecutionId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | 

eval {
    $api_instance->deleteJobExecutionById(jobExecutionId => $jobExecutionId);
};
if ($@) {
    warn "Exception when calling DefaultApi->deleteJobExecutionById: $@\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()
jobExecutionId = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID |  (default to null)

try:
    api_instance.delete_job_execution_by_id(jobExecutionId)
except ApiException as e:
    print("Exception when calling DefaultApi->deleteJobExecutionById: %s\n" % e)
extern crate DefaultApi;

pub fn main() {
    let jobExecutionId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID

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

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

Scopes

Parameters

Path parameters
Name Description
jobExecutionId*
UUID (uuid)
Required

Responses

deleteJobProfileById

Delete specific job profile


/job-profiles/{jobProfileId}

Usage and SDK Samples

curl -X DELETE \
 -H "Accept: text/plain" \
 "http://localhost/data-export/job-profiles/{jobProfileId}"

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();
        UUID jobProfileId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

        try {
            apiInstance.deleteJobProfileById(jobProfileId);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#deleteJobProfileById");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        UUID jobProfileId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

        try {
            apiInstance.deleteJobProfileById(jobProfileId);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#deleteJobProfileById");
            e.printStackTrace();
        }
    }
}


// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
UUID *jobProfileId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; //  (default to null)

[apiInstance deleteJobProfileByIdWith:jobProfileId
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var DataExportApi = require('data_export_api');

// Create an instance of the API class
var api = new DataExportApi.DefaultApi()
var jobProfileId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {UUID} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.deleteJobProfileById(jobProfileId, callback);

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

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

            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var jobProfileId = 38400000-8cf0-11bd-b23e-10b96e4ef00d;  // UUID |  (default to null)

            try {
                apiInstance.deleteJobProfileById(jobProfileId);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.deleteJobProfileById: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$jobProfileId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

try {
    $api_instance->deleteJobProfileById($jobProfileId);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->deleteJobProfileById: ', $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 $jobProfileId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | 

eval {
    $api_instance->deleteJobProfileById(jobProfileId => $jobProfileId);
};
if ($@) {
    warn "Exception when calling DefaultApi->deleteJobProfileById: $@\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()
jobProfileId = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID |  (default to null)

try:
    api_instance.delete_job_profile_by_id(jobProfileId)
except ApiException as e:
    print("Exception when calling DefaultApi->deleteJobProfileById: %s\n" % e)
extern crate DefaultApi;

pub fn main() {
    let jobProfileId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID

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

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

Scopes

Parameters

Path parameters
Name Description
jobProfileId*
UUID (uuid)
Required

Responses

deleteMappingProfileById

Delete specific mapping profile


/mapping-profiles/{mappingProfileId}

Usage and SDK Samples

curl -X DELETE \
 -H "Accept: text/plain" \
 "http://localhost/data-export/mapping-profiles/{mappingProfileId}"

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();
        UUID mappingProfileId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

        try {
            apiInstance.deleteMappingProfileById(mappingProfileId);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#deleteMappingProfileById");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        UUID mappingProfileId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

        try {
            apiInstance.deleteMappingProfileById(mappingProfileId);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#deleteMappingProfileById");
            e.printStackTrace();
        }
    }
}


// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
UUID *mappingProfileId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; //  (default to null)

[apiInstance deleteMappingProfileByIdWith:mappingProfileId
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var DataExportApi = require('data_export_api');

// Create an instance of the API class
var api = new DataExportApi.DefaultApi()
var mappingProfileId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {UUID} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.deleteMappingProfileById(mappingProfileId, callback);

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

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

            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var mappingProfileId = 38400000-8cf0-11bd-b23e-10b96e4ef00d;  // UUID |  (default to null)

            try {
                apiInstance.deleteMappingProfileById(mappingProfileId);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.deleteMappingProfileById: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$mappingProfileId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

try {
    $api_instance->deleteMappingProfileById($mappingProfileId);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->deleteMappingProfileById: ', $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 $mappingProfileId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | 

eval {
    $api_instance->deleteMappingProfileById(mappingProfileId => $mappingProfileId);
};
if ($@) {
    warn "Exception when calling DefaultApi->deleteMappingProfileById: $@\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()
mappingProfileId = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID |  (default to null)

try:
    api_instance.delete_mapping_profile_by_id(mappingProfileId)
except ApiException as e:
    print("Exception when calling DefaultApi->deleteMappingProfileById: %s\n" % e)
extern crate DefaultApi;

pub fn main() {
    let mappingProfileId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID

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

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

Scopes

Parameters

Path parameters
Name Description
mappingProfileId*
UUID (uuid)
Required

Responses

downloadRecordById

Download single authority or instance record by id


/download-record/{recordId}

Usage and SDK Samples

curl -X GET \
 -H "Accept: application/octet-stream,text/plain" \
 "http://localhost/data-export/download-record/{recordId}?idType=&utf=true&suppress999ff=true"

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();
        UUID recordId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        IdType idType = ; // IdType | 
        Boolean utf = true; // Boolean | Specify whether to encode the file in UTF-8.
        Boolean suppress999ff = true; // Boolean | Specify whether to suppress 999ff field.

        try {
            File result = apiInstance.downloadRecordById(recordId, idType, utf, suppress999ff);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#downloadRecordById");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        UUID recordId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        IdType idType = ; // IdType | 
        Boolean utf = true; // Boolean | Specify whether to encode the file in UTF-8.
        Boolean suppress999ff = true; // Boolean | Specify whether to suppress 999ff field.

        try {
            File result = apiInstance.downloadRecordById(recordId, idType, utf, suppress999ff);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#downloadRecordById");
            e.printStackTrace();
        }
    }
}


// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
UUID *recordId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; //  (default to null)
IdType *idType = ; //  (default to null)
Boolean *utf = true; // Specify whether to encode the file in UTF-8. (optional) (default to true)
Boolean *suppress999ff = true; // Specify whether to suppress 999ff field. (optional) (default to false)

[apiInstance downloadRecordByIdWith:recordId
    idType:idType
    utf:utf
    suppress999ff:suppress999ff
              completionHandler: ^(File output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var DataExportApi = require('data_export_api');

// Create an instance of the API class
var api = new DataExportApi.DefaultApi()
var recordId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {UUID} 
var idType = ; // {IdType} 
var opts = {
  'utf': true, // {Boolean} Specify whether to encode the file in UTF-8.
  'suppress999ff': true // {Boolean} Specify whether to suppress 999ff field.
};

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

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

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

            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var recordId = 38400000-8cf0-11bd-b23e-10b96e4ef00d;  // UUID |  (default to null)
            var idType = new IdType(); // IdType |  (default to null)
            var utf = true;  // Boolean | Specify whether to encode the file in UTF-8. (optional)  (default to true)
            var suppress999ff = true;  // Boolean | Specify whether to suppress 999ff field. (optional)  (default to false)

            try {
                File result = apiInstance.downloadRecordById(recordId, idType, utf, suppress999ff);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.downloadRecordById: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$recordId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
$idType = ; // IdType | 
$utf = true; // Boolean | Specify whether to encode the file in UTF-8.
$suppress999ff = true; // Boolean | Specify whether to suppress 999ff field.

try {
    $result = $api_instance->downloadRecordById($recordId, $idType, $utf, $suppress999ff);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->downloadRecordById: ', $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 $recordId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | 
my $idType = ; # IdType | 
my $utf = true; # Boolean | Specify whether to encode the file in UTF-8.
my $suppress999ff = true; # Boolean | Specify whether to suppress 999ff field.

eval {
    my $result = $api_instance->downloadRecordById(recordId => $recordId, idType => $idType, utf => $utf, suppress999ff => $suppress999ff);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->downloadRecordById: $@\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()
recordId = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID |  (default to null)
idType =  # IdType |  (default to null)
utf = true # Boolean | Specify whether to encode the file in UTF-8. (optional) (default to true)
suppress999ff = true # Boolean | Specify whether to suppress 999ff field. (optional) (default to false)

try:
    api_response = api_instance.download_record_by_id(recordId, idType, utf=utf, suppress999ff=suppress999ff)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->downloadRecordById: %s\n" % e)
extern crate DefaultApi;

pub fn main() {
    let recordId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID
    let idType = ; // IdType
    let utf = true; // Boolean
    let suppress999ff = true; // Boolean

    let mut context = DefaultApi::Context::default();
    let result = client.downloadRecordById(recordId, idType, utf, suppress999ff, &context).wait();

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

Scopes

Parameters

Path parameters
Name Description
recordId*
UUID (uuid)
Required
Query parameters
Name Description
idType*
IdType
Required
utf
Boolean
Specify whether to encode the file in UTF-8.
suppress999ff
Boolean
Specify whether to suppress 999ff field.

Responses

getErrorLogsByQuery

APIs supporting Error logs


/logs

Usage and SDK Samples

curl -X GET \
 -H "Accept: application/json,text/plain" \
 "http://localhost/data-export/logs?query=query_example&offset=56&limit=56"

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 query = query_example; // String | A query string to filter rules based on matching criteria in fields.
        Integer offset = 56; // Integer | Skip over a number of elements by specifying an offset value for the query
        Integer limit = 56; // Integer | Limit the number of elements returned in the response

        try {
            errorLogCollection result = apiInstance.getErrorLogsByQuery(query, offset, limit);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#getErrorLogsByQuery");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String query = query_example; // String | A query string to filter rules based on matching criteria in fields.
        Integer offset = 56; // Integer | Skip over a number of elements by specifying an offset value for the query
        Integer limit = 56; // Integer | Limit the number of elements returned in the response

        try {
            errorLogCollection result = apiInstance.getErrorLogsByQuery(query, offset, limit);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#getErrorLogsByQuery");
            e.printStackTrace();
        }
    }
}


// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
String *query = query_example; // A query string to filter rules based on matching criteria in fields. (optional) (default to null)
Integer *offset = 56; // Skip over a number of elements by specifying an offset value for the query (optional) (default to 0)
Integer *limit = 56; // Limit the number of elements returned in the response (optional) (default to 10)

[apiInstance getErrorLogsByQueryWith:query
    offset:offset
    limit:limit
              completionHandler: ^(errorLogCollection output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var DataExportApi = require('data_export_api');

// Create an instance of the API class
var api = new DataExportApi.DefaultApi()
var opts = {
  'query': query_example, // {String} A query string to filter rules based on matching criteria in fields.
  'offset': 56, // {Integer} Skip over a number of elements by specifying an offset value for the query
  'limit': 56 // {Integer} Limit the number of elements returned in the response
};

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

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

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

            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var query = query_example;  // String | A query string to filter rules based on matching criteria in fields. (optional)  (default to null)
            var offset = 56;  // Integer | Skip over a number of elements by specifying an offset value for the query (optional)  (default to 0)
            var limit = 56;  // Integer | Limit the number of elements returned in the response (optional)  (default to 10)

            try {
                errorLogCollection result = apiInstance.getErrorLogsByQuery(query, offset, limit);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.getErrorLogsByQuery: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$query = query_example; // String | A query string to filter rules based on matching criteria in fields.
$offset = 56; // Integer | Skip over a number of elements by specifying an offset value for the query
$limit = 56; // Integer | Limit the number of elements returned in the response

try {
    $result = $api_instance->getErrorLogsByQuery($query, $offset, $limit);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->getErrorLogsByQuery: ', $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 $query = query_example; # String | A query string to filter rules based on matching criteria in fields.
my $offset = 56; # Integer | Skip over a number of elements by specifying an offset value for the query
my $limit = 56; # Integer | Limit the number of elements returned in the response

eval {
    my $result = $api_instance->getErrorLogsByQuery(query => $query, offset => $offset, limit => $limit);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->getErrorLogsByQuery: $@\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()
query = query_example # String | A query string to filter rules based on matching criteria in fields. (optional) (default to null)
offset = 56 # Integer | Skip over a number of elements by specifying an offset value for the query (optional) (default to 0)
limit = 56 # Integer | Limit the number of elements returned in the response (optional) (default to 10)

try:
    api_response = api_instance.get_error_logs_by_query(query=query, offset=offset, limit=limit)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->getErrorLogsByQuery: %s\n" % e)
extern crate DefaultApi;

pub fn main() {
    let query = query_example; // String
    let offset = 56; // Integer
    let limit = 56; // Integer

    let mut context = DefaultApi::Context::default();
    let result = client.getErrorLogsByQuery(query, offset, limit, &context).wait();

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

Scopes

Parameters

Query parameters
Name Description
query
String
A query string to filter rules based on matching criteria in fields.
offset
Integer
Skip over a number of elements by specifying an offset value for the query
limit
Integer
Limit the number of elements returned in the response

Responses

getFileDefinitionById

Get specific file definition


/file-definitions/{fileDefinitionId}

Usage and SDK Samples

curl -X GET \
 -H "Accept: application/json,text/plain" \
 "http://localhost/data-export/file-definitions/{fileDefinitionId}"

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();
        UUID fileDefinitionId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

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

import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        UUID fileDefinitionId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

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


// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
UUID *fileDefinitionId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; //  (default to null)

[apiInstance getFileDefinitionByIdWith:fileDefinitionId
              completionHandler: ^(fileDefinition output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var DataExportApi = require('data_export_api');

// Create an instance of the API class
var api = new DataExportApi.DefaultApi()
var fileDefinitionId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {UUID} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var fileDefinitionId = 38400000-8cf0-11bd-b23e-10b96e4ef00d;  // UUID |  (default to null)

            try {
                fileDefinition result = apiInstance.getFileDefinitionById(fileDefinitionId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.getFileDefinitionById: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$fileDefinitionId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

try {
    $result = $api_instance->getFileDefinitionById($fileDefinitionId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->getFileDefinitionById: ', $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 $fileDefinitionId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | 

eval {
    my $result = $api_instance->getFileDefinitionById(fileDefinitionId => $fileDefinitionId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->getFileDefinitionById: $@\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()
fileDefinitionId = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID |  (default to null)

try:
    api_response = api_instance.get_file_definition_by_id(fileDefinitionId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->getFileDefinitionById: %s\n" % e)
extern crate DefaultApi;

pub fn main() {
    let fileDefinitionId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID

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

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

Scopes

Parameters

Path parameters
Name Description
fileDefinitionId*
UUID (uuid)
Required

Responses

getJobExecutionsByQuery

API for getting JobExecutions by query


/job-executions

Usage and SDK Samples

curl -X GET \
 -H "Accept: application/json,text/plain" \
 "http://localhost/data-export/job-executions?query=query_example&offset=56&limit=56"

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 query = query_example; // String | A query string to filter rules based on matching criteria in fields.
        Integer offset = 56; // Integer | Skip over a number of elements by specifying an offset value for the query
        Integer limit = 56; // Integer | Limit the number of elements returned in the response

        try {
            jobExecutionCollection result = apiInstance.getJobExecutionsByQuery(query, offset, limit);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#getJobExecutionsByQuery");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String query = query_example; // String | A query string to filter rules based on matching criteria in fields.
        Integer offset = 56; // Integer | Skip over a number of elements by specifying an offset value for the query
        Integer limit = 56; // Integer | Limit the number of elements returned in the response

        try {
            jobExecutionCollection result = apiInstance.getJobExecutionsByQuery(query, offset, limit);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#getJobExecutionsByQuery");
            e.printStackTrace();
        }
    }
}


// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
String *query = query_example; // A query string to filter rules based on matching criteria in fields. (optional) (default to null)
Integer *offset = 56; // Skip over a number of elements by specifying an offset value for the query (optional) (default to 0)
Integer *limit = 56; // Limit the number of elements returned in the response (optional) (default to 10)

[apiInstance getJobExecutionsByQueryWith:query
    offset:offset
    limit:limit
              completionHandler: ^(jobExecutionCollection output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var DataExportApi = require('data_export_api');

// Create an instance of the API class
var api = new DataExportApi.DefaultApi()
var opts = {
  'query': query_example, // {String} A query string to filter rules based on matching criteria in fields.
  'offset': 56, // {Integer} Skip over a number of elements by specifying an offset value for the query
  'limit': 56 // {Integer} Limit the number of elements returned in the response
};

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

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

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

            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var query = query_example;  // String | A query string to filter rules based on matching criteria in fields. (optional)  (default to null)
            var offset = 56;  // Integer | Skip over a number of elements by specifying an offset value for the query (optional)  (default to 0)
            var limit = 56;  // Integer | Limit the number of elements returned in the response (optional)  (default to 10)

            try {
                jobExecutionCollection result = apiInstance.getJobExecutionsByQuery(query, offset, limit);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.getJobExecutionsByQuery: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$query = query_example; // String | A query string to filter rules based on matching criteria in fields.
$offset = 56; // Integer | Skip over a number of elements by specifying an offset value for the query
$limit = 56; // Integer | Limit the number of elements returned in the response

try {
    $result = $api_instance->getJobExecutionsByQuery($query, $offset, $limit);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->getJobExecutionsByQuery: ', $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 $query = query_example; # String | A query string to filter rules based on matching criteria in fields.
my $offset = 56; # Integer | Skip over a number of elements by specifying an offset value for the query
my $limit = 56; # Integer | Limit the number of elements returned in the response

eval {
    my $result = $api_instance->getJobExecutionsByQuery(query => $query, offset => $offset, limit => $limit);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->getJobExecutionsByQuery: $@\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()
query = query_example # String | A query string to filter rules based on matching criteria in fields. (optional) (default to null)
offset = 56 # Integer | Skip over a number of elements by specifying an offset value for the query (optional) (default to 0)
limit = 56 # Integer | Limit the number of elements returned in the response (optional) (default to 10)

try:
    api_response = api_instance.get_job_executions_by_query(query=query, offset=offset, limit=limit)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->getJobExecutionsByQuery: %s\n" % e)
extern crate DefaultApi;

pub fn main() {
    let query = query_example; // String
    let offset = 56; // Integer
    let limit = 56; // Integer

    let mut context = DefaultApi::Context::default();
    let result = client.getJobExecutionsByQuery(query, offset, limit, &context).wait();

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

Scopes

Parameters

Query parameters
Name Description
query
String
A query string to filter rules based on matching criteria in fields.
offset
Integer
Skip over a number of elements by specifying an offset value for the query
limit
Integer
Limit the number of elements returned in the response

Responses

getJobProfileById

Get specific job profile


/job-profiles/{jobProfileId}

Usage and SDK Samples

curl -X GET \
 -H "Accept: application/json,text/plain" \
 "http://localhost/data-export/job-profiles/{jobProfileId}"

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();
        UUID jobProfileId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

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

import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        UUID jobProfileId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

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


// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
UUID *jobProfileId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; //  (default to null)

[apiInstance getJobProfileByIdWith:jobProfileId
              completionHandler: ^(jobProfile output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var DataExportApi = require('data_export_api');

// Create an instance of the API class
var api = new DataExportApi.DefaultApi()
var jobProfileId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {UUID} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var jobProfileId = 38400000-8cf0-11bd-b23e-10b96e4ef00d;  // UUID |  (default to null)

            try {
                jobProfile result = apiInstance.getJobProfileById(jobProfileId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.getJobProfileById: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$jobProfileId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

try {
    $result = $api_instance->getJobProfileById($jobProfileId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->getJobProfileById: ', $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 $jobProfileId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | 

eval {
    my $result = $api_instance->getJobProfileById(jobProfileId => $jobProfileId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->getJobProfileById: $@\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()
jobProfileId = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID |  (default to null)

try:
    api_response = api_instance.get_job_profile_by_id(jobProfileId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->getJobProfileById: %s\n" % e)
extern crate DefaultApi;

pub fn main() {
    let jobProfileId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID

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

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

Scopes

Parameters

Path parameters
Name Description
jobProfileId*
UUID (uuid)
Required

Responses

getJobProfiles

API for getting job profiles


/job-profiles

Usage and SDK Samples

curl -X GET \
 -H "Accept: application/json,text/plain" \
 "http://localhost/data-export/job-profiles?used=true&query=query_example&offset=56&limit=56"

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();
        Boolean used = true; // Boolean | true if need already used profiles
        String query = query_example; // String | A query string to filter rules based on matching criteria in fields.
        Integer offset = 56; // Integer | Skip over a number of elements by specifying an offset value for the query
        Integer limit = 56; // Integer | Limit the number of elements returned in the response

        try {
            jobProfileCollection result = apiInstance.getJobProfiles(used, query, offset, limit);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#getJobProfiles");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        Boolean used = true; // Boolean | true if need already used profiles
        String query = query_example; // String | A query string to filter rules based on matching criteria in fields.
        Integer offset = 56; // Integer | Skip over a number of elements by specifying an offset value for the query
        Integer limit = 56; // Integer | Limit the number of elements returned in the response

        try {
            jobProfileCollection result = apiInstance.getJobProfiles(used, query, offset, limit);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#getJobProfiles");
            e.printStackTrace();
        }
    }
}


// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
Boolean *used = true; // true if need already used profiles (optional) (default to false)
String *query = query_example; // A query string to filter rules based on matching criteria in fields. (optional) (default to null)
Integer *offset = 56; // Skip over a number of elements by specifying an offset value for the query (optional) (default to 0)
Integer *limit = 56; // Limit the number of elements returned in the response (optional) (default to 10)

[apiInstance getJobProfilesWith:used
    query:query
    offset:offset
    limit:limit
              completionHandler: ^(jobProfileCollection output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var DataExportApi = require('data_export_api');

// Create an instance of the API class
var api = new DataExportApi.DefaultApi()
var opts = {
  'used': true, // {Boolean} true if need already used profiles
  'query': query_example, // {String} A query string to filter rules based on matching criteria in fields.
  'offset': 56, // {Integer} Skip over a number of elements by specifying an offset value for the query
  'limit': 56 // {Integer} Limit the number of elements returned in the response
};

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

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

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

            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var used = true;  // Boolean | true if need already used profiles (optional)  (default to false)
            var query = query_example;  // String | A query string to filter rules based on matching criteria in fields. (optional)  (default to null)
            var offset = 56;  // Integer | Skip over a number of elements by specifying an offset value for the query (optional)  (default to 0)
            var limit = 56;  // Integer | Limit the number of elements returned in the response (optional)  (default to 10)

            try {
                jobProfileCollection result = apiInstance.getJobProfiles(used, query, offset, limit);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.getJobProfiles: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$used = true; // Boolean | true if need already used profiles
$query = query_example; // String | A query string to filter rules based on matching criteria in fields.
$offset = 56; // Integer | Skip over a number of elements by specifying an offset value for the query
$limit = 56; // Integer | Limit the number of elements returned in the response

try {
    $result = $api_instance->getJobProfiles($used, $query, $offset, $limit);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->getJobProfiles: ', $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 $used = true; # Boolean | true if need already used profiles
my $query = query_example; # String | A query string to filter rules based on matching criteria in fields.
my $offset = 56; # Integer | Skip over a number of elements by specifying an offset value for the query
my $limit = 56; # Integer | Limit the number of elements returned in the response

eval {
    my $result = $api_instance->getJobProfiles(used => $used, query => $query, offset => $offset, limit => $limit);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->getJobProfiles: $@\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()
used = true # Boolean | true if need already used profiles (optional) (default to false)
query = query_example # String | A query string to filter rules based on matching criteria in fields. (optional) (default to null)
offset = 56 # Integer | Skip over a number of elements by specifying an offset value for the query (optional) (default to 0)
limit = 56 # Integer | Limit the number of elements returned in the response (optional) (default to 10)

try:
    api_response = api_instance.get_job_profiles(used=used, query=query, offset=offset, limit=limit)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->getJobProfiles: %s\n" % e)
extern crate DefaultApi;

pub fn main() {
    let used = true; // Boolean
    let query = query_example; // String
    let offset = 56; // Integer
    let limit = 56; // Integer

    let mut context = DefaultApi::Context::default();
    let result = client.getJobProfiles(used, query, offset, limit, &context).wait();

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

Scopes

Parameters

Query parameters
Name Description
used
Boolean
true if need already used profiles
query
String
A query string to filter rules based on matching criteria in fields.
offset
Integer
Skip over a number of elements by specifying an offset value for the query
limit
Integer
Limit the number of elements returned in the response

Responses

getLinkToDownloadFiles

API for getting the link to download files


/job-executions/{jobExecutionId}/download/{exportFileId}

Usage and SDK Samples

curl -X GET \
 -H "Accept: application/json,text/plain" \
 "http://localhost/data-export/job-executions/{jobExecutionId}/download/{exportFileId}"

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();
        UUID jobExecutionId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        UUID exportFileId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

        try {
            fileDownload result = apiInstance.getLinkToDownloadFiles(jobExecutionId, exportFileId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#getLinkToDownloadFiles");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        UUID jobExecutionId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        UUID exportFileId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

        try {
            fileDownload result = apiInstance.getLinkToDownloadFiles(jobExecutionId, exportFileId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#getLinkToDownloadFiles");
            e.printStackTrace();
        }
    }
}


// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
UUID *jobExecutionId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; //  (default to null)
UUID *exportFileId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; //  (default to null)

[apiInstance getLinkToDownloadFilesWith:jobExecutionId
    exportFileId:exportFileId
              completionHandler: ^(fileDownload output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var DataExportApi = require('data_export_api');

// Create an instance of the API class
var api = new DataExportApi.DefaultApi()
var jobExecutionId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {UUID} 
var exportFileId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {UUID} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var jobExecutionId = 38400000-8cf0-11bd-b23e-10b96e4ef00d;  // UUID |  (default to null)
            var exportFileId = 38400000-8cf0-11bd-b23e-10b96e4ef00d;  // UUID |  (default to null)

            try {
                fileDownload result = apiInstance.getLinkToDownloadFiles(jobExecutionId, exportFileId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.getLinkToDownloadFiles: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$jobExecutionId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
$exportFileId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

try {
    $result = $api_instance->getLinkToDownloadFiles($jobExecutionId, $exportFileId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->getLinkToDownloadFiles: ', $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 $jobExecutionId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | 
my $exportFileId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | 

eval {
    my $result = $api_instance->getLinkToDownloadFiles(jobExecutionId => $jobExecutionId, exportFileId => $exportFileId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->getLinkToDownloadFiles: $@\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()
jobExecutionId = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID |  (default to null)
exportFileId = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID |  (default to null)

try:
    api_response = api_instance.get_link_to_download_files(jobExecutionId, exportFileId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->getLinkToDownloadFiles: %s\n" % e)
extern crate DefaultApi;

pub fn main() {
    let jobExecutionId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID
    let exportFileId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID

    let mut context = DefaultApi::Context::default();
    let result = client.getLinkToDownloadFiles(jobExecutionId, exportFileId, &context).wait();

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

Scopes

Parameters

Path parameters
Name Description
jobExecutionId*
UUID (uuid)
Required
exportFileId*
UUID (uuid)
Required

Responses

getMappingProfileById

Get specific mapping profile


/mapping-profiles/{mappingProfileId}

Usage and SDK Samples

curl -X GET \
 -H "Accept: application/json,text/plain" \
 "http://localhost/data-export/mapping-profiles/{mappingProfileId}"

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();
        UUID mappingProfileId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

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

import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        UUID mappingProfileId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

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


// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
UUID *mappingProfileId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; //  (default to null)

[apiInstance getMappingProfileByIdWith:mappingProfileId
              completionHandler: ^(mappingProfile output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var DataExportApi = require('data_export_api');

// Create an instance of the API class
var api = new DataExportApi.DefaultApi()
var mappingProfileId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {UUID} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var mappingProfileId = 38400000-8cf0-11bd-b23e-10b96e4ef00d;  // UUID |  (default to null)

            try {
                mappingProfile result = apiInstance.getMappingProfileById(mappingProfileId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.getMappingProfileById: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$mappingProfileId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

try {
    $result = $api_instance->getMappingProfileById($mappingProfileId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->getMappingProfileById: ', $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 $mappingProfileId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | 

eval {
    my $result = $api_instance->getMappingProfileById(mappingProfileId => $mappingProfileId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->getMappingProfileById: $@\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()
mappingProfileId = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID |  (default to null)

try:
    api_response = api_instance.get_mapping_profile_by_id(mappingProfileId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->getMappingProfileById: %s\n" % e)
extern crate DefaultApi;

pub fn main() {
    let mappingProfileId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID

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

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

Scopes

Parameters

Path parameters
Name Description
mappingProfileId*
UUID (uuid)
Required

Responses

getMappingProfiles

API for getting mapping profiles


/mapping-profiles

Usage and SDK Samples

curl -X GET \
 -H "Accept: application/json,text/plain" \
 "http://localhost/data-export/mapping-profiles?query=query_example&offset=56&limit=56"

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 query = query_example; // String | A query string to filter rules based on matching criteria in fields.
        Integer offset = 56; // Integer | Skip over a number of elements by specifying an offset value for the query
        Integer limit = 56; // Integer | Limit the number of elements returned in the response

        try {
            mappingProfileCollection result = apiInstance.getMappingProfiles(query, offset, limit);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#getMappingProfiles");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String query = query_example; // String | A query string to filter rules based on matching criteria in fields.
        Integer offset = 56; // Integer | Skip over a number of elements by specifying an offset value for the query
        Integer limit = 56; // Integer | Limit the number of elements returned in the response

        try {
            mappingProfileCollection result = apiInstance.getMappingProfiles(query, offset, limit);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#getMappingProfiles");
            e.printStackTrace();
        }
    }
}


// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
String *query = query_example; // A query string to filter rules based on matching criteria in fields. (optional) (default to null)
Integer *offset = 56; // Skip over a number of elements by specifying an offset value for the query (optional) (default to 0)
Integer *limit = 56; // Limit the number of elements returned in the response (optional) (default to 10)

[apiInstance getMappingProfilesWith:query
    offset:offset
    limit:limit
              completionHandler: ^(mappingProfileCollection output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var DataExportApi = require('data_export_api');

// Create an instance of the API class
var api = new DataExportApi.DefaultApi()
var opts = {
  'query': query_example, // {String} A query string to filter rules based on matching criteria in fields.
  'offset': 56, // {Integer} Skip over a number of elements by specifying an offset value for the query
  'limit': 56 // {Integer} Limit the number of elements returned in the response
};

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

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

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

            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var query = query_example;  // String | A query string to filter rules based on matching criteria in fields. (optional)  (default to null)
            var offset = 56;  // Integer | Skip over a number of elements by specifying an offset value for the query (optional)  (default to 0)
            var limit = 56;  // Integer | Limit the number of elements returned in the response (optional)  (default to 10)

            try {
                mappingProfileCollection result = apiInstance.getMappingProfiles(query, offset, limit);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.getMappingProfiles: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$query = query_example; // String | A query string to filter rules based on matching criteria in fields.
$offset = 56; // Integer | Skip over a number of elements by specifying an offset value for the query
$limit = 56; // Integer | Limit the number of elements returned in the response

try {
    $result = $api_instance->getMappingProfiles($query, $offset, $limit);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->getMappingProfiles: ', $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 $query = query_example; # String | A query string to filter rules based on matching criteria in fields.
my $offset = 56; # Integer | Skip over a number of elements by specifying an offset value for the query
my $limit = 56; # Integer | Limit the number of elements returned in the response

eval {
    my $result = $api_instance->getMappingProfiles(query => $query, offset => $offset, limit => $limit);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->getMappingProfiles: $@\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()
query = query_example # String | A query string to filter rules based on matching criteria in fields. (optional) (default to null)
offset = 56 # Integer | Skip over a number of elements by specifying an offset value for the query (optional) (default to 0)
limit = 56 # Integer | Limit the number of elements returned in the response (optional) (default to 10)

try:
    api_response = api_instance.get_mapping_profiles(query=query, offset=offset, limit=limit)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->getMappingProfiles: %s\n" % e)
extern crate DefaultApi;

pub fn main() {
    let query = query_example; // String
    let offset = 56; // Integer
    let limit = 56; // Integer

    let mut context = DefaultApi::Context::default();
    let result = client.getMappingProfiles(query, offset, limit, &context).wait();

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

Scopes

Parameters

Query parameters
Name Description
query
String
A query string to filter rules based on matching criteria in fields.
offset
Integer
Skip over a number of elements by specifying an offset value for the query
limit
Integer
Limit the number of elements returned in the response

Responses

getRelatedUsers

Get only users who have ever started export


/related-users

Usage and SDK Samples

curl -X GET \
 -H "Accept: application/json,text/plain" \
 "http://localhost/data-export/related-users"

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 {
            relatedUserCollection result = apiInstance.getRelatedUsers();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#getRelatedUsers");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.DefaultApi;

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

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


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

[apiInstance getRelatedUsersWithCompletionHandler: 
              ^(relatedUserCollection output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var DataExportApi = require('data_export_api');

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

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

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

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

            try {
                relatedUserCollection result = apiInstance.getRelatedUsers();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.getRelatedUsers: " + 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->getRelatedUsers();
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->getRelatedUsers: ', $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->getRelatedUsers();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->getRelatedUsers: $@\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:
    api_response = api_instance.get_related_users()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->getRelatedUsers: %s\n" % e)
extern crate DefaultApi;

pub fn main() {

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

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

Scopes

Parameters

Responses

getTransformationFields

API for getting transformation fields


/transformation-fields

Usage and SDK Samples

curl -X GET \
 -H "Accept: application/json,text/plain" \
 "http://localhost/data-export/transformation-fields"

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 {
            transformationFieldCollection result = apiInstance.getTransformationFields();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#getTransformationFields");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.DefaultApi;

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

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


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

[apiInstance getTransformationFieldsWithCompletionHandler: 
              ^(transformationFieldCollection output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var DataExportApi = require('data_export_api');

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

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

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

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

            try {
                transformationFieldCollection result = apiInstance.getTransformationFields();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.getTransformationFields: " + 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->getTransformationFields();
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->getTransformationFields: ', $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->getTransformationFields();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->getTransformationFields: $@\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:
    api_response = api_instance.get_transformation_fields()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->getTransformationFields: %s\n" % e)
extern crate DefaultApi;

pub fn main() {

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

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

Scopes

Parameters

Responses

postCleanUpFiles

API to start clean up mechanism of file definitions and related generated files


/clean-up-files

Usage and SDK Samples

curl -X POST \
 -H "Accept: text/plain,application/json" \
 "http://localhost/data-export/clean-up-files"

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 {
            apiInstance.postCleanUpFiles();
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#postCleanUpFiles");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.DefaultApi;

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

        try {
            apiInstance.postCleanUpFiles();
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#postCleanUpFiles");
            e.printStackTrace();
        }
    }
}


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

[apiInstance postCleanUpFilesWithCompletionHandler: 
              ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var DataExportApi = require('data_export_api');

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

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

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

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

            try {
                apiInstance.postCleanUpFiles();
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.postCleanUpFiles: " + e.Message );
            }
        }
    }
}

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

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

try {
    $api_instance->postCleanUpFiles();
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->postCleanUpFiles: ', $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 {
    $api_instance->postCleanUpFiles();
};
if ($@) {
    warn "Exception when calling DefaultApi->postCleanUpFiles: $@\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:
    api_instance.post_clean_up_files()
except ApiException as e:
    print("Exception when calling DefaultApi->postCleanUpFiles: %s\n" % e)
extern crate DefaultApi;

pub fn main() {

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

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

Scopes

Parameters

Responses

postDataExport

Starts the export process


/export

Usage and SDK Samples

curl -X POST \
 -H "Accept: text/plain,application/json" \
 -H "Content-Type: application/json" \
 "http://localhost/data-export/export" \
 -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();
        ExportRequest exportRequest = {"$ref":"examples/exportRequest.json"}; // ExportRequest | 

        try {
            apiInstance.postDataExport(exportRequest);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#postDataExport");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        ExportRequest exportRequest = {"$ref":"examples/exportRequest.json"}; // ExportRequest | 

        try {
            apiInstance.postDataExport(exportRequest);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#postDataExport");
            e.printStackTrace();
        }
    }
}


// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
ExportRequest *exportRequest = {"$ref":"examples/exportRequest.json"}; // 

[apiInstance postDataExportWith:exportRequest
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var DataExportApi = require('data_export_api');

// Create an instance of the API class
var api = new DataExportApi.DefaultApi()
var exportRequest = {"$ref":"examples/exportRequest.json"}; // {ExportRequest} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.postDataExport(exportRequest, callback);

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

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

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

            try {
                apiInstance.postDataExport(exportRequest);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.postDataExport: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$exportRequest = {"$ref":"examples/exportRequest.json"}; // ExportRequest | 

try {
    $api_instance->postDataExport($exportRequest);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->postDataExport: ', $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 $exportRequest = WWW::OPenAPIClient::Object::ExportRequest->new(); # ExportRequest | 

eval {
    $api_instance->postDataExport(exportRequest => $exportRequest);
};
if ($@) {
    warn "Exception when calling DefaultApi->postDataExport: $@\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()
exportRequest = {"$ref":"examples/exportRequest.json"} # ExportRequest | 

try:
    api_instance.post_data_export(exportRequest)
except ApiException as e:
    print("Exception when calling DefaultApi->postDataExport: %s\n" % e)
extern crate DefaultApi;

pub fn main() {
    let exportRequest = {"$ref":"examples/exportRequest.json"}; // ExportRequest

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

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

Scopes

Parameters

Body parameters
Name Description
exportRequest *

Responses

postDataExportConfiguration

Adds configuration value


/configuration

Usage and SDK Samples

curl -X POST \
 -H "Accept: application/json,text/plain" \
 -H "Content-Type: application/json" \
 "http://localhost/data-export/configuration" \
 -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();
        Config config = {"$ref":"examples/configuration/config.json"}; // Config | 

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

import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        Config config = {"$ref":"examples/configuration/config.json"}; // Config | 

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


// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
Config *config = {"$ref":"examples/configuration/config.json"}; // 

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

var DataExportApi = require('data_export_api');

// Create an instance of the API class
var api = new DataExportApi.DefaultApi()
var config = {"$ref":"examples/configuration/config.json"}; // {Config} 

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

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

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

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

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

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$config = {"$ref":"examples/configuration/config.json"}; // Config | 

try {
    $result = $api_instance->postDataExportConfiguration($config);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->postDataExportConfiguration: ', $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 $config = WWW::OPenAPIClient::Object::Config->new(); # Config | 

eval {
    my $result = $api_instance->postDataExportConfiguration(config => $config);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->postDataExportConfiguration: $@\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()
config = {"$ref":"examples/configuration/config.json"} # Config | 

try:
    api_response = api_instance.post_data_export_configuration(config)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->postDataExportConfiguration: %s\n" % e)
extern crate DefaultApi;

pub fn main() {
    let config = {"$ref":"examples/configuration/config.json"}; // Config

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

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

Scopes

Parameters

Body parameters
Name Description
config *

Responses

postDataExportQuickExport

Starts quick export process


/quick-export

Usage and SDK Samples

curl -X POST \
 -H "Accept: application/json,text/plain" \
 -H "Content-Type: application/json" \
 "http://localhost/data-export/quick-export" \
 -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();
        QuickExportRequest quickExportRequest = {"$ref":"examples/quickExportRequest.json"}; // QuickExportRequest | 

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

import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        QuickExportRequest quickExportRequest = {"$ref":"examples/quickExportRequest.json"}; // QuickExportRequest | 

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


// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
QuickExportRequest *quickExportRequest = {"$ref":"examples/quickExportRequest.json"}; // 

[apiInstance postDataExportQuickExportWith:quickExportRequest
              completionHandler: ^(quickExportResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var DataExportApi = require('data_export_api');

// Create an instance of the API class
var api = new DataExportApi.DefaultApi()
var quickExportRequest = {"$ref":"examples/quickExportRequest.json"}; // {QuickExportRequest} 

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

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

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

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

            try {
                quickExportResponse result = apiInstance.postDataExportQuickExport(quickExportRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.postDataExportQuickExport: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$quickExportRequest = {"$ref":"examples/quickExportRequest.json"}; // QuickExportRequest | 

try {
    $result = $api_instance->postDataExportQuickExport($quickExportRequest);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->postDataExportQuickExport: ', $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 $quickExportRequest = WWW::OPenAPIClient::Object::QuickExportRequest->new(); # QuickExportRequest | 

eval {
    my $result = $api_instance->postDataExportQuickExport(quickExportRequest => $quickExportRequest);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->postDataExportQuickExport: $@\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()
quickExportRequest = {"$ref":"examples/quickExportRequest.json"} # QuickExportRequest | 

try:
    api_response = api_instance.post_data_export_quick_export(quickExportRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->postDataExportQuickExport: %s\n" % e)
extern crate DefaultApi;

pub fn main() {
    let quickExportRequest = {"$ref":"examples/quickExportRequest.json"}; // QuickExportRequest

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

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

Scopes

Parameters

Body parameters
Name Description
quickExportRequest *

Responses

postExpireJobExecution

Method to expire long running jobs


/expire-jobs

Usage and SDK Samples

curl -X POST \
 -H "Accept: text/plain,application/json" \
 "http://localhost/data-export/expire-jobs"

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 {
            apiInstance.postExpireJobExecution();
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#postExpireJobExecution");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.DefaultApi;

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

        try {
            apiInstance.postExpireJobExecution();
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#postExpireJobExecution");
            e.printStackTrace();
        }
    }
}


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

[apiInstance postExpireJobExecutionWithCompletionHandler: 
              ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var DataExportApi = require('data_export_api');

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

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

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

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

            try {
                apiInstance.postExpireJobExecution();
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.postExpireJobExecution: " + e.Message );
            }
        }
    }
}

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

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

try {
    $api_instance->postExpireJobExecution();
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->postExpireJobExecution: ', $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 {
    $api_instance->postExpireJobExecution();
};
if ($@) {
    warn "Exception when calling DefaultApi->postExpireJobExecution: $@\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:
    api_instance.post_expire_job_execution()
except ApiException as e:
    print("Exception when calling DefaultApi->postExpireJobExecution: %s\n" % e)
extern crate DefaultApi;

pub fn main() {

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

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

Scopes

Parameters

Responses

postExportAll

Export all records of the specific type


/export-all

Usage and SDK Samples

curl -X POST \
 -H "Accept: text/plain,application/json" \
 -H "Content-Type: application/json" \
 "http://localhost/data-export/export-all" \
 -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();
        ExportAllRequest exportAllRequest = {"$ref":"examples/exportAllRequest.json"}; // ExportAllRequest | 

        try {
            apiInstance.postExportAll(exportAllRequest);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#postExportAll");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        ExportAllRequest exportAllRequest = {"$ref":"examples/exportAllRequest.json"}; // ExportAllRequest | 

        try {
            apiInstance.postExportAll(exportAllRequest);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#postExportAll");
            e.printStackTrace();
        }
    }
}


// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
ExportAllRequest *exportAllRequest = {"$ref":"examples/exportAllRequest.json"}; // 

[apiInstance postExportAllWith:exportAllRequest
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var DataExportApi = require('data_export_api');

// Create an instance of the API class
var api = new DataExportApi.DefaultApi()
var exportAllRequest = {"$ref":"examples/exportAllRequest.json"}; // {ExportAllRequest} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.postExportAll(exportAllRequest, callback);

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

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

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

            try {
                apiInstance.postExportAll(exportAllRequest);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.postExportAll: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$exportAllRequest = {"$ref":"examples/exportAllRequest.json"}; // ExportAllRequest | 

try {
    $api_instance->postExportAll($exportAllRequest);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->postExportAll: ', $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 $exportAllRequest = WWW::OPenAPIClient::Object::ExportAllRequest->new(); # ExportAllRequest | 

eval {
    $api_instance->postExportAll(exportAllRequest => $exportAllRequest);
};
if ($@) {
    warn "Exception when calling DefaultApi->postExportAll: $@\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()
exportAllRequest = {"$ref":"examples/exportAllRequest.json"} # ExportAllRequest | 

try:
    api_instance.post_export_all(exportAllRequest)
except ApiException as e:
    print("Exception when calling DefaultApi->postExportAll: %s\n" % e)
extern crate DefaultApi;

pub fn main() {
    let exportAllRequest = {"$ref":"examples/exportAllRequest.json"}; // ExportAllRequest

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

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

Scopes

Parameters

Body parameters
Name Description
exportAllRequest *

Responses

postExportDeletedAuthority

Export of deleted authority records


/export-authority-deleted

Usage and SDK Samples

curl -X POST \
 -H "Accept: application/json,text/plain" \
 -H "Content-Type: application/json" \
 "http://localhost/data-export/export-authority-deleted" \
 -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();
        ExportAuthorityDeletedRequest exportAuthorityDeletedRequest = {"$ref":"examples/exportAuthorityDeletedRequest.json"}; // ExportAuthorityDeletedRequest | 

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

import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        ExportAuthorityDeletedRequest exportAuthorityDeletedRequest = {"$ref":"examples/exportAuthorityDeletedRequest.json"}; // ExportAuthorityDeletedRequest | 

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


// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
ExportAuthorityDeletedRequest *exportAuthorityDeletedRequest = {"$ref":"examples/exportAuthorityDeletedRequest.json"}; //  (optional)

[apiInstance postExportDeletedAuthorityWith:exportAuthorityDeletedRequest
              completionHandler: ^(exportAuthorityDeletedResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var DataExportApi = require('data_export_api');

// Create an instance of the API class
var api = new DataExportApi.DefaultApi()
var opts = {
  'exportAuthorityDeletedRequest': {"$ref":"examples/exportAuthorityDeletedRequest.json"} // {ExportAuthorityDeletedRequest} 
};

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

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

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

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

            try {
                exportAuthorityDeletedResponse result = apiInstance.postExportDeletedAuthority(exportAuthorityDeletedRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.postExportDeletedAuthority: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$exportAuthorityDeletedRequest = {"$ref":"examples/exportAuthorityDeletedRequest.json"}; // ExportAuthorityDeletedRequest | 

try {
    $result = $api_instance->postExportDeletedAuthority($exportAuthorityDeletedRequest);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->postExportDeletedAuthority: ', $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 $exportAuthorityDeletedRequest = WWW::OPenAPIClient::Object::ExportAuthorityDeletedRequest->new(); # ExportAuthorityDeletedRequest | 

eval {
    my $result = $api_instance->postExportDeletedAuthority(exportAuthorityDeletedRequest => $exportAuthorityDeletedRequest);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->postExportDeletedAuthority: $@\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()
exportAuthorityDeletedRequest = {"$ref":"examples/exportAuthorityDeletedRequest.json"} # ExportAuthorityDeletedRequest |  (optional)

try:
    api_response = api_instance.post_export_deleted_authority(exportAuthorityDeletedRequest=exportAuthorityDeletedRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->postExportDeletedAuthority: %s\n" % e)
extern crate DefaultApi;

pub fn main() {
    let exportAuthorityDeletedRequest = {"$ref":"examples/exportAuthorityDeletedRequest.json"}; // ExportAuthorityDeletedRequest

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

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

Scopes

Parameters

Body parameters
Name Description
exportAuthorityDeletedRequest

Responses

postExportDeletedMarcIds

Export of deleted MARC IDs


/export-deleted

Usage and SDK Samples

curl -X POST \
 -H "Accept: application/json,text/plain" \
 -H "Content-Type: application/json" \
 "http://localhost/data-export/export-deleted" \
 -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();
        ExportDeletedMarcIdsRequest exportDeletedMarcIdsRequest = {"$ref":"examples/exportDeletedMarcIdsRequest.json"}; // ExportDeletedMarcIdsRequest | 

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

import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        ExportDeletedMarcIdsRequest exportDeletedMarcIdsRequest = {"$ref":"examples/exportDeletedMarcIdsRequest.json"}; // ExportDeletedMarcIdsRequest | 

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


// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
ExportDeletedMarcIdsRequest *exportDeletedMarcIdsRequest = {"$ref":"examples/exportDeletedMarcIdsRequest.json"}; //  (optional)

[apiInstance postExportDeletedMarcIdsWith:exportDeletedMarcIdsRequest
              completionHandler: ^(exportDeletedMarcIdsResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var DataExportApi = require('data_export_api');

// Create an instance of the API class
var api = new DataExportApi.DefaultApi()
var opts = {
  'exportDeletedMarcIdsRequest': {"$ref":"examples/exportDeletedMarcIdsRequest.json"} // {ExportDeletedMarcIdsRequest} 
};

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

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

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

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

            try {
                exportDeletedMarcIdsResponse result = apiInstance.postExportDeletedMarcIds(exportDeletedMarcIdsRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.postExportDeletedMarcIds: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$exportDeletedMarcIdsRequest = {"$ref":"examples/exportDeletedMarcIdsRequest.json"}; // ExportDeletedMarcIdsRequest | 

try {
    $result = $api_instance->postExportDeletedMarcIds($exportDeletedMarcIdsRequest);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->postExportDeletedMarcIds: ', $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 $exportDeletedMarcIdsRequest = WWW::OPenAPIClient::Object::ExportDeletedMarcIdsRequest->new(); # ExportDeletedMarcIdsRequest | 

eval {
    my $result = $api_instance->postExportDeletedMarcIds(exportDeletedMarcIdsRequest => $exportDeletedMarcIdsRequest);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->postExportDeletedMarcIds: $@\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()
exportDeletedMarcIdsRequest = {"$ref":"examples/exportDeletedMarcIdsRequest.json"} # ExportDeletedMarcIdsRequest |  (optional)

try:
    api_response = api_instance.post_export_deleted_marc_ids(exportDeletedMarcIdsRequest=exportDeletedMarcIdsRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->postExportDeletedMarcIds: %s\n" % e)
extern crate DefaultApi;

pub fn main() {
    let exportDeletedMarcIdsRequest = {"$ref":"examples/exportDeletedMarcIdsRequest.json"}; // ExportDeletedMarcIdsRequest

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

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

Scopes

Parameters

Body parameters
Name Description
exportDeletedMarcIdsRequest

Responses

postFileDefinition

API for uploading files


/file-definitions

Usage and SDK Samples

curl -X POST \
 -H "Accept: application/json,text/plain" \
 -H "Content-Type: application/json" \
 "http://localhost/data-export/file-definitions" \
 -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();
        FileDefinition fileDefinition = {"$ref":"examples/fileDefinition.json"}; // FileDefinition | 

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

import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        FileDefinition fileDefinition = {"$ref":"examples/fileDefinition.json"}; // FileDefinition | 

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


// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
FileDefinition *fileDefinition = {"$ref":"examples/fileDefinition.json"}; // 

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

var DataExportApi = require('data_export_api');

// Create an instance of the API class
var api = new DataExportApi.DefaultApi()
var fileDefinition = {"$ref":"examples/fileDefinition.json"}; // {FileDefinition} 

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

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

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

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

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

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$fileDefinition = {"$ref":"examples/fileDefinition.json"}; // FileDefinition | 

try {
    $result = $api_instance->postFileDefinition($fileDefinition);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->postFileDefinition: ', $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 $fileDefinition = WWW::OPenAPIClient::Object::FileDefinition->new(); # FileDefinition | 

eval {
    my $result = $api_instance->postFileDefinition(fileDefinition => $fileDefinition);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->postFileDefinition: $@\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()
fileDefinition = {"$ref":"examples/fileDefinition.json"} # FileDefinition | 

try:
    api_response = api_instance.post_file_definition(fileDefinition)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->postFileDefinition: %s\n" % e)
extern crate DefaultApi;

pub fn main() {
    let fileDefinition = {"$ref":"examples/fileDefinition.json"}; // FileDefinition

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

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

Scopes

Parameters

Body parameters
Name Description
fileDefinition *

Responses

postJobProfile

API for uploading job profiles


/job-profiles

Usage and SDK Samples

curl -X POST \
 -H "Accept: application/json,text/plain" \
 -H "Content-Type: application/json" \
 "http://localhost/data-export/job-profiles" \
 -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();
        JobProfile jobProfile = {"$ref":"examples/profiles/jobProfile.json"}; // JobProfile | 

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

import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        JobProfile jobProfile = {"$ref":"examples/profiles/jobProfile.json"}; // JobProfile | 

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


// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
JobProfile *jobProfile = {"$ref":"examples/profiles/jobProfile.json"}; // 

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

var DataExportApi = require('data_export_api');

// Create an instance of the API class
var api = new DataExportApi.DefaultApi()
var jobProfile = {"$ref":"examples/profiles/jobProfile.json"}; // {JobProfile} 

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

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

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

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

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

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$jobProfile = {"$ref":"examples/profiles/jobProfile.json"}; // JobProfile | 

try {
    $result = $api_instance->postJobProfile($jobProfile);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->postJobProfile: ', $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 $jobProfile = WWW::OPenAPIClient::Object::JobProfile->new(); # JobProfile | 

eval {
    my $result = $api_instance->postJobProfile(jobProfile => $jobProfile);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->postJobProfile: $@\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()
jobProfile = {"$ref":"examples/profiles/jobProfile.json"} # JobProfile | 

try:
    api_response = api_instance.post_job_profile(jobProfile)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->postJobProfile: %s\n" % e)
extern crate DefaultApi;

pub fn main() {
    let jobProfile = {"$ref":"examples/profiles/jobProfile.json"}; // JobProfile

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

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

Scopes

Parameters

Body parameters
Name Description
jobProfile *

Responses

postMappingProfile

API for uploading mapping profiles


/mapping-profiles

Usage and SDK Samples

curl -X POST \
 -H "Accept: application/json,text/plain" \
 -H "Content-Type: application/json" \
 "http://localhost/data-export/mapping-profiles" \
 -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();
        MappingProfile mappingProfile = {"$ref":"examples/profiles/mappingProfile.json"}; // MappingProfile | 

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

import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        MappingProfile mappingProfile = {"$ref":"examples/profiles/mappingProfile.json"}; // MappingProfile | 

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


// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
MappingProfile *mappingProfile = {"$ref":"examples/profiles/mappingProfile.json"}; // 

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

var DataExportApi = require('data_export_api');

// Create an instance of the API class
var api = new DataExportApi.DefaultApi()
var mappingProfile = {"$ref":"examples/profiles/mappingProfile.json"}; // {MappingProfile} 

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

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

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

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

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

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$mappingProfile = {"$ref":"examples/profiles/mappingProfile.json"}; // MappingProfile | 

try {
    $result = $api_instance->postMappingProfile($mappingProfile);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->postMappingProfile: ', $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 $mappingProfile = WWW::OPenAPIClient::Object::MappingProfile->new(); # MappingProfile | 

eval {
    my $result = $api_instance->postMappingProfile(mappingProfile => $mappingProfile);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->postMappingProfile: $@\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()
mappingProfile = {"$ref":"examples/profiles/mappingProfile.json"} # MappingProfile | 

try:
    api_response = api_instance.post_mapping_profile(mappingProfile)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->postMappingProfile: %s\n" % e)
extern crate DefaultApi;

pub fn main() {
    let mappingProfile = {"$ref":"examples/profiles/mappingProfile.json"}; // MappingProfile

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

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

Scopes

Parameters

Body parameters
Name Description
mappingProfile *

Responses

putJobProfile

Update specific job profile


/job-profiles/{jobProfileId}

Usage and SDK Samples

curl -X PUT \
 -H "Accept: text/plain" \
 -H "Content-Type: application/json" \
 "http://localhost/data-export/job-profiles/{jobProfileId}" \
 -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();
        UUID jobProfileId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        JobProfile jobProfile = {"$ref":"examples/profiles/jobProfile.json"}; // JobProfile | 

        try {
            apiInstance.putJobProfile(jobProfileId, jobProfile);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#putJobProfile");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        UUID jobProfileId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        JobProfile jobProfile = {"$ref":"examples/profiles/jobProfile.json"}; // JobProfile | 

        try {
            apiInstance.putJobProfile(jobProfileId, jobProfile);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#putJobProfile");
            e.printStackTrace();
        }
    }
}


// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
UUID *jobProfileId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; //  (default to null)
JobProfile *jobProfile = {"$ref":"examples/profiles/jobProfile.json"}; // 

[apiInstance putJobProfileWith:jobProfileId
    jobProfile:jobProfile
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var DataExportApi = require('data_export_api');

// Create an instance of the API class
var api = new DataExportApi.DefaultApi()
var jobProfileId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {UUID} 
var jobProfile = {"$ref":"examples/profiles/jobProfile.json"}; // {JobProfile} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.putJobProfile(jobProfileId, jobProfile, callback);

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

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

            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var jobProfileId = 38400000-8cf0-11bd-b23e-10b96e4ef00d;  // UUID |  (default to null)
            var jobProfile = new JobProfile(); // JobProfile | 

            try {
                apiInstance.putJobProfile(jobProfileId, jobProfile);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.putJobProfile: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$jobProfileId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
$jobProfile = {"$ref":"examples/profiles/jobProfile.json"}; // JobProfile | 

try {
    $api_instance->putJobProfile($jobProfileId, $jobProfile);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->putJobProfile: ', $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 $jobProfileId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | 
my $jobProfile = WWW::OPenAPIClient::Object::JobProfile->new(); # JobProfile | 

eval {
    $api_instance->putJobProfile(jobProfileId => $jobProfileId, jobProfile => $jobProfile);
};
if ($@) {
    warn "Exception when calling DefaultApi->putJobProfile: $@\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()
jobProfileId = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID |  (default to null)
jobProfile = {"$ref":"examples/profiles/jobProfile.json"} # JobProfile | 

try:
    api_instance.put_job_profile(jobProfileId, jobProfile)
except ApiException as e:
    print("Exception when calling DefaultApi->putJobProfile: %s\n" % e)
extern crate DefaultApi;

pub fn main() {
    let jobProfileId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID
    let jobProfile = {"$ref":"examples/profiles/jobProfile.json"}; // JobProfile

    let mut context = DefaultApi::Context::default();
    let result = client.putJobProfile(jobProfileId, jobProfile, &context).wait();

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

Scopes

Parameters

Path parameters
Name Description
jobProfileId*
UUID (uuid)
Required
Body parameters
Name Description
jobProfile *

Responses

putMappingProfile

Update specific mapping profile


/mapping-profiles/{mappingProfileId}

Usage and SDK Samples

curl -X PUT \
 -H "Accept: text/plain" \
 -H "Content-Type: application/json" \
 "http://localhost/data-export/mapping-profiles/{mappingProfileId}" \
 -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();
        UUID mappingProfileId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        MappingProfile mappingProfile = {"$ref":"examples/profiles/mappingProfile.json"}; // MappingProfile | 

        try {
            apiInstance.putMappingProfile(mappingProfileId, mappingProfile);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#putMappingProfile");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        UUID mappingProfileId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        MappingProfile mappingProfile = {"$ref":"examples/profiles/mappingProfile.json"}; // MappingProfile | 

        try {
            apiInstance.putMappingProfile(mappingProfileId, mappingProfile);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#putMappingProfile");
            e.printStackTrace();
        }
    }
}


// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
UUID *mappingProfileId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; //  (default to null)
MappingProfile *mappingProfile = {"$ref":"examples/profiles/mappingProfile.json"}; // 

[apiInstance putMappingProfileWith:mappingProfileId
    mappingProfile:mappingProfile
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var DataExportApi = require('data_export_api');

// Create an instance of the API class
var api = new DataExportApi.DefaultApi()
var mappingProfileId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {UUID} 
var mappingProfile = {"$ref":"examples/profiles/mappingProfile.json"}; // {MappingProfile} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.putMappingProfile(mappingProfileId, mappingProfile, callback);

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

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

            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var mappingProfileId = 38400000-8cf0-11bd-b23e-10b96e4ef00d;  // UUID |  (default to null)
            var mappingProfile = new MappingProfile(); // MappingProfile | 

            try {
                apiInstance.putMappingProfile(mappingProfileId, mappingProfile);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.putMappingProfile: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$mappingProfileId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
$mappingProfile = {"$ref":"examples/profiles/mappingProfile.json"}; // MappingProfile | 

try {
    $api_instance->putMappingProfile($mappingProfileId, $mappingProfile);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->putMappingProfile: ', $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 $mappingProfileId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | 
my $mappingProfile = WWW::OPenAPIClient::Object::MappingProfile->new(); # MappingProfile | 

eval {
    $api_instance->putMappingProfile(mappingProfileId => $mappingProfileId, mappingProfile => $mappingProfile);
};
if ($@) {
    warn "Exception when calling DefaultApi->putMappingProfile: $@\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()
mappingProfileId = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID |  (default to null)
mappingProfile = {"$ref":"examples/profiles/mappingProfile.json"} # MappingProfile | 

try:
    api_instance.put_mapping_profile(mappingProfileId, mappingProfile)
except ApiException as e:
    print("Exception when calling DefaultApi->putMappingProfile: %s\n" % e)
extern crate DefaultApi;

pub fn main() {
    let mappingProfileId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID
    let mappingProfile = {"$ref":"examples/profiles/mappingProfile.json"}; // MappingProfile

    let mut context = DefaultApi::Context::default();
    let result = client.putMappingProfile(mappingProfileId, mappingProfile, &context).wait();

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

Scopes

Parameters

Path parameters
Name Description
mappingProfileId*
UUID (uuid)
Required
Body parameters
Name Description
mappingProfile *

Responses

uploadFile

Upload file definition


/file-definitions/{fileDefinitionId}/upload

Usage and SDK Samples

curl -X POST \
 -H "Accept: application/json,text/plain" \
 -H "Content-Type: application/octet-stream" \
 "http://localhost/data-export/file-definitions/{fileDefinitionId}/upload" \
 -d 'Custom MIME type example not yet supported: application/octet-stream'

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();
        UUID fileDefinitionId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        File body = BINARY_DATA_HERE; // File | 

        try {
            fileDefinition result = apiInstance.uploadFile(fileDefinitionId, body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#uploadFile");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.DefaultApi;

public class DefaultApiExample {
    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        UUID fileDefinitionId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        File body = BINARY_DATA_HERE; // File | 

        try {
            fileDefinition result = apiInstance.uploadFile(fileDefinitionId, body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#uploadFile");
            e.printStackTrace();
        }
    }
}


// Create an instance of the API class
DefaultApi *apiInstance = [[DefaultApi alloc] init];
UUID *fileDefinitionId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; //  (default to null)
File *body = BINARY_DATA_HERE; //  (optional)

[apiInstance uploadFileWith:fileDefinitionId
    body:body
              completionHandler: ^(fileDefinition output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var DataExportApi = require('data_export_api');

// Create an instance of the API class
var api = new DataExportApi.DefaultApi()
var fileDefinitionId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {UUID} 
var opts = {
  'body': BINARY_DATA_HERE // {File} 
};

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

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

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

            // Create an instance of the API class
            var apiInstance = new DefaultApi();
            var fileDefinitionId = 38400000-8cf0-11bd-b23e-10b96e4ef00d;  // UUID |  (default to null)
            var body = BINARY_DATA_HERE;  // File |  (optional) 

            try {
                fileDefinition result = apiInstance.uploadFile(fileDefinitionId, body);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DefaultApi.uploadFile: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DefaultApi();
$fileDefinitionId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
$body = BINARY_DATA_HERE; // File | 

try {
    $result = $api_instance->uploadFile($fileDefinitionId, $body);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DefaultApi->uploadFile: ', $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 $fileDefinitionId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | 
my $body = WWW::OPenAPIClient::Object::File->new(); # File | 

eval {
    my $result = $api_instance->uploadFile(fileDefinitionId => $fileDefinitionId, body => $body);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->uploadFile: $@\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()
fileDefinitionId = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID |  (default to null)
body = BINARY_DATA_HERE # File |  (optional)

try:
    api_response = api_instance.upload_file(fileDefinitionId, body=body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DefaultApi->uploadFile: %s\n" % e)
extern crate DefaultApi;

pub fn main() {
    let fileDefinitionId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID
    let body = BINARY_DATA_HERE; // File

    let mut context = DefaultApi::Context::default();
    let result = client.uploadFile(fileDefinitionId, body, &context).wait();

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

Scopes

Parameters

Path parameters
Name Description
fileDefinitionId*
UUID (uuid)
Required
Body parameters
Name Description
body

Responses