Demo Facility

Environments

environmentsGet

Get all entities


/environments

Usage and SDK Samples

curl -X GET "http://localhost/api/environments"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.EnvironmentsApi;

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

public class EnvironmentsApiExample {

    public static void main(String[] args) {
        
        EnvironmentsApi apiInstance = new EnvironmentsApi();
        try {
            array[Environment] result = apiInstance.environmentsGet();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling EnvironmentsApi#environmentsGet");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.EnvironmentsApi;

public class EnvironmentsApiExample {

    public static void main(String[] args) {
        EnvironmentsApi apiInstance = new EnvironmentsApi();
        try {
            array[Environment] result = apiInstance.environmentsGet();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling EnvironmentsApi#environmentsGet");
            e.printStackTrace();
        }
    }
}

EnvironmentsApi *apiInstance = [[EnvironmentsApi alloc] init];

// Get all entities
[apiInstance environmentsGetWithCompletionHandler: 
              ^(array[Environment] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var DemoFacility = require('demo_facility');

var api = new DemoFacility.EnvironmentsApi()

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.environmentsGet(callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class environmentsGetExample
    {
        public void main()
        {
            
            var apiInstance = new EnvironmentsApi();

            try
            {
                // Get all entities
                array[Environment] result = apiInstance.environmentsGet();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling EnvironmentsApi.environmentsGet: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\EnvironmentsApi();

try {
    $result = $api_instance->environmentsGet();
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling EnvironmentsApi->environmentsGet: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::EnvironmentsApi;

my $api_instance = WWW::SwaggerClient::EnvironmentsApi->new();

eval { 
    my $result = $api_instance->environmentsGet();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling EnvironmentsApi->environmentsGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.EnvironmentsApi()

try: 
    # Get all entities
    api_response = api_instance.environments_get()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling EnvironmentsApi->environmentsGet: %s\n" % e)

Parameters

Responses

Status: 200 - Array of entities

Status: 500 - An errror occured.


environmentsIdDelete

Deletes an entity


/environments/{id}

Usage and SDK Samples

curl -X DELETE "http://localhost/api/environments/{id}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.EnvironmentsApi;

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

public class EnvironmentsApiExample {

    public static void main(String[] args) {
        
        EnvironmentsApi apiInstance = new EnvironmentsApi();
        String id = id_example; // String | ID of entity to fetch
        try {
            apiInstance.environmentsIdDelete(id);
        } catch (ApiException e) {
            System.err.println("Exception when calling EnvironmentsApi#environmentsIdDelete");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.EnvironmentsApi;

public class EnvironmentsApiExample {

    public static void main(String[] args) {
        EnvironmentsApi apiInstance = new EnvironmentsApi();
        String id = id_example; // String | ID of entity to fetch
        try {
            apiInstance.environmentsIdDelete(id);
        } catch (ApiException e) {
            System.err.println("Exception when calling EnvironmentsApi#environmentsIdDelete");
            e.printStackTrace();
        }
    }
}
String *id = id_example; // ID of entity to fetch

EnvironmentsApi *apiInstance = [[EnvironmentsApi alloc] init];

// Deletes an entity
[apiInstance environmentsIdDeleteWith:id
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var DemoFacility = require('demo_facility');

var api = new DemoFacility.EnvironmentsApi()

var id = id_example; // {String} ID of entity to fetch


var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.environmentsIdDelete(id, , callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class environmentsIdDeleteExample
    {
        public void main()
        {
            
            var apiInstance = new EnvironmentsApi();
            var id = id_example;  // String | ID of entity to fetch

            try
            {
                // Deletes an entity
                apiInstance.environmentsIdDelete(id);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling EnvironmentsApi.environmentsIdDelete: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\EnvironmentsApi();
$id = id_example; // String | ID of entity to fetch

try {
    $api_instance->environmentsIdDelete($id);
} catch (Exception $e) {
    echo 'Exception when calling EnvironmentsApi->environmentsIdDelete: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::EnvironmentsApi;

my $api_instance = WWW::SwaggerClient::EnvironmentsApi->new();
my $id = id_example; # String | ID of entity to fetch

eval { 
    $api_instance->environmentsIdDelete(id => $id);
};
if ($@) {
    warn "Exception when calling EnvironmentsApi->environmentsIdDelete: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.EnvironmentsApi()
id = id_example # String | ID of entity to fetch

try: 
    # Deletes an entity
    api_instance.environments_id_delete(id)
except ApiException as e:
    print("Exception when calling EnvironmentsApi->environmentsIdDelete: %s\n" % e)

Parameters

Path parameters
Name Description
id*
String
ID of entity to fetch
Required

Responses

Status: 200 - Entity deleted.

Status: 404 - Entity not found.


environmentsIdGet

Get entity by id


/environments/{id}

Usage and SDK Samples

curl -X GET "http://localhost/api/environments/{id}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.EnvironmentsApi;

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

public class EnvironmentsApiExample {

    public static void main(String[] args) {
        
        EnvironmentsApi apiInstance = new EnvironmentsApi();
        String id = id_example; // String | ID of entity to fetch
        try {
            Environment result = apiInstance.environmentsIdGet(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling EnvironmentsApi#environmentsIdGet");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.EnvironmentsApi;

public class EnvironmentsApiExample {

    public static void main(String[] args) {
        EnvironmentsApi apiInstance = new EnvironmentsApi();
        String id = id_example; // String | ID of entity to fetch
        try {
            Environment result = apiInstance.environmentsIdGet(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling EnvironmentsApi#environmentsIdGet");
            e.printStackTrace();
        }
    }
}
String *id = id_example; // ID of entity to fetch

EnvironmentsApi *apiInstance = [[EnvironmentsApi alloc] init];

// Get entity by id
[apiInstance environmentsIdGetWith:id
              completionHandler: ^(Environment output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var DemoFacility = require('demo_facility');

var api = new DemoFacility.EnvironmentsApi()

var id = id_example; // {String} ID of entity to fetch


var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.environmentsIdGet(id, , callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class environmentsIdGetExample
    {
        public void main()
        {
            
            var apiInstance = new EnvironmentsApi();
            var id = id_example;  // String | ID of entity to fetch

            try
            {
                // Get entity by id
                Environment result = apiInstance.environmentsIdGet(id);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling EnvironmentsApi.environmentsIdGet: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\EnvironmentsApi();
$id = id_example; // String | ID of entity to fetch

try {
    $result = $api_instance->environmentsIdGet($id);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling EnvironmentsApi->environmentsIdGet: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::EnvironmentsApi;

my $api_instance = WWW::SwaggerClient::EnvironmentsApi->new();
my $id = id_example; # String | ID of entity to fetch

eval { 
    my $result = $api_instance->environmentsIdGet(id => $id);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling EnvironmentsApi->environmentsIdGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.EnvironmentsApi()
id = id_example # String | ID of entity to fetch

try: 
    # Get entity by id
    api_response = api_instance.environments_id_get(id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling EnvironmentsApi->environmentsIdGet: %s\n" % e)

Parameters

Path parameters
Name Description
id*
String
ID of entity to fetch
Required

Responses

Status: 200 - Entitiy found.

Status: 404 - Entity not found.

Status: 500 - An error occured.


environmentsIdPatch

Update an existing entity


/environments/{id}

Usage and SDK Samples

curl -X PATCH "http://localhost/api/environments/{id}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.EnvironmentsApi;

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

public class EnvironmentsApiExample {

    public static void main(String[] args) {
        
        EnvironmentsApi apiInstance = new EnvironmentsApi();
        String id = id_example; // String | ID of entity to fetch
        Environment body = ; // Environment | Object that needs to be added
        try {
            Environment result = apiInstance.environmentsIdPatch(id, body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling EnvironmentsApi#environmentsIdPatch");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.EnvironmentsApi;

public class EnvironmentsApiExample {

    public static void main(String[] args) {
        EnvironmentsApi apiInstance = new EnvironmentsApi();
        String id = id_example; // String | ID of entity to fetch
        Environment body = ; // Environment | Object that needs to be added
        try {
            Environment result = apiInstance.environmentsIdPatch(id, body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling EnvironmentsApi#environmentsIdPatch");
            e.printStackTrace();
        }
    }
}
String *id = id_example; // ID of entity to fetch
Environment *body = ; // Object that needs to be added

EnvironmentsApi *apiInstance = [[EnvironmentsApi alloc] init];

// Update an existing entity
[apiInstance environmentsIdPatchWith:id
    body:body
              completionHandler: ^(Environment output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var DemoFacility = require('demo_facility');

var api = new DemoFacility.EnvironmentsApi()

var id = id_example; // {String} ID of entity to fetch

var body = ; // {Environment} Object that needs to be added


var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.environmentsIdPatch(id, body, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class environmentsIdPatchExample
    {
        public void main()
        {
            
            var apiInstance = new EnvironmentsApi();
            var id = id_example;  // String | ID of entity to fetch
            var body = new Environment(); // Environment | Object that needs to be added

            try
            {
                // Update an existing entity
                Environment result = apiInstance.environmentsIdPatch(id, body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling EnvironmentsApi.environmentsIdPatch: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\EnvironmentsApi();
$id = id_example; // String | ID of entity to fetch
$body = ; // Environment | Object that needs to be added

try {
    $result = $api_instance->environmentsIdPatch($id, $body);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling EnvironmentsApi->environmentsIdPatch: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::EnvironmentsApi;

my $api_instance = WWW::SwaggerClient::EnvironmentsApi->new();
my $id = id_example; # String | ID of entity to fetch
my $body = WWW::SwaggerClient::Object::Environment->new(); # Environment | Object that needs to be added

eval { 
    my $result = $api_instance->environmentsIdPatch(id => $id, body => $body);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling EnvironmentsApi->environmentsIdPatch: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.EnvironmentsApi()
id = id_example # String | ID of entity to fetch
body =  # Environment | Object that needs to be added

try: 
    # Update an existing entity
    api_response = api_instance.environments_id_patch(id, body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling EnvironmentsApi->environmentsIdPatch: %s\n" % e)

Parameters

Path parameters
Name Description
id*
String
ID of entity to fetch
Required
Body parameters
Name Description
body *

Responses

Status: 200 - Entitiy updated.

Status: 404 - Entity does not exist.


environmentsPost

Add a new entity


/environments

Usage and SDK Samples

curl -X POST "http://localhost/api/environments"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.EnvironmentsApi;

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

public class EnvironmentsApiExample {

    public static void main(String[] args) {
        
        EnvironmentsApi apiInstance = new EnvironmentsApi();
        Environment body = ; // Environment | Object that shall be stored
        try {
            Environment result = apiInstance.environmentsPost(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling EnvironmentsApi#environmentsPost");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.EnvironmentsApi;

public class EnvironmentsApiExample {

    public static void main(String[] args) {
        EnvironmentsApi apiInstance = new EnvironmentsApi();
        Environment body = ; // Environment | Object that shall be stored
        try {
            Environment result = apiInstance.environmentsPost(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling EnvironmentsApi#environmentsPost");
            e.printStackTrace();
        }
    }
}
Environment *body = ; // Object that shall be stored

EnvironmentsApi *apiInstance = [[EnvironmentsApi alloc] init];

// Add a new entity
[apiInstance environmentsPostWith:body
              completionHandler: ^(Environment output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var DemoFacility = require('demo_facility');

var api = new DemoFacility.EnvironmentsApi()

var body = ; // {Environment} Object that shall be stored


var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.environmentsPost(body, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class environmentsPostExample
    {
        public void main()
        {
            
            var apiInstance = new EnvironmentsApi();
            var body = new Environment(); // Environment | Object that shall be stored

            try
            {
                // Add a new entity
                Environment result = apiInstance.environmentsPost(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling EnvironmentsApi.environmentsPost: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\EnvironmentsApi();
$body = ; // Environment | Object that shall be stored

try {
    $result = $api_instance->environmentsPost($body);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling EnvironmentsApi->environmentsPost: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::EnvironmentsApi;

my $api_instance = WWW::SwaggerClient::EnvironmentsApi->new();
my $body = WWW::SwaggerClient::Object::Environment->new(); # Environment | Object that shall be stored

eval { 
    my $result = $api_instance->environmentsPost(body => $body);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling EnvironmentsApi->environmentsPost: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.EnvironmentsApi()
body =  # Environment | Object that shall be stored

try: 
    # Add a new entity
    api_response = api_instance.environments_post(body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling EnvironmentsApi->environmentsPost: %s\n" % e)

Parameters

Body parameters
Name Description
body *

Responses

Status: 201 - Entitiy stored.

Status: 500 - An errror occured.


Locations

locationsGet

Get all entities


/locations

Usage and SDK Samples

curl -X GET "http://localhost/api/locations"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.LocationsApi;

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

public class LocationsApiExample {

    public static void main(String[] args) {
        
        LocationsApi apiInstance = new LocationsApi();
        try {
            array[Location] result = apiInstance.locationsGet();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling LocationsApi#locationsGet");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.LocationsApi;

public class LocationsApiExample {

    public static void main(String[] args) {
        LocationsApi apiInstance = new LocationsApi();
        try {
            array[Location] result = apiInstance.locationsGet();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling LocationsApi#locationsGet");
            e.printStackTrace();
        }
    }
}

LocationsApi *apiInstance = [[LocationsApi alloc] init];

// Get all entities
[apiInstance locationsGetWithCompletionHandler: 
              ^(array[Location] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var DemoFacility = require('demo_facility');

var api = new DemoFacility.LocationsApi()

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.locationsGet(callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class locationsGetExample
    {
        public void main()
        {
            
            var apiInstance = new LocationsApi();

            try
            {
                // Get all entities
                array[Location] result = apiInstance.locationsGet();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling LocationsApi.locationsGet: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\LocationsApi();

try {
    $result = $api_instance->locationsGet();
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling LocationsApi->locationsGet: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::LocationsApi;

my $api_instance = WWW::SwaggerClient::LocationsApi->new();

eval { 
    my $result = $api_instance->locationsGet();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling LocationsApi->locationsGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.LocationsApi()

try: 
    # Get all entities
    api_response = api_instance.locations_get()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling LocationsApi->locationsGet: %s\n" % e)

Parameters

Responses

Status: 200 - Array of entities

Status: 500 - An errror occured.


locationsIdDelete

Deletes an entity


/locations/{id}

Usage and SDK Samples

curl -X DELETE "http://localhost/api/locations/{id}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.LocationsApi;

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

public class LocationsApiExample {

    public static void main(String[] args) {
        
        LocationsApi apiInstance = new LocationsApi();
        String id = id_example; // String | ID of entity to fetch
        try {
            apiInstance.locationsIdDelete(id);
        } catch (ApiException e) {
            System.err.println("Exception when calling LocationsApi#locationsIdDelete");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.LocationsApi;

public class LocationsApiExample {

    public static void main(String[] args) {
        LocationsApi apiInstance = new LocationsApi();
        String id = id_example; // String | ID of entity to fetch
        try {
            apiInstance.locationsIdDelete(id);
        } catch (ApiException e) {
            System.err.println("Exception when calling LocationsApi#locationsIdDelete");
            e.printStackTrace();
        }
    }
}
String *id = id_example; // ID of entity to fetch

LocationsApi *apiInstance = [[LocationsApi alloc] init];

// Deletes an entity
[apiInstance locationsIdDeleteWith:id
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var DemoFacility = require('demo_facility');

var api = new DemoFacility.LocationsApi()

var id = id_example; // {String} ID of entity to fetch


var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.locationsIdDelete(id, , callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class locationsIdDeleteExample
    {
        public void main()
        {
            
            var apiInstance = new LocationsApi();
            var id = id_example;  // String | ID of entity to fetch

            try
            {
                // Deletes an entity
                apiInstance.locationsIdDelete(id);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling LocationsApi.locationsIdDelete: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\LocationsApi();
$id = id_example; // String | ID of entity to fetch

try {
    $api_instance->locationsIdDelete($id);
} catch (Exception $e) {
    echo 'Exception when calling LocationsApi->locationsIdDelete: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::LocationsApi;

my $api_instance = WWW::SwaggerClient::LocationsApi->new();
my $id = id_example; # String | ID of entity to fetch

eval { 
    $api_instance->locationsIdDelete(id => $id);
};
if ($@) {
    warn "Exception when calling LocationsApi->locationsIdDelete: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.LocationsApi()
id = id_example # String | ID of entity to fetch

try: 
    # Deletes an entity
    api_instance.locations_id_delete(id)
except ApiException as e:
    print("Exception when calling LocationsApi->locationsIdDelete: %s\n" % e)

Parameters

Path parameters
Name Description
id*
String
ID of entity to fetch
Required

Responses

Status: 200 - Entity deleted.

Status: 404 - Entity not found.


locationsIdGet

Get entity by id


/locations/{id}

Usage and SDK Samples

curl -X GET "http://localhost/api/locations/{id}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.LocationsApi;

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

public class LocationsApiExample {

    public static void main(String[] args) {
        
        LocationsApi apiInstance = new LocationsApi();
        String id = id_example; // String | ID of entity to fetch
        try {
            Location result = apiInstance.locationsIdGet(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling LocationsApi#locationsIdGet");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.LocationsApi;

public class LocationsApiExample {

    public static void main(String[] args) {
        LocationsApi apiInstance = new LocationsApi();
        String id = id_example; // String | ID of entity to fetch
        try {
            Location result = apiInstance.locationsIdGet(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling LocationsApi#locationsIdGet");
            e.printStackTrace();
        }
    }
}
String *id = id_example; // ID of entity to fetch

LocationsApi *apiInstance = [[LocationsApi alloc] init];

// Get entity by id
[apiInstance locationsIdGetWith:id
              completionHandler: ^(Location output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var DemoFacility = require('demo_facility');

var api = new DemoFacility.LocationsApi()

var id = id_example; // {String} ID of entity to fetch


var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.locationsIdGet(id, , callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class locationsIdGetExample
    {
        public void main()
        {
            
            var apiInstance = new LocationsApi();
            var id = id_example;  // String | ID of entity to fetch

            try
            {
                // Get entity by id
                Location result = apiInstance.locationsIdGet(id);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling LocationsApi.locationsIdGet: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\LocationsApi();
$id = id_example; // String | ID of entity to fetch

try {
    $result = $api_instance->locationsIdGet($id);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling LocationsApi->locationsIdGet: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::LocationsApi;

my $api_instance = WWW::SwaggerClient::LocationsApi->new();
my $id = id_example; # String | ID of entity to fetch

eval { 
    my $result = $api_instance->locationsIdGet(id => $id);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling LocationsApi->locationsIdGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.LocationsApi()
id = id_example # String | ID of entity to fetch

try: 
    # Get entity by id
    api_response = api_instance.locations_id_get(id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling LocationsApi->locationsIdGet: %s\n" % e)

Parameters

Path parameters
Name Description
id*
String
ID of entity to fetch
Required

Responses

Status: 200 - Entitiy found.

Status: 404 - Entity not found.

Status: 500 - An error occured.


locationsIdPatch

Update an existing entity


/locations/{id}

Usage and SDK Samples

curl -X PATCH "http://localhost/api/locations/{id}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.LocationsApi;

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

public class LocationsApiExample {

    public static void main(String[] args) {
        
        LocationsApi apiInstance = new LocationsApi();
        String id = id_example; // String | ID of entity to fetch
        Location body = ; // Location | Object that needs to be added
        try {
            Location result = apiInstance.locationsIdPatch(id, body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling LocationsApi#locationsIdPatch");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.LocationsApi;

public class LocationsApiExample {

    public static void main(String[] args) {
        LocationsApi apiInstance = new LocationsApi();
        String id = id_example; // String | ID of entity to fetch
        Location body = ; // Location | Object that needs to be added
        try {
            Location result = apiInstance.locationsIdPatch(id, body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling LocationsApi#locationsIdPatch");
            e.printStackTrace();
        }
    }
}
String *id = id_example; // ID of entity to fetch
Location *body = ; // Object that needs to be added

LocationsApi *apiInstance = [[LocationsApi alloc] init];

// Update an existing entity
[apiInstance locationsIdPatchWith:id
    body:body
              completionHandler: ^(Location output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var DemoFacility = require('demo_facility');

var api = new DemoFacility.LocationsApi()

var id = id_example; // {String} ID of entity to fetch

var body = ; // {Location} Object that needs to be added


var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.locationsIdPatch(id, body, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class locationsIdPatchExample
    {
        public void main()
        {
            
            var apiInstance = new LocationsApi();
            var id = id_example;  // String | ID of entity to fetch
            var body = new Location(); // Location | Object that needs to be added

            try
            {
                // Update an existing entity
                Location result = apiInstance.locationsIdPatch(id, body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling LocationsApi.locationsIdPatch: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\LocationsApi();
$id = id_example; // String | ID of entity to fetch
$body = ; // Location | Object that needs to be added

try {
    $result = $api_instance->locationsIdPatch($id, $body);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling LocationsApi->locationsIdPatch: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::LocationsApi;

my $api_instance = WWW::SwaggerClient::LocationsApi->new();
my $id = id_example; # String | ID of entity to fetch
my $body = WWW::SwaggerClient::Object::Location->new(); # Location | Object that needs to be added

eval { 
    my $result = $api_instance->locationsIdPatch(id => $id, body => $body);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling LocationsApi->locationsIdPatch: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.LocationsApi()
id = id_example # String | ID of entity to fetch
body =  # Location | Object that needs to be added

try: 
    # Update an existing entity
    api_response = api_instance.locations_id_patch(id, body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling LocationsApi->locationsIdPatch: %s\n" % e)

Parameters

Path parameters
Name Description
id*
String
ID of entity to fetch
Required
Body parameters
Name Description
body *

Responses

Status: 200 - Entitiy updated.

Status: 404 - Entity does not exist.


locationsPost

Add a new entity


/locations

Usage and SDK Samples

curl -X POST "http://localhost/api/locations"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.LocationsApi;

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

public class LocationsApiExample {

    public static void main(String[] args) {
        
        LocationsApi apiInstance = new LocationsApi();
        Location body = ; // Location | Object that shall be stored
        try {
            Location result = apiInstance.locationsPost(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling LocationsApi#locationsPost");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.LocationsApi;

public class LocationsApiExample {

    public static void main(String[] args) {
        LocationsApi apiInstance = new LocationsApi();
        Location body = ; // Location | Object that shall be stored
        try {
            Location result = apiInstance.locationsPost(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling LocationsApi#locationsPost");
            e.printStackTrace();
        }
    }
}
Location *body = ; // Object that shall be stored

LocationsApi *apiInstance = [[LocationsApi alloc] init];

// Add a new entity
[apiInstance locationsPostWith:body
              completionHandler: ^(Location output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var DemoFacility = require('demo_facility');

var api = new DemoFacility.LocationsApi()

var body = ; // {Location} Object that shall be stored


var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.locationsPost(body, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class locationsPostExample
    {
        public void main()
        {
            
            var apiInstance = new LocationsApi();
            var body = new Location(); // Location | Object that shall be stored

            try
            {
                // Add a new entity
                Location result = apiInstance.locationsPost(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling LocationsApi.locationsPost: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\LocationsApi();
$body = ; // Location | Object that shall be stored

try {
    $result = $api_instance->locationsPost($body);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling LocationsApi->locationsPost: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::LocationsApi;

my $api_instance = WWW::SwaggerClient::LocationsApi->new();
my $body = WWW::SwaggerClient::Object::Location->new(); # Location | Object that shall be stored

eval { 
    my $result = $api_instance->locationsPost(body => $body);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling LocationsApi->locationsPost: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.LocationsApi()
body =  # Location | Object that shall be stored

try: 
    # Add a new entity
    api_response = api_instance.locations_post(body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling LocationsApi->locationsPost: %s\n" % e)

Parameters

Body parameters
Name Description
body *

Responses

Status: 201 - Entitiy stored.

Status: 500 - An errror occured.


OrderPositions

orderPositionsGet

Get all entities


/orderPositions

Usage and SDK Samples

curl -X GET "http://localhost/api/orderPositions"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.OrderPositionsApi;

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

public class OrderPositionsApiExample {

    public static void main(String[] args) {
        
        OrderPositionsApi apiInstance = new OrderPositionsApi();
        try {
            array[OrderPosition] result = apiInstance.orderPositionsGet();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling OrderPositionsApi#orderPositionsGet");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.OrderPositionsApi;

public class OrderPositionsApiExample {

    public static void main(String[] args) {
        OrderPositionsApi apiInstance = new OrderPositionsApi();
        try {
            array[OrderPosition] result = apiInstance.orderPositionsGet();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling OrderPositionsApi#orderPositionsGet");
            e.printStackTrace();
        }
    }
}

OrderPositionsApi *apiInstance = [[OrderPositionsApi alloc] init];

// Get all entities
[apiInstance orderPositionsGetWithCompletionHandler: 
              ^(array[OrderPosition] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var DemoFacility = require('demo_facility');

var api = new DemoFacility.OrderPositionsApi()

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.orderPositionsGet(callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class orderPositionsGetExample
    {
        public void main()
        {
            
            var apiInstance = new OrderPositionsApi();

            try
            {
                // Get all entities
                array[OrderPosition] result = apiInstance.orderPositionsGet();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling OrderPositionsApi.orderPositionsGet: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\OrderPositionsApi();

try {
    $result = $api_instance->orderPositionsGet();
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling OrderPositionsApi->orderPositionsGet: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::OrderPositionsApi;

my $api_instance = WWW::SwaggerClient::OrderPositionsApi->new();

eval { 
    my $result = $api_instance->orderPositionsGet();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling OrderPositionsApi->orderPositionsGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.OrderPositionsApi()

try: 
    # Get all entities
    api_response = api_instance.order_positions_get()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling OrderPositionsApi->orderPositionsGet: %s\n" % e)

Parameters

Responses

Status: 200 - Array of entities

Status: 500 - An errror occured.


orderPositionsIdDelete

Deletes an entity


/orderPositions/{id}

Usage and SDK Samples

curl -X DELETE "http://localhost/api/orderPositions/{id}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.OrderPositionsApi;

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

public class OrderPositionsApiExample {

    public static void main(String[] args) {
        
        OrderPositionsApi apiInstance = new OrderPositionsApi();
        String id = id_example; // String | ID of entity to fetch
        try {
            apiInstance.orderPositionsIdDelete(id);
        } catch (ApiException e) {
            System.err.println("Exception when calling OrderPositionsApi#orderPositionsIdDelete");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.OrderPositionsApi;

public class OrderPositionsApiExample {

    public static void main(String[] args) {
        OrderPositionsApi apiInstance = new OrderPositionsApi();
        String id = id_example; // String | ID of entity to fetch
        try {
            apiInstance.orderPositionsIdDelete(id);
        } catch (ApiException e) {
            System.err.println("Exception when calling OrderPositionsApi#orderPositionsIdDelete");
            e.printStackTrace();
        }
    }
}
String *id = id_example; // ID of entity to fetch

OrderPositionsApi *apiInstance = [[OrderPositionsApi alloc] init];

// Deletes an entity
[apiInstance orderPositionsIdDeleteWith:id
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var DemoFacility = require('demo_facility');

var api = new DemoFacility.OrderPositionsApi()

var id = id_example; // {String} ID of entity to fetch


var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.orderPositionsIdDelete(id, , callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class orderPositionsIdDeleteExample
    {
        public void main()
        {
            
            var apiInstance = new OrderPositionsApi();
            var id = id_example;  // String | ID of entity to fetch

            try
            {
                // Deletes an entity
                apiInstance.orderPositionsIdDelete(id);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling OrderPositionsApi.orderPositionsIdDelete: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\OrderPositionsApi();
$id = id_example; // String | ID of entity to fetch

try {
    $api_instance->orderPositionsIdDelete($id);
} catch (Exception $e) {
    echo 'Exception when calling OrderPositionsApi->orderPositionsIdDelete: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::OrderPositionsApi;

my $api_instance = WWW::SwaggerClient::OrderPositionsApi->new();
my $id = id_example; # String | ID of entity to fetch

eval { 
    $api_instance->orderPositionsIdDelete(id => $id);
};
if ($@) {
    warn "Exception when calling OrderPositionsApi->orderPositionsIdDelete: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.OrderPositionsApi()
id = id_example # String | ID of entity to fetch

try: 
    # Deletes an entity
    api_instance.order_positions_id_delete(id)
except ApiException as e:
    print("Exception when calling OrderPositionsApi->orderPositionsIdDelete: %s\n" % e)

Parameters

Path parameters
Name Description
id*
String
ID of entity to fetch
Required

Responses

Status: 200 - Entity deleted.

Status: 404 - Entity not found.


orderPositionsIdGet

Get entity by id


/orderPositions/{id}

Usage and SDK Samples

curl -X GET "http://localhost/api/orderPositions/{id}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.OrderPositionsApi;

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

public class OrderPositionsApiExample {

    public static void main(String[] args) {
        
        OrderPositionsApi apiInstance = new OrderPositionsApi();
        String id = id_example; // String | ID of entity to fetch
        try {
            OrderPosition result = apiInstance.orderPositionsIdGet(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling OrderPositionsApi#orderPositionsIdGet");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.OrderPositionsApi;

public class OrderPositionsApiExample {

    public static void main(String[] args) {
        OrderPositionsApi apiInstance = new OrderPositionsApi();
        String id = id_example; // String | ID of entity to fetch
        try {
            OrderPosition result = apiInstance.orderPositionsIdGet(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling OrderPositionsApi#orderPositionsIdGet");
            e.printStackTrace();
        }
    }
}
String *id = id_example; // ID of entity to fetch

OrderPositionsApi *apiInstance = [[OrderPositionsApi alloc] init];

// Get entity by id
[apiInstance orderPositionsIdGetWith:id
              completionHandler: ^(OrderPosition output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var DemoFacility = require('demo_facility');

var api = new DemoFacility.OrderPositionsApi()

var id = id_example; // {String} ID of entity to fetch


var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.orderPositionsIdGet(id, , callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class orderPositionsIdGetExample
    {
        public void main()
        {
            
            var apiInstance = new OrderPositionsApi();
            var id = id_example;  // String | ID of entity to fetch

            try
            {
                // Get entity by id
                OrderPosition result = apiInstance.orderPositionsIdGet(id);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling OrderPositionsApi.orderPositionsIdGet: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\OrderPositionsApi();
$id = id_example; // String | ID of entity to fetch

try {
    $result = $api_instance->orderPositionsIdGet($id);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling OrderPositionsApi->orderPositionsIdGet: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::OrderPositionsApi;

my $api_instance = WWW::SwaggerClient::OrderPositionsApi->new();
my $id = id_example; # String | ID of entity to fetch

eval { 
    my $result = $api_instance->orderPositionsIdGet(id => $id);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling OrderPositionsApi->orderPositionsIdGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.OrderPositionsApi()
id = id_example # String | ID of entity to fetch

try: 
    # Get entity by id
    api_response = api_instance.order_positions_id_get(id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling OrderPositionsApi->orderPositionsIdGet: %s\n" % e)

Parameters

Path parameters
Name Description
id*
String
ID of entity to fetch
Required

Responses

Status: 200 - Entitiy found.

Status: 404 - Entity not found.

Status: 500 - An error occured.


orderPositionsIdPatch

Update an existing entity


/orderPositions/{id}

Usage and SDK Samples

curl -X PATCH "http://localhost/api/orderPositions/{id}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.OrderPositionsApi;

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

public class OrderPositionsApiExample {

    public static void main(String[] args) {
        
        OrderPositionsApi apiInstance = new OrderPositionsApi();
        String id = id_example; // String | ID of entity to fetch
        OrderPosition body = ; // OrderPosition | Object that needs to be added
        try {
            OrderPosition result = apiInstance.orderPositionsIdPatch(id, body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling OrderPositionsApi#orderPositionsIdPatch");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.OrderPositionsApi;

public class OrderPositionsApiExample {

    public static void main(String[] args) {
        OrderPositionsApi apiInstance = new OrderPositionsApi();
        String id = id_example; // String | ID of entity to fetch
        OrderPosition body = ; // OrderPosition | Object that needs to be added
        try {
            OrderPosition result = apiInstance.orderPositionsIdPatch(id, body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling OrderPositionsApi#orderPositionsIdPatch");
            e.printStackTrace();
        }
    }
}
String *id = id_example; // ID of entity to fetch
OrderPosition *body = ; // Object that needs to be added

OrderPositionsApi *apiInstance = [[OrderPositionsApi alloc] init];

// Update an existing entity
[apiInstance orderPositionsIdPatchWith:id
    body:body
              completionHandler: ^(OrderPosition output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var DemoFacility = require('demo_facility');

var api = new DemoFacility.OrderPositionsApi()

var id = id_example; // {String} ID of entity to fetch

var body = ; // {OrderPosition} Object that needs to be added


var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.orderPositionsIdPatch(id, body, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class orderPositionsIdPatchExample
    {
        public void main()
        {
            
            var apiInstance = new OrderPositionsApi();
            var id = id_example;  // String | ID of entity to fetch
            var body = new OrderPosition(); // OrderPosition | Object that needs to be added

            try
            {
                // Update an existing entity
                OrderPosition result = apiInstance.orderPositionsIdPatch(id, body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling OrderPositionsApi.orderPositionsIdPatch: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\OrderPositionsApi();
$id = id_example; // String | ID of entity to fetch
$body = ; // OrderPosition | Object that needs to be added

try {
    $result = $api_instance->orderPositionsIdPatch($id, $body);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling OrderPositionsApi->orderPositionsIdPatch: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::OrderPositionsApi;

my $api_instance = WWW::SwaggerClient::OrderPositionsApi->new();
my $id = id_example; # String | ID of entity to fetch
my $body = WWW::SwaggerClient::Object::OrderPosition->new(); # OrderPosition | Object that needs to be added

eval { 
    my $result = $api_instance->orderPositionsIdPatch(id => $id, body => $body);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling OrderPositionsApi->orderPositionsIdPatch: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.OrderPositionsApi()
id = id_example # String | ID of entity to fetch
body =  # OrderPosition | Object that needs to be added

try: 
    # Update an existing entity
    api_response = api_instance.order_positions_id_patch(id, body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling OrderPositionsApi->orderPositionsIdPatch: %s\n" % e)

Parameters

Path parameters
Name Description
id*
String
ID of entity to fetch
Required
Body parameters
Name Description
body *

Responses

Status: 200 - Entitiy updated.

Status: 404 - Entity does not exist.


orderPositionsPost

Add a new entity


/orderPositions

Usage and SDK Samples

curl -X POST "http://localhost/api/orderPositions"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.OrderPositionsApi;

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

public class OrderPositionsApiExample {

    public static void main(String[] args) {
        
        OrderPositionsApi apiInstance = new OrderPositionsApi();
        OrderPosition body = ; // OrderPosition | Object that shall be stored
        try {
            OrderPosition result = apiInstance.orderPositionsPost(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling OrderPositionsApi#orderPositionsPost");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.OrderPositionsApi;

public class OrderPositionsApiExample {

    public static void main(String[] args) {
        OrderPositionsApi apiInstance = new OrderPositionsApi();
        OrderPosition body = ; // OrderPosition | Object that shall be stored
        try {
            OrderPosition result = apiInstance.orderPositionsPost(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling OrderPositionsApi#orderPositionsPost");
            e.printStackTrace();
        }
    }
}
OrderPosition *body = ; // Object that shall be stored

OrderPositionsApi *apiInstance = [[OrderPositionsApi alloc] init];

// Add a new entity
[apiInstance orderPositionsPostWith:body
              completionHandler: ^(OrderPosition output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var DemoFacility = require('demo_facility');

var api = new DemoFacility.OrderPositionsApi()

var body = ; // {OrderPosition} Object that shall be stored


var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.orderPositionsPost(body, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class orderPositionsPostExample
    {
        public void main()
        {
            
            var apiInstance = new OrderPositionsApi();
            var body = new OrderPosition(); // OrderPosition | Object that shall be stored

            try
            {
                // Add a new entity
                OrderPosition result = apiInstance.orderPositionsPost(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling OrderPositionsApi.orderPositionsPost: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\OrderPositionsApi();
$body = ; // OrderPosition | Object that shall be stored

try {
    $result = $api_instance->orderPositionsPost($body);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling OrderPositionsApi->orderPositionsPost: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::OrderPositionsApi;

my $api_instance = WWW::SwaggerClient::OrderPositionsApi->new();
my $body = WWW::SwaggerClient::Object::OrderPosition->new(); # OrderPosition | Object that shall be stored

eval { 
    my $result = $api_instance->orderPositionsPost(body => $body);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling OrderPositionsApi->orderPositionsPost: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.OrderPositionsApi()
body =  # OrderPosition | Object that shall be stored

try: 
    # Add a new entity
    api_response = api_instance.order_positions_post(body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling OrderPositionsApi->orderPositionsPost: %s\n" % e)

Parameters

Body parameters
Name Description
body *

Responses

Status: 201 - Entitiy stored.

Status: 500 - An errror occured.


Orders

ordersGet

Get all entities


/orders

Usage and SDK Samples

curl -X GET "http://localhost/api/orders"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.OrdersApi;

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

public class OrdersApiExample {

    public static void main(String[] args) {
        
        OrdersApi apiInstance = new OrdersApi();
        try {
            array[Order] result = apiInstance.ordersGet();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling OrdersApi#ordersGet");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.OrdersApi;

public class OrdersApiExample {

    public static void main(String[] args) {
        OrdersApi apiInstance = new OrdersApi();
        try {
            array[Order] result = apiInstance.ordersGet();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling OrdersApi#ordersGet");
            e.printStackTrace();
        }
    }
}

OrdersApi *apiInstance = [[OrdersApi alloc] init];

// Get all entities
[apiInstance ordersGetWithCompletionHandler: 
              ^(array[Order] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var DemoFacility = require('demo_facility');

var api = new DemoFacility.OrdersApi()

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.ordersGet(callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class ordersGetExample
    {
        public void main()
        {
            
            var apiInstance = new OrdersApi();

            try
            {
                // Get all entities
                array[Order] result = apiInstance.ordersGet();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling OrdersApi.ordersGet: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\OrdersApi();

try {
    $result = $api_instance->ordersGet();
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling OrdersApi->ordersGet: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::OrdersApi;

my $api_instance = WWW::SwaggerClient::OrdersApi->new();

eval { 
    my $result = $api_instance->ordersGet();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling OrdersApi->ordersGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.OrdersApi()

try: 
    # Get all entities
    api_response = api_instance.orders_get()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling OrdersApi->ordersGet: %s\n" % e)

Parameters

Responses

Status: 200 - Array of entities

Status: 500 - An errror occured.


ordersIdDelete

Deletes an entity


/orders/{id}

Usage and SDK Samples

curl -X DELETE "http://localhost/api/orders/{id}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.OrdersApi;

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

public class OrdersApiExample {

    public static void main(String[] args) {
        
        OrdersApi apiInstance = new OrdersApi();
        String id = id_example; // String | ID of entity to fetch
        try {
            apiInstance.ordersIdDelete(id);
        } catch (ApiException e) {
            System.err.println("Exception when calling OrdersApi#ordersIdDelete");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.OrdersApi;

public class OrdersApiExample {

    public static void main(String[] args) {
        OrdersApi apiInstance = new OrdersApi();
        String id = id_example; // String | ID of entity to fetch
        try {
            apiInstance.ordersIdDelete(id);
        } catch (ApiException e) {
            System.err.println("Exception when calling OrdersApi#ordersIdDelete");
            e.printStackTrace();
        }
    }
}
String *id = id_example; // ID of entity to fetch

OrdersApi *apiInstance = [[OrdersApi alloc] init];

// Deletes an entity
[apiInstance ordersIdDeleteWith:id
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var DemoFacility = require('demo_facility');

var api = new DemoFacility.OrdersApi()

var id = id_example; // {String} ID of entity to fetch


var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.ordersIdDelete(id, , callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class ordersIdDeleteExample
    {
        public void main()
        {
            
            var apiInstance = new OrdersApi();
            var id = id_example;  // String | ID of entity to fetch

            try
            {
                // Deletes an entity
                apiInstance.ordersIdDelete(id);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling OrdersApi.ordersIdDelete: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\OrdersApi();
$id = id_example; // String | ID of entity to fetch

try {
    $api_instance->ordersIdDelete($id);
} catch (Exception $e) {
    echo 'Exception when calling OrdersApi->ordersIdDelete: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::OrdersApi;

my $api_instance = WWW::SwaggerClient::OrdersApi->new();
my $id = id_example; # String | ID of entity to fetch

eval { 
    $api_instance->ordersIdDelete(id => $id);
};
if ($@) {
    warn "Exception when calling OrdersApi->ordersIdDelete: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.OrdersApi()
id = id_example # String | ID of entity to fetch

try: 
    # Deletes an entity
    api_instance.orders_id_delete(id)
except ApiException as e:
    print("Exception when calling OrdersApi->ordersIdDelete: %s\n" % e)

Parameters

Path parameters
Name Description
id*
String
ID of entity to fetch
Required

Responses

Status: 200 - Entity deleted.

Status: 404 - Entity not found.


ordersIdGet

Get entity by id


/orders/{id}

Usage and SDK Samples

curl -X GET "http://localhost/api/orders/{id}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.OrdersApi;

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

public class OrdersApiExample {

    public static void main(String[] args) {
        
        OrdersApi apiInstance = new OrdersApi();
        String id = id_example; // String | ID of entity to fetch
        try {
            Order result = apiInstance.ordersIdGet(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling OrdersApi#ordersIdGet");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.OrdersApi;

public class OrdersApiExample {

    public static void main(String[] args) {
        OrdersApi apiInstance = new OrdersApi();
        String id = id_example; // String | ID of entity to fetch
        try {
            Order result = apiInstance.ordersIdGet(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling OrdersApi#ordersIdGet");
            e.printStackTrace();
        }
    }
}
String *id = id_example; // ID of entity to fetch

OrdersApi *apiInstance = [[OrdersApi alloc] init];

// Get entity by id
[apiInstance ordersIdGetWith:id
              completionHandler: ^(Order output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var DemoFacility = require('demo_facility');

var api = new DemoFacility.OrdersApi()

var id = id_example; // {String} ID of entity to fetch


var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.ordersIdGet(id, , callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class ordersIdGetExample
    {
        public void main()
        {
            
            var apiInstance = new OrdersApi();
            var id = id_example;  // String | ID of entity to fetch

            try
            {
                // Get entity by id
                Order result = apiInstance.ordersIdGet(id);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling OrdersApi.ordersIdGet: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\OrdersApi();
$id = id_example; // String | ID of entity to fetch

try {
    $result = $api_instance->ordersIdGet($id);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling OrdersApi->ordersIdGet: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::OrdersApi;

my $api_instance = WWW::SwaggerClient::OrdersApi->new();
my $id = id_example; # String | ID of entity to fetch

eval { 
    my $result = $api_instance->ordersIdGet(id => $id);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling OrdersApi->ordersIdGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.OrdersApi()
id = id_example # String | ID of entity to fetch

try: 
    # Get entity by id
    api_response = api_instance.orders_id_get(id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling OrdersApi->ordersIdGet: %s\n" % e)

Parameters

Path parameters
Name Description
id*
String
ID of entity to fetch
Required

Responses

Status: 200 - Entitiy found.

Status: 404 - Entity not found.

Status: 500 - An error occured.


ordersIdPatch

Update an existing entity


/orders/{id}

Usage and SDK Samples

curl -X PATCH "http://localhost/api/orders/{id}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.OrdersApi;

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

public class OrdersApiExample {

    public static void main(String[] args) {
        
        OrdersApi apiInstance = new OrdersApi();
        String id = id_example; // String | ID of entity to fetch
        Order body = ; // Order | Object that needs to be added
        try {
            Order result = apiInstance.ordersIdPatch(id, body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling OrdersApi#ordersIdPatch");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.OrdersApi;

public class OrdersApiExample {

    public static void main(String[] args) {
        OrdersApi apiInstance = new OrdersApi();
        String id = id_example; // String | ID of entity to fetch
        Order body = ; // Order | Object that needs to be added
        try {
            Order result = apiInstance.ordersIdPatch(id, body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling OrdersApi#ordersIdPatch");
            e.printStackTrace();
        }
    }
}
String *id = id_example; // ID of entity to fetch
Order *body = ; // Object that needs to be added

OrdersApi *apiInstance = [[OrdersApi alloc] init];

// Update an existing entity
[apiInstance ordersIdPatchWith:id
    body:body
              completionHandler: ^(Order output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var DemoFacility = require('demo_facility');

var api = new DemoFacility.OrdersApi()

var id = id_example; // {String} ID of entity to fetch

var body = ; // {Order} Object that needs to be added


var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.ordersIdPatch(id, body, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class ordersIdPatchExample
    {
        public void main()
        {
            
            var apiInstance = new OrdersApi();
            var id = id_example;  // String | ID of entity to fetch
            var body = new Order(); // Order | Object that needs to be added

            try
            {
                // Update an existing entity
                Order result = apiInstance.ordersIdPatch(id, body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling OrdersApi.ordersIdPatch: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\OrdersApi();
$id = id_example; // String | ID of entity to fetch
$body = ; // Order | Object that needs to be added

try {
    $result = $api_instance->ordersIdPatch($id, $body);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling OrdersApi->ordersIdPatch: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::OrdersApi;

my $api_instance = WWW::SwaggerClient::OrdersApi->new();
my $id = id_example; # String | ID of entity to fetch
my $body = WWW::SwaggerClient::Object::Order->new(); # Order | Object that needs to be added

eval { 
    my $result = $api_instance->ordersIdPatch(id => $id, body => $body);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling OrdersApi->ordersIdPatch: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.OrdersApi()
id = id_example # String | ID of entity to fetch
body =  # Order | Object that needs to be added

try: 
    # Update an existing entity
    api_response = api_instance.orders_id_patch(id, body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling OrdersApi->ordersIdPatch: %s\n" % e)

Parameters

Path parameters
Name Description
id*
String
ID of entity to fetch
Required
Body parameters
Name Description
body *

Responses

Status: 200 - Entitiy updated.

Status: 404 - Entity does not exist.


ordersPost

Add a new entity


/orders

Usage and SDK Samples

curl -X POST "http://localhost/api/orders"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.OrdersApi;

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

public class OrdersApiExample {

    public static void main(String[] args) {
        
        OrdersApi apiInstance = new OrdersApi();
        Order body = ; // Order | Object that shall be stored
        try {
            Order result = apiInstance.ordersPost(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling OrdersApi#ordersPost");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.OrdersApi;

public class OrdersApiExample {

    public static void main(String[] args) {
        OrdersApi apiInstance = new OrdersApi();
        Order body = ; // Order | Object that shall be stored
        try {
            Order result = apiInstance.ordersPost(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling OrdersApi#ordersPost");
            e.printStackTrace();
        }
    }
}
Order *body = ; // Object that shall be stored

OrdersApi *apiInstance = [[OrdersApi alloc] init];

// Add a new entity
[apiInstance ordersPostWith:body
              completionHandler: ^(Order output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var DemoFacility = require('demo_facility');

var api = new DemoFacility.OrdersApi()

var body = ; // {Order} Object that shall be stored


var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.ordersPost(body, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class ordersPostExample
    {
        public void main()
        {
            
            var apiInstance = new OrdersApi();
            var body = new Order(); // Order | Object that shall be stored

            try
            {
                // Add a new entity
                Order result = apiInstance.ordersPost(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling OrdersApi.ordersPost: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\OrdersApi();
$body = ; // Order | Object that shall be stored

try {
    $result = $api_instance->ordersPost($body);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling OrdersApi->ordersPost: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::OrdersApi;

my $api_instance = WWW::SwaggerClient::OrdersApi->new();
my $body = WWW::SwaggerClient::Object::Order->new(); # Order | Object that shall be stored

eval { 
    my $result = $api_instance->ordersPost(body => $body);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling OrdersApi->ordersPost: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.OrdersApi()
body =  # Order | Object that shall be stored

try: 
    # Add a new entity
    api_response = api_instance.orders_post(body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling OrdersApi->ordersPost: %s\n" % e)

Parameters

Body parameters
Name Description
body *

Responses

Status: 201 - Entitiy stored.

Status: 500 - An errror occured.


ProcessActivities

processActivitiesGet

Get all entities


/processActivities

Usage and SDK Samples

curl -X GET "http://localhost/api/processActivities"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ProcessActivitiesApi;

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

public class ProcessActivitiesApiExample {

    public static void main(String[] args) {
        
        ProcessActivitiesApi apiInstance = new ProcessActivitiesApi();
        try {
            array[ProcessActivity] result = apiInstance.processActivitiesGet();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProcessActivitiesApi#processActivitiesGet");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.ProcessActivitiesApi;

public class ProcessActivitiesApiExample {

    public static void main(String[] args) {
        ProcessActivitiesApi apiInstance = new ProcessActivitiesApi();
        try {
            array[ProcessActivity] result = apiInstance.processActivitiesGet();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProcessActivitiesApi#processActivitiesGet");
            e.printStackTrace();
        }
    }
}

ProcessActivitiesApi *apiInstance = [[ProcessActivitiesApi alloc] init];

// Get all entities
[apiInstance processActivitiesGetWithCompletionHandler: 
              ^(array[ProcessActivity] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var DemoFacility = require('demo_facility');

var api = new DemoFacility.ProcessActivitiesApi()

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.processActivitiesGet(callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class processActivitiesGetExample
    {
        public void main()
        {
            
            var apiInstance = new ProcessActivitiesApi();

            try
            {
                // Get all entities
                array[ProcessActivity] result = apiInstance.processActivitiesGet();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ProcessActivitiesApi.processActivitiesGet: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\ProcessActivitiesApi();

try {
    $result = $api_instance->processActivitiesGet();
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ProcessActivitiesApi->processActivitiesGet: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::ProcessActivitiesApi;

my $api_instance = WWW::SwaggerClient::ProcessActivitiesApi->new();

eval { 
    my $result = $api_instance->processActivitiesGet();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ProcessActivitiesApi->processActivitiesGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.ProcessActivitiesApi()

try: 
    # Get all entities
    api_response = api_instance.process_activities_get()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ProcessActivitiesApi->processActivitiesGet: %s\n" % e)

Parameters

Responses

Status: 200 - Array of entities

Status: 500 - An errror occured.


processActivitiesPost

Add a new entity


/processActivities

Usage and SDK Samples

curl -X POST "http://localhost/api/processActivities"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ProcessActivitiesApi;

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

public class ProcessActivitiesApiExample {

    public static void main(String[] args) {
        
        ProcessActivitiesApi apiInstance = new ProcessActivitiesApi();
        ProcessActivity body = ; // ProcessActivity | Object that shall be stored
        try {
            ProcessActivity result = apiInstance.processActivitiesPost(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProcessActivitiesApi#processActivitiesPost");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.ProcessActivitiesApi;

public class ProcessActivitiesApiExample {

    public static void main(String[] args) {
        ProcessActivitiesApi apiInstance = new ProcessActivitiesApi();
        ProcessActivity body = ; // ProcessActivity | Object that shall be stored
        try {
            ProcessActivity result = apiInstance.processActivitiesPost(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProcessActivitiesApi#processActivitiesPost");
            e.printStackTrace();
        }
    }
}
ProcessActivity *body = ; // Object that shall be stored

ProcessActivitiesApi *apiInstance = [[ProcessActivitiesApi alloc] init];

// Add a new entity
[apiInstance processActivitiesPostWith:body
              completionHandler: ^(ProcessActivity output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var DemoFacility = require('demo_facility');

var api = new DemoFacility.ProcessActivitiesApi()

var body = ; // {ProcessActivity} Object that shall be stored


var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.processActivitiesPost(body, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class processActivitiesPostExample
    {
        public void main()
        {
            
            var apiInstance = new ProcessActivitiesApi();
            var body = new ProcessActivity(); // ProcessActivity | Object that shall be stored

            try
            {
                // Add a new entity
                ProcessActivity result = apiInstance.processActivitiesPost(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ProcessActivitiesApi.processActivitiesPost: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\ProcessActivitiesApi();
$body = ; // ProcessActivity | Object that shall be stored

try {
    $result = $api_instance->processActivitiesPost($body);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ProcessActivitiesApi->processActivitiesPost: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::ProcessActivitiesApi;

my $api_instance = WWW::SwaggerClient::ProcessActivitiesApi->new();
my $body = WWW::SwaggerClient::Object::ProcessActivity->new(); # ProcessActivity | Object that shall be stored

eval { 
    my $result = $api_instance->processActivitiesPost(body => $body);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ProcessActivitiesApi->processActivitiesPost: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.ProcessActivitiesApi()
body =  # ProcessActivity | Object that shall be stored

try: 
    # Add a new entity
    api_response = api_instance.process_activities_post(body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ProcessActivitiesApi->processActivitiesPost: %s\n" % e)

Parameters

Body parameters
Name Description
body *

Responses

Status: 201 - Entitiy stored.

Status: 500 - An errror occured.


processesActivitiesIdDelete

Deletes an entity


/processesActivities/{id}

Usage and SDK Samples

curl -X DELETE "http://localhost/api/processesActivities/{id}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ProcessActivitiesApi;

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

public class ProcessActivitiesApiExample {

    public static void main(String[] args) {
        
        ProcessActivitiesApi apiInstance = new ProcessActivitiesApi();
        String id = id_example; // String | ID of entity to fetch
        try {
            apiInstance.processesActivitiesIdDelete(id);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProcessActivitiesApi#processesActivitiesIdDelete");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.ProcessActivitiesApi;

public class ProcessActivitiesApiExample {

    public static void main(String[] args) {
        ProcessActivitiesApi apiInstance = new ProcessActivitiesApi();
        String id = id_example; // String | ID of entity to fetch
        try {
            apiInstance.processesActivitiesIdDelete(id);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProcessActivitiesApi#processesActivitiesIdDelete");
            e.printStackTrace();
        }
    }
}
String *id = id_example; // ID of entity to fetch

ProcessActivitiesApi *apiInstance = [[ProcessActivitiesApi alloc] init];

// Deletes an entity
[apiInstance processesActivitiesIdDeleteWith:id
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var DemoFacility = require('demo_facility');

var api = new DemoFacility.ProcessActivitiesApi()

var id = id_example; // {String} ID of entity to fetch


var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.processesActivitiesIdDelete(id, , callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class processesActivitiesIdDeleteExample
    {
        public void main()
        {
            
            var apiInstance = new ProcessActivitiesApi();
            var id = id_example;  // String | ID of entity to fetch

            try
            {
                // Deletes an entity
                apiInstance.processesActivitiesIdDelete(id);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ProcessActivitiesApi.processesActivitiesIdDelete: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\ProcessActivitiesApi();
$id = id_example; // String | ID of entity to fetch

try {
    $api_instance->processesActivitiesIdDelete($id);
} catch (Exception $e) {
    echo 'Exception when calling ProcessActivitiesApi->processesActivitiesIdDelete: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::ProcessActivitiesApi;

my $api_instance = WWW::SwaggerClient::ProcessActivitiesApi->new();
my $id = id_example; # String | ID of entity to fetch

eval { 
    $api_instance->processesActivitiesIdDelete(id => $id);
};
if ($@) {
    warn "Exception when calling ProcessActivitiesApi->processesActivitiesIdDelete: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.ProcessActivitiesApi()
id = id_example # String | ID of entity to fetch

try: 
    # Deletes an entity
    api_instance.processes_activities_id_delete(id)
except ApiException as e:
    print("Exception when calling ProcessActivitiesApi->processesActivitiesIdDelete: %s\n" % e)

Parameters

Path parameters
Name Description
id*
String
ID of entity to fetch
Required

Responses

Status: 200 - Entity deleted.

Status: 404 - Entity not found.


processesActivitiesIdGet

Get entity by id


/processesActivities/{id}

Usage and SDK Samples

curl -X GET "http://localhost/api/processesActivities/{id}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ProcessActivitiesApi;

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

public class ProcessActivitiesApiExample {

    public static void main(String[] args) {
        
        ProcessActivitiesApi apiInstance = new ProcessActivitiesApi();
        String id = id_example; // String | ID of entity to fetch
        try {
            ProcessActivity result = apiInstance.processesActivitiesIdGet(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProcessActivitiesApi#processesActivitiesIdGet");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.ProcessActivitiesApi;

public class ProcessActivitiesApiExample {

    public static void main(String[] args) {
        ProcessActivitiesApi apiInstance = new ProcessActivitiesApi();
        String id = id_example; // String | ID of entity to fetch
        try {
            ProcessActivity result = apiInstance.processesActivitiesIdGet(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProcessActivitiesApi#processesActivitiesIdGet");
            e.printStackTrace();
        }
    }
}
String *id = id_example; // ID of entity to fetch

ProcessActivitiesApi *apiInstance = [[ProcessActivitiesApi alloc] init];

// Get entity by id
[apiInstance processesActivitiesIdGetWith:id
              completionHandler: ^(ProcessActivity output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var DemoFacility = require('demo_facility');

var api = new DemoFacility.ProcessActivitiesApi()

var id = id_example; // {String} ID of entity to fetch


var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.processesActivitiesIdGet(id, , callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class processesActivitiesIdGetExample
    {
        public void main()
        {
            
            var apiInstance = new ProcessActivitiesApi();
            var id = id_example;  // String | ID of entity to fetch

            try
            {
                // Get entity by id
                ProcessActivity result = apiInstance.processesActivitiesIdGet(id);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ProcessActivitiesApi.processesActivitiesIdGet: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\ProcessActivitiesApi();
$id = id_example; // String | ID of entity to fetch

try {
    $result = $api_instance->processesActivitiesIdGet($id);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ProcessActivitiesApi->processesActivitiesIdGet: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::ProcessActivitiesApi;

my $api_instance = WWW::SwaggerClient::ProcessActivitiesApi->new();
my $id = id_example; # String | ID of entity to fetch

eval { 
    my $result = $api_instance->processesActivitiesIdGet(id => $id);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ProcessActivitiesApi->processesActivitiesIdGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.ProcessActivitiesApi()
id = id_example # String | ID of entity to fetch

try: 
    # Get entity by id
    api_response = api_instance.processes_activities_id_get(id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ProcessActivitiesApi->processesActivitiesIdGet: %s\n" % e)

Parameters

Path parameters
Name Description
id*
String
ID of entity to fetch
Required

Responses

Status: 200 - Entitiy found.

Status: 404 - Entity not found.

Status: 500 - An error occured.


processesActivitiesIdPatch

Update an existing entity


/processesActivities/{id}

Usage and SDK Samples

curl -X PATCH "http://localhost/api/processesActivities/{id}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ProcessActivitiesApi;

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

public class ProcessActivitiesApiExample {

    public static void main(String[] args) {
        
        ProcessActivitiesApi apiInstance = new ProcessActivitiesApi();
        String id = id_example; // String | ID of entity to fetch
        ProcessActivity body = ; // ProcessActivity | Object that needs to be added
        try {
            ProcessActivity result = apiInstance.processesActivitiesIdPatch(id, body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProcessActivitiesApi#processesActivitiesIdPatch");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.ProcessActivitiesApi;

public class ProcessActivitiesApiExample {

    public static void main(String[] args) {
        ProcessActivitiesApi apiInstance = new ProcessActivitiesApi();
        String id = id_example; // String | ID of entity to fetch
        ProcessActivity body = ; // ProcessActivity | Object that needs to be added
        try {
            ProcessActivity result = apiInstance.processesActivitiesIdPatch(id, body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProcessActivitiesApi#processesActivitiesIdPatch");
            e.printStackTrace();
        }
    }
}
String *id = id_example; // ID of entity to fetch
ProcessActivity *body = ; // Object that needs to be added

ProcessActivitiesApi *apiInstance = [[ProcessActivitiesApi alloc] init];

// Update an existing entity
[apiInstance processesActivitiesIdPatchWith:id
    body:body
              completionHandler: ^(ProcessActivity output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var DemoFacility = require('demo_facility');

var api = new DemoFacility.ProcessActivitiesApi()

var id = id_example; // {String} ID of entity to fetch

var body = ; // {ProcessActivity} Object that needs to be added


var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.processesActivitiesIdPatch(id, body, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class processesActivitiesIdPatchExample
    {
        public void main()
        {
            
            var apiInstance = new ProcessActivitiesApi();
            var id = id_example;  // String | ID of entity to fetch
            var body = new ProcessActivity(); // ProcessActivity | Object that needs to be added

            try
            {
                // Update an existing entity
                ProcessActivity result = apiInstance.processesActivitiesIdPatch(id, body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ProcessActivitiesApi.processesActivitiesIdPatch: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\ProcessActivitiesApi();
$id = id_example; // String | ID of entity to fetch
$body = ; // ProcessActivity | Object that needs to be added

try {
    $result = $api_instance->processesActivitiesIdPatch($id, $body);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ProcessActivitiesApi->processesActivitiesIdPatch: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::ProcessActivitiesApi;

my $api_instance = WWW::SwaggerClient::ProcessActivitiesApi->new();
my $id = id_example; # String | ID of entity to fetch
my $body = WWW::SwaggerClient::Object::ProcessActivity->new(); # ProcessActivity | Object that needs to be added

eval { 
    my $result = $api_instance->processesActivitiesIdPatch(id => $id, body => $body);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ProcessActivitiesApi->processesActivitiesIdPatch: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.ProcessActivitiesApi()
id = id_example # String | ID of entity to fetch
body =  # ProcessActivity | Object that needs to be added

try: 
    # Update an existing entity
    api_response = api_instance.processes_activities_id_patch(id, body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ProcessActivitiesApi->processesActivitiesIdPatch: %s\n" % e)

Parameters

Path parameters
Name Description
id*
String
ID of entity to fetch
Required
Body parameters
Name Description
body *

Responses

Status: 200 - Entitiy updated.

Status: 404 - Entity does not exist.


Processes

processesGet

Get all entities


/processes

Usage and SDK Samples

curl -X GET "http://localhost/api/processes"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ProcessesApi;

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

public class ProcessesApiExample {

    public static void main(String[] args) {
        
        ProcessesApi apiInstance = new ProcessesApi();
        try {
            array[Process] result = apiInstance.processesGet();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProcessesApi#processesGet");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.ProcessesApi;

public class ProcessesApiExample {

    public static void main(String[] args) {
        ProcessesApi apiInstance = new ProcessesApi();
        try {
            array[Process] result = apiInstance.processesGet();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProcessesApi#processesGet");
            e.printStackTrace();
        }
    }
}

ProcessesApi *apiInstance = [[ProcessesApi alloc] init];

// Get all entities
[apiInstance processesGetWithCompletionHandler: 
              ^(array[Process] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var DemoFacility = require('demo_facility');

var api = new DemoFacility.ProcessesApi()

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.processesGet(callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class processesGetExample
    {
        public void main()
        {
            
            var apiInstance = new ProcessesApi();

            try
            {
                // Get all entities
                array[Process] result = apiInstance.processesGet();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ProcessesApi.processesGet: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\ProcessesApi();

try {
    $result = $api_instance->processesGet();
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ProcessesApi->processesGet: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::ProcessesApi;

my $api_instance = WWW::SwaggerClient::ProcessesApi->new();

eval { 
    my $result = $api_instance->processesGet();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ProcessesApi->processesGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.ProcessesApi()

try: 
    # Get all entities
    api_response = api_instance.processes_get()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ProcessesApi->processesGet: %s\n" % e)

Parameters

Responses

Status: 200 - Array of entities

Status: 500 - An errror occured.


processesIdDelete

Deletes an entity


/processes/{id}

Usage and SDK Samples

curl -X DELETE "http://localhost/api/processes/{id}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ProcessesApi;

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

public class ProcessesApiExample {

    public static void main(String[] args) {
        
        ProcessesApi apiInstance = new ProcessesApi();
        String id = id_example; // String | ID of entity to fetch
        try {
            apiInstance.processesIdDelete(id);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProcessesApi#processesIdDelete");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.ProcessesApi;

public class ProcessesApiExample {

    public static void main(String[] args) {
        ProcessesApi apiInstance = new ProcessesApi();
        String id = id_example; // String | ID of entity to fetch
        try {
            apiInstance.processesIdDelete(id);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProcessesApi#processesIdDelete");
            e.printStackTrace();
        }
    }
}
String *id = id_example; // ID of entity to fetch

ProcessesApi *apiInstance = [[ProcessesApi alloc] init];

// Deletes an entity
[apiInstance processesIdDeleteWith:id
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var DemoFacility = require('demo_facility');

var api = new DemoFacility.ProcessesApi()

var id = id_example; // {String} ID of entity to fetch


var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.processesIdDelete(id, , callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class processesIdDeleteExample
    {
        public void main()
        {
            
            var apiInstance = new ProcessesApi();
            var id = id_example;  // String | ID of entity to fetch

            try
            {
                // Deletes an entity
                apiInstance.processesIdDelete(id);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ProcessesApi.processesIdDelete: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\ProcessesApi();
$id = id_example; // String | ID of entity to fetch

try {
    $api_instance->processesIdDelete($id);
} catch (Exception $e) {
    echo 'Exception when calling ProcessesApi->processesIdDelete: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::ProcessesApi;

my $api_instance = WWW::SwaggerClient::ProcessesApi->new();
my $id = id_example; # String | ID of entity to fetch

eval { 
    $api_instance->processesIdDelete(id => $id);
};
if ($@) {
    warn "Exception when calling ProcessesApi->processesIdDelete: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.ProcessesApi()
id = id_example # String | ID of entity to fetch

try: 
    # Deletes an entity
    api_instance.processes_id_delete(id)
except ApiException as e:
    print("Exception when calling ProcessesApi->processesIdDelete: %s\n" % e)

Parameters

Path parameters
Name Description
id*
String
ID of entity to fetch
Required

Responses

Status: 200 - Entity deleted.

Status: 404 - Entity not found.


processesIdGet

Get entity by id


/processes/{id}

Usage and SDK Samples

curl -X GET "http://localhost/api/processes/{id}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ProcessesApi;

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

public class ProcessesApiExample {

    public static void main(String[] args) {
        
        ProcessesApi apiInstance = new ProcessesApi();
        String id = id_example; // String | ID of entity to fetch
        try {
            Process result = apiInstance.processesIdGet(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProcessesApi#processesIdGet");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.ProcessesApi;

public class ProcessesApiExample {

    public static void main(String[] args) {
        ProcessesApi apiInstance = new ProcessesApi();
        String id = id_example; // String | ID of entity to fetch
        try {
            Process result = apiInstance.processesIdGet(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProcessesApi#processesIdGet");
            e.printStackTrace();
        }
    }
}
String *id = id_example; // ID of entity to fetch

ProcessesApi *apiInstance = [[ProcessesApi alloc] init];

// Get entity by id
[apiInstance processesIdGetWith:id
              completionHandler: ^(Process output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var DemoFacility = require('demo_facility');

var api = new DemoFacility.ProcessesApi()

var id = id_example; // {String} ID of entity to fetch


var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.processesIdGet(id, , callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class processesIdGetExample
    {
        public void main()
        {
            
            var apiInstance = new ProcessesApi();
            var id = id_example;  // String | ID of entity to fetch

            try
            {
                // Get entity by id
                Process result = apiInstance.processesIdGet(id);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ProcessesApi.processesIdGet: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\ProcessesApi();
$id = id_example; // String | ID of entity to fetch

try {
    $result = $api_instance->processesIdGet($id);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ProcessesApi->processesIdGet: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::ProcessesApi;

my $api_instance = WWW::SwaggerClient::ProcessesApi->new();
my $id = id_example; # String | ID of entity to fetch

eval { 
    my $result = $api_instance->processesIdGet(id => $id);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ProcessesApi->processesIdGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.ProcessesApi()
id = id_example # String | ID of entity to fetch

try: 
    # Get entity by id
    api_response = api_instance.processes_id_get(id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ProcessesApi->processesIdGet: %s\n" % e)

Parameters

Path parameters
Name Description
id*
String
ID of entity to fetch
Required

Responses

Status: 200 - Entitiy found.

Status: 404 - Entity not found.

Status: 500 - An error occured.


processesIdPatch

Update an existing entity


/processes/{id}

Usage and SDK Samples

curl -X PATCH "http://localhost/api/processes/{id}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ProcessesApi;

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

public class ProcessesApiExample {

    public static void main(String[] args) {
        
        ProcessesApi apiInstance = new ProcessesApi();
        String id = id_example; // String | ID of entity to fetch
        Process body = ; // Process | Object that needs to be added
        try {
            Process result = apiInstance.processesIdPatch(id, body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProcessesApi#processesIdPatch");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.ProcessesApi;

public class ProcessesApiExample {

    public static void main(String[] args) {
        ProcessesApi apiInstance = new ProcessesApi();
        String id = id_example; // String | ID of entity to fetch
        Process body = ; // Process | Object that needs to be added
        try {
            Process result = apiInstance.processesIdPatch(id, body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProcessesApi#processesIdPatch");
            e.printStackTrace();
        }
    }
}
String *id = id_example; // ID of entity to fetch
Process *body = ; // Object that needs to be added

ProcessesApi *apiInstance = [[ProcessesApi alloc] init];

// Update an existing entity
[apiInstance processesIdPatchWith:id
    body:body
              completionHandler: ^(Process output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var DemoFacility = require('demo_facility');

var api = new DemoFacility.ProcessesApi()

var id = id_example; // {String} ID of entity to fetch

var body = ; // {Process} Object that needs to be added


var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.processesIdPatch(id, body, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class processesIdPatchExample
    {
        public void main()
        {
            
            var apiInstance = new ProcessesApi();
            var id = id_example;  // String | ID of entity to fetch
            var body = new Process(); // Process | Object that needs to be added

            try
            {
                // Update an existing entity
                Process result = apiInstance.processesIdPatch(id, body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ProcessesApi.processesIdPatch: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\ProcessesApi();
$id = id_example; // String | ID of entity to fetch
$body = ; // Process | Object that needs to be added

try {
    $result = $api_instance->processesIdPatch($id, $body);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ProcessesApi->processesIdPatch: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::ProcessesApi;

my $api_instance = WWW::SwaggerClient::ProcessesApi->new();
my $id = id_example; # String | ID of entity to fetch
my $body = WWW::SwaggerClient::Object::Process->new(); # Process | Object that needs to be added

eval { 
    my $result = $api_instance->processesIdPatch(id => $id, body => $body);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ProcessesApi->processesIdPatch: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.ProcessesApi()
id = id_example # String | ID of entity to fetch
body =  # Process | Object that needs to be added

try: 
    # Update an existing entity
    api_response = api_instance.processes_id_patch(id, body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ProcessesApi->processesIdPatch: %s\n" % e)

Parameters

Path parameters
Name Description
id*
String
ID of entity to fetch
Required
Body parameters
Name Description
body *

Responses

Status: 200 - Entitiy updated.

Status: 404 - Entity does not exist.


processesPost

Add a new entity


/processes

Usage and SDK Samples

curl -X POST "http://localhost/api/processes"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ProcessesApi;

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

public class ProcessesApiExample {

    public static void main(String[] args) {
        
        ProcessesApi apiInstance = new ProcessesApi();
        Process body = ; // Process | Object that shall be stored
        try {
            Process result = apiInstance.processesPost(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProcessesApi#processesPost");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.ProcessesApi;

public class ProcessesApiExample {

    public static void main(String[] args) {
        ProcessesApi apiInstance = new ProcessesApi();
        Process body = ; // Process | Object that shall be stored
        try {
            Process result = apiInstance.processesPost(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProcessesApi#processesPost");
            e.printStackTrace();
        }
    }
}
Process *body = ; // Object that shall be stored

ProcessesApi *apiInstance = [[ProcessesApi alloc] init];

// Add a new entity
[apiInstance processesPostWith:body
              completionHandler: ^(Process output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var DemoFacility = require('demo_facility');

var api = new DemoFacility.ProcessesApi()

var body = ; // {Process} Object that shall be stored


var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.processesPost(body, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class processesPostExample
    {
        public void main()
        {
            
            var apiInstance = new ProcessesApi();
            var body = new Process(); // Process | Object that shall be stored

            try
            {
                // Add a new entity
                Process result = apiInstance.processesPost(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ProcessesApi.processesPost: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\ProcessesApi();
$body = ; // Process | Object that shall be stored

try {
    $result = $api_instance->processesPost($body);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ProcessesApi->processesPost: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::ProcessesApi;

my $api_instance = WWW::SwaggerClient::ProcessesApi->new();
my $body = WWW::SwaggerClient::Object::Process->new(); # Process | Object that shall be stored

eval { 
    my $result = $api_instance->processesPost(body => $body);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ProcessesApi->processesPost: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.ProcessesApi()
body =  # Process | Object that shall be stored

try: 
    # Add a new entity
    api_response = api_instance.processes_post(body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ProcessesApi->processesPost: %s\n" % e)

Parameters

Body parameters
Name Description
body *

Responses

Status: 201 - Entitiy stored.

Status: 500 - An errror occured.


Products

productsGet

Get all entities


/products

Usage and SDK Samples

curl -X GET "http://localhost/api/products"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ProductsApi;

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

public class ProductsApiExample {

    public static void main(String[] args) {
        
        ProductsApi apiInstance = new ProductsApi();
        try {
            array[Product] result = apiInstance.productsGet();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProductsApi#productsGet");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.ProductsApi;

public class ProductsApiExample {

    public static void main(String[] args) {
        ProductsApi apiInstance = new ProductsApi();
        try {
            array[Product] result = apiInstance.productsGet();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProductsApi#productsGet");
            e.printStackTrace();
        }
    }
}

ProductsApi *apiInstance = [[ProductsApi alloc] init];

// Get all entities
[apiInstance productsGetWithCompletionHandler: 
              ^(array[Product] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var DemoFacility = require('demo_facility');

var api = new DemoFacility.ProductsApi()

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.productsGet(callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class productsGetExample
    {
        public void main()
        {
            
            var apiInstance = new ProductsApi();

            try
            {
                // Get all entities
                array[Product] result = apiInstance.productsGet();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ProductsApi.productsGet: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\ProductsApi();

try {
    $result = $api_instance->productsGet();
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ProductsApi->productsGet: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::ProductsApi;

my $api_instance = WWW::SwaggerClient::ProductsApi->new();

eval { 
    my $result = $api_instance->productsGet();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ProductsApi->productsGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.ProductsApi()

try: 
    # Get all entities
    api_response = api_instance.products_get()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ProductsApi->productsGet: %s\n" % e)

Parameters

Responses

Status: 200 - Array of entities

Status: 500 - An errror occured.


productsIdDelete

Deletes an entity


/products/{id}

Usage and SDK Samples

curl -X DELETE "http://localhost/api/products/{id}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ProductsApi;

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

public class ProductsApiExample {

    public static void main(String[] args) {
        
        ProductsApi apiInstance = new ProductsApi();
        String id = id_example; // String | ID of entity to fetch
        try {
            apiInstance.productsIdDelete(id);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProductsApi#productsIdDelete");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.ProductsApi;

public class ProductsApiExample {

    public static void main(String[] args) {
        ProductsApi apiInstance = new ProductsApi();
        String id = id_example; // String | ID of entity to fetch
        try {
            apiInstance.productsIdDelete(id);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProductsApi#productsIdDelete");
            e.printStackTrace();
        }
    }
}
String *id = id_example; // ID of entity to fetch

ProductsApi *apiInstance = [[ProductsApi alloc] init];

// Deletes an entity
[apiInstance productsIdDeleteWith:id
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var DemoFacility = require('demo_facility');

var api = new DemoFacility.ProductsApi()

var id = id_example; // {String} ID of entity to fetch


var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.productsIdDelete(id, , callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class productsIdDeleteExample
    {
        public void main()
        {
            
            var apiInstance = new ProductsApi();
            var id = id_example;  // String | ID of entity to fetch

            try
            {
                // Deletes an entity
                apiInstance.productsIdDelete(id);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ProductsApi.productsIdDelete: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\ProductsApi();
$id = id_example; // String | ID of entity to fetch

try {
    $api_instance->productsIdDelete($id);
} catch (Exception $e) {
    echo 'Exception when calling ProductsApi->productsIdDelete: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::ProductsApi;

my $api_instance = WWW::SwaggerClient::ProductsApi->new();
my $id = id_example; # String | ID of entity to fetch

eval { 
    $api_instance->productsIdDelete(id => $id);
};
if ($@) {
    warn "Exception when calling ProductsApi->productsIdDelete: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.ProductsApi()
id = id_example # String | ID of entity to fetch

try: 
    # Deletes an entity
    api_instance.products_id_delete(id)
except ApiException as e:
    print("Exception when calling ProductsApi->productsIdDelete: %s\n" % e)

Parameters

Path parameters
Name Description
id*
String
ID of entity to fetch
Required

Responses

Status: 200 - Entity deleted.

Status: 404 - Entity not found.


productsIdGet

Get entity by id


/products/{id}

Usage and SDK Samples

curl -X GET "http://localhost/api/products/{id}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ProductsApi;

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

public class ProductsApiExample {

    public static void main(String[] args) {
        
        ProductsApi apiInstance = new ProductsApi();
        String id = id_example; // String | ID of entity to fetch
        try {
            Product result = apiInstance.productsIdGet(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProductsApi#productsIdGet");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.ProductsApi;

public class ProductsApiExample {

    public static void main(String[] args) {
        ProductsApi apiInstance = new ProductsApi();
        String id = id_example; // String | ID of entity to fetch
        try {
            Product result = apiInstance.productsIdGet(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProductsApi#productsIdGet");
            e.printStackTrace();
        }
    }
}
String *id = id_example; // ID of entity to fetch

ProductsApi *apiInstance = [[ProductsApi alloc] init];

// Get entity by id
[apiInstance productsIdGetWith:id
              completionHandler: ^(Product output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var DemoFacility = require('demo_facility');

var api = new DemoFacility.ProductsApi()

var id = id_example; // {String} ID of entity to fetch


var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.productsIdGet(id, , callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class productsIdGetExample
    {
        public void main()
        {
            
            var apiInstance = new ProductsApi();
            var id = id_example;  // String | ID of entity to fetch

            try
            {
                // Get entity by id
                Product result = apiInstance.productsIdGet(id);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ProductsApi.productsIdGet: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\ProductsApi();
$id = id_example; // String | ID of entity to fetch

try {
    $result = $api_instance->productsIdGet($id);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ProductsApi->productsIdGet: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::ProductsApi;

my $api_instance = WWW::SwaggerClient::ProductsApi->new();
my $id = id_example; # String | ID of entity to fetch

eval { 
    my $result = $api_instance->productsIdGet(id => $id);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ProductsApi->productsIdGet: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.ProductsApi()
id = id_example # String | ID of entity to fetch

try: 
    # Get entity by id
    api_response = api_instance.products_id_get(id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ProductsApi->productsIdGet: %s\n" % e)

Parameters

Path parameters
Name Description
id*
String
ID of entity to fetch
Required

Responses

Status: 200 - Entitiy found.

Status: 404 - Entity not found.

Status: 500 - An error occured.


productsIdPatch

Update an existing entity


/products/{id}

Usage and SDK Samples

curl -X PATCH "http://localhost/api/products/{id}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ProductsApi;

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

public class ProductsApiExample {

    public static void main(String[] args) {
        
        ProductsApi apiInstance = new ProductsApi();
        String id = id_example; // String | ID of entity to fetch
        Product body = ; // Product | Object that needs to be added
        try {
            Product result = apiInstance.productsIdPatch(id, body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProductsApi#productsIdPatch");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.ProductsApi;

public class ProductsApiExample {

    public static void main(String[] args) {
        ProductsApi apiInstance = new ProductsApi();
        String id = id_example; // String | ID of entity to fetch
        Product body = ; // Product | Object that needs to be added
        try {
            Product result = apiInstance.productsIdPatch(id, body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProductsApi#productsIdPatch");
            e.printStackTrace();
        }
    }
}
String *id = id_example; // ID of entity to fetch
Product *body = ; // Object that needs to be added

ProductsApi *apiInstance = [[ProductsApi alloc] init];

// Update an existing entity
[apiInstance productsIdPatchWith:id
    body:body
              completionHandler: ^(Product output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var DemoFacility = require('demo_facility');

var api = new DemoFacility.ProductsApi()

var id = id_example; // {String} ID of entity to fetch

var body = ; // {Product} Object that needs to be added


var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.productsIdPatch(id, body, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class productsIdPatchExample
    {
        public void main()
        {
            
            var apiInstance = new ProductsApi();
            var id = id_example;  // String | ID of entity to fetch
            var body = new Product(); // Product | Object that needs to be added

            try
            {
                // Update an existing entity
                Product result = apiInstance.productsIdPatch(id, body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ProductsApi.productsIdPatch: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\ProductsApi();
$id = id_example; // String | ID of entity to fetch
$body = ; // Product | Object that needs to be added

try {
    $result = $api_instance->productsIdPatch($id, $body);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ProductsApi->productsIdPatch: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::ProductsApi;

my $api_instance = WWW::SwaggerClient::ProductsApi->new();
my $id = id_example; # String | ID of entity to fetch
my $body = WWW::SwaggerClient::Object::Product->new(); # Product | Object that needs to be added

eval { 
    my $result = $api_instance->productsIdPatch(id => $id, body => $body);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ProductsApi->productsIdPatch: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.ProductsApi()
id = id_example # String | ID of entity to fetch
body =  # Product | Object that needs to be added

try: 
    # Update an existing entity
    api_response = api_instance.products_id_patch(id, body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ProductsApi->productsIdPatch: %s\n" % e)

Parameters

Path parameters
Name Description
id*
String
ID of entity to fetch
Required
Body parameters
Name Description
body *

Responses

Status: 200 - Entitiy updated.

Status: 404 - Entity does not exist.


productsPost

Add a new entity


/products

Usage and SDK Samples

curl -X POST "http://localhost/api/products"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ProductsApi;

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

public class ProductsApiExample {

    public static void main(String[] args) {
        
        ProductsApi apiInstance = new ProductsApi();
        Product body = ; // Product | Object that shall be stored
        try {
            Product result = apiInstance.productsPost(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProductsApi#productsPost");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.ProductsApi;

public class ProductsApiExample {

    public static void main(String[] args) {
        ProductsApi apiInstance = new ProductsApi();
        Product body = ; // Product | Object that shall be stored
        try {
            Product result = apiInstance.productsPost(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProductsApi#productsPost");
            e.printStackTrace();
        }
    }
}
Product *body = ; // Object that shall be stored

ProductsApi *apiInstance = [[ProductsApi alloc] init];

// Add a new entity
[apiInstance productsPostWith:body
              completionHandler: ^(Product output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var DemoFacility = require('demo_facility');

var api = new DemoFacility.ProductsApi()

var body = ; // {Product} Object that shall be stored


var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.productsPost(body, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class productsPostExample
    {
        public void main()
        {
            
            var apiInstance = new ProductsApi();
            var body = new Product(); // Product | Object that shall be stored

            try
            {
                // Add a new entity
                Product result = apiInstance.productsPost(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ProductsApi.productsPost: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\ProductsApi();
$body = ; // Product | Object that shall be stored

try {
    $result = $api_instance->productsPost($body);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ProductsApi->productsPost: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::ProductsApi;

my $api_instance = WWW::SwaggerClient::ProductsApi->new();
my $body = WWW::SwaggerClient::Object::Product->new(); # Product | Object that shall be stored

eval { 
    my $result = $api_instance->productsPost(body => $body);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ProductsApi->productsPost: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.ProductsApi()
body =  # Product | Object that shall be stored

try: 
    # Add a new entity
    api_response = api_instance.products_post(body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ProductsApi->productsPost: %s\n" % e)

Parameters

Body parameters
Name Description
body *

Responses

Status: 201 - Entitiy stored.

Status: 500 - An errror occured.


Simulation

simulationProcessProcessIdOrderOrderIdPost

Start a simulation


/simulation/process/{processId}/order/{orderId}

Usage and SDK Samples

curl -X POST "http://localhost/api/simulation/process/{processId}/order/{orderId}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.SimulationApi;

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

public class SimulationApiExample {

    public static void main(String[] args) {
        
        SimulationApi apiInstance = new SimulationApi();
        String processId = processId_example; // String | ID of process to simulate
        String orderId = orderId_example; // String | ID of order to simulate
        try {
            Product result = apiInstance.simulationProcessProcessIdOrderOrderIdPost(processId, orderId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling SimulationApi#simulationProcessProcessIdOrderOrderIdPost");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.SimulationApi;

public class SimulationApiExample {

    public static void main(String[] args) {
        SimulationApi apiInstance = new SimulationApi();
        String processId = processId_example; // String | ID of process to simulate
        String orderId = orderId_example; // String | ID of order to simulate
        try {
            Product result = apiInstance.simulationProcessProcessIdOrderOrderIdPost(processId, orderId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling SimulationApi#simulationProcessProcessIdOrderOrderIdPost");
            e.printStackTrace();
        }
    }
}
String *processId = processId_example; // ID of process to simulate
String *orderId = orderId_example; // ID of order to simulate

SimulationApi *apiInstance = [[SimulationApi alloc] init];

// Start a simulation
[apiInstance simulationProcessProcessIdOrderOrderIdPostWith:processId
    orderId:orderId
              completionHandler: ^(Product output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var DemoFacility = require('demo_facility');

var api = new DemoFacility.SimulationApi()

var processId = processId_example; // {String} ID of process to simulate

var orderId = orderId_example; // {String} ID of order to simulate


var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.simulationProcessProcessIdOrderOrderIdPost(processId, orderId, callback);
using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class simulationProcessProcessIdOrderOrderIdPostExample
    {
        public void main()
        {
            
            var apiInstance = new SimulationApi();
            var processId = processId_example;  // String | ID of process to simulate
            var orderId = orderId_example;  // String | ID of order to simulate

            try
            {
                // Start a simulation
                Product result = apiInstance.simulationProcessProcessIdOrderOrderIdPost(processId, orderId);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling SimulationApi.simulationProcessProcessIdOrderOrderIdPost: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\Api\SimulationApi();
$processId = processId_example; // String | ID of process to simulate
$orderId = orderId_example; // String | ID of order to simulate

try {
    $result = $api_instance->simulationProcessProcessIdOrderOrderIdPost($processId, $orderId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling SimulationApi->simulationProcessProcessIdOrderOrderIdPost: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::SimulationApi;

my $api_instance = WWW::SwaggerClient::SimulationApi->new();
my $processId = processId_example; # String | ID of process to simulate
my $orderId = orderId_example; # String | ID of order to simulate

eval { 
    my $result = $api_instance->simulationProcessProcessIdOrderOrderIdPost(processId => $processId, orderId => $orderId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling SimulationApi->simulationProcessProcessIdOrderOrderIdPost: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.SimulationApi()
processId = processId_example # String | ID of process to simulate
orderId = orderId_example # String | ID of order to simulate

try: 
    # Start a simulation
    api_response = api_instance.simulation_process_process_id_order_order_id_post(processId, orderId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling SimulationApi->simulationProcessProcessIdOrderOrderIdPost: %s\n" % e)

Parameters

Path parameters
Name Description
processId*
String
ID of process to simulate
Required
orderId*
String
ID of order to simulate
Required

Responses

Status: 200 - Simulation started.

Status: 404 - Entity does not exist.