Internal - TraceSense API

Api

apiAllergensListAllergensList


/api/allergens/list-allergens/

Usage and SDK Samples

curl -X GET -H "Accept: application/json" -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://127.0.0.1:8000/api/allergens/list-allergens/"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ApiApi;

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

public class ApiApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: Basic
        HttpBasicAuth Basic = (HttpBasicAuth) defaultClient.getAuthentication("Basic");
        Basic.setUsername("YOUR USERNAME");
        Basic.setPassword("YOUR PASSWORD");

        ApiApi apiInstance = new ApiApi();
        try {
            array[Allergens] result = apiInstance.apiAllergensListAllergensList();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiApi#apiAllergensListAllergensList");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.ApiApi;

public class ApiApiExample {

    public static void main(String[] args) {
        ApiApi apiInstance = new ApiApi();
        try {
            array[Allergens] result = apiInstance.apiAllergensListAllergensList();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiApi#apiAllergensListAllergensList");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: Basic)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];


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

[apiInstance apiAllergensListAllergensListWithCompletionHandler: 
              ^(array[Allergens] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var InternalTraceSenseApi = require('internal___trace_sense_api');
var defaultClient = InternalTraceSenseApi.ApiClient.instance;

// Configure HTTP basic authorization: Basic
var Basic = defaultClient.authentications['Basic'];
Basic.username = 'YOUR USERNAME'
Basic.password = 'YOUR PASSWORD'

var api = new InternalTraceSenseApi.ApiApi()

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

namespace Example
{
    public class apiAllergensListAllergensListExample
    {
        public void main()
        {
            
            // Configure HTTP basic authorization: Basic
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new ApiApi();

            try
            {
                array[Allergens] result = apiInstance.apiAllergensListAllergensList();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ApiApi.apiAllergensListAllergensList: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: Basic
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

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

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

# Configure HTTP basic authorization: Basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

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

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

# Configure HTTP basic authorization: Basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

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

try: 
    api_response = api_instance.api_allergens_list_allergens_list()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ApiApi->apiAllergensListAllergensList: %s\n" % e)

Parameters

Responses

Status: 200 -


apiCommoditiesAddCsvCreate

Checks relevant directory and inserts data into database


/api/commodities/add/csv/

Usage and SDK Samples

curl -X POST -H "Accept: application/json" -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://127.0.0.1:8000/api/commodities/add/csv/"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ApiApi;

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

public class ApiApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: Basic
        HttpBasicAuth Basic = (HttpBasicAuth) defaultClient.getAuthentication("Basic");
        Basic.setUsername("YOUR USERNAME");
        Basic.setPassword("YOUR PASSWORD");

        ApiApi apiInstance = new ApiApi();
        try {
            apiInstance.apiCommoditiesAddCsvCreate();
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiApi#apiCommoditiesAddCsvCreate");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.ApiApi;

public class ApiApiExample {

    public static void main(String[] args) {
        ApiApi apiInstance = new ApiApi();
        try {
            apiInstance.apiCommoditiesAddCsvCreate();
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiApi#apiCommoditiesAddCsvCreate");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: Basic)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];


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

[apiInstance apiCommoditiesAddCsvCreateWithCompletionHandler: 
              ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var InternalTraceSenseApi = require('internal___trace_sense_api');
var defaultClient = InternalTraceSenseApi.ApiClient.instance;

// Configure HTTP basic authorization: Basic
var Basic = defaultClient.authentications['Basic'];
Basic.username = 'YOUR USERNAME'
Basic.password = 'YOUR PASSWORD'

var api = new InternalTraceSenseApi.ApiApi()

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

namespace Example
{
    public class apiCommoditiesAddCsvCreateExample
    {
        public void main()
        {
            
            // Configure HTTP basic authorization: Basic
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new ApiApi();

            try
            {
                apiInstance.apiCommoditiesAddCsvCreate();
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ApiApi.apiCommoditiesAddCsvCreate: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: Basic
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

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

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

# Configure HTTP basic authorization: Basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

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

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

# Configure HTTP basic authorization: Basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

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

try: 
    api_instance.api_commodities_add_csv_create()
except ApiException as e:
    print("Exception when calling ApiApi->apiCommoditiesAddCsvCreate: %s\n" % e)

Parameters

Responses

Status: 201 -


apiCommoditiesCommoditiesCreate


/api/commodities/commodities/

Usage and SDK Samples

curl -X POST -H "Accept: application/json" -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://127.0.0.1:8000/api/commodities/commodities/"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ApiApi;

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

public class ApiApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: Basic
        HttpBasicAuth Basic = (HttpBasicAuth) defaultClient.getAuthentication("Basic");
        Basic.setUsername("YOUR USERNAME");
        Basic.setPassword("YOUR PASSWORD");

        ApiApi apiInstance = new ApiApi();
        Commodities data = ; // Commodities | 
        try {
            Commodities result = apiInstance.apiCommoditiesCommoditiesCreate(data);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiApi#apiCommoditiesCommoditiesCreate");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.ApiApi;

public class ApiApiExample {

    public static void main(String[] args) {
        ApiApi apiInstance = new ApiApi();
        Commodities data = ; // Commodities | 
        try {
            Commodities result = apiInstance.apiCommoditiesCommoditiesCreate(data);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiApi#apiCommoditiesCommoditiesCreate");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: Basic)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

Commodities *data = ; // 

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

[apiInstance apiCommoditiesCommoditiesCreateWith:data
              completionHandler: ^(Commodities output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var InternalTraceSenseApi = require('internal___trace_sense_api');
var defaultClient = InternalTraceSenseApi.ApiClient.instance;

// Configure HTTP basic authorization: Basic
var Basic = defaultClient.authentications['Basic'];
Basic.username = 'YOUR USERNAME'
Basic.password = 'YOUR PASSWORD'

var api = new InternalTraceSenseApi.ApiApi()

var data = ; // {Commodities} 


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

namespace Example
{
    public class apiCommoditiesCommoditiesCreateExample
    {
        public void main()
        {
            
            // Configure HTTP basic authorization: Basic
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new ApiApi();
            var data = new Commodities(); // Commodities | 

            try
            {
                Commodities result = apiInstance.apiCommoditiesCommoditiesCreate(data);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ApiApi.apiCommoditiesCommoditiesCreate: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: Basic
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\Api\ApiApi();
$data = ; // Commodities | 

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

# Configure HTTP basic authorization: Basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::ApiApi->new();
my $data = WWW::SwaggerClient::Object::Commodities->new(); # Commodities | 

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

# Configure HTTP basic authorization: Basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.ApiApi()
data =  # Commodities | 

try: 
    api_response = api_instance.api_commodities_commodities_create(data)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ApiApi->apiCommoditiesCommoditiesCreate: %s\n" % e)

Parameters

Body parameters
Name Description
data *

Responses

Status: 201 -


apiCommoditiesCommoditiesList


/api/commodities/commodities/

Usage and SDK Samples

curl -X GET -H "Accept: application/json" -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://127.0.0.1:8000/api/commodities/commodities/?page="
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ApiApi;

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

public class ApiApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: Basic
        HttpBasicAuth Basic = (HttpBasicAuth) defaultClient.getAuthentication("Basic");
        Basic.setUsername("YOUR USERNAME");
        Basic.setPassword("YOUR PASSWORD");

        ApiApi apiInstance = new ApiApi();
        Integer page = 56; // Integer | A page number within the paginated result set.
        try {
            inline_response_200 result = apiInstance.apiCommoditiesCommoditiesList(page);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiApi#apiCommoditiesCommoditiesList");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.ApiApi;

public class ApiApiExample {

    public static void main(String[] args) {
        ApiApi apiInstance = new ApiApi();
        Integer page = 56; // Integer | A page number within the paginated result set.
        try {
            inline_response_200 result = apiInstance.apiCommoditiesCommoditiesList(page);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiApi#apiCommoditiesCommoditiesList");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: Basic)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

Integer *page = 56; // A page number within the paginated result set. (optional)

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

[apiInstance apiCommoditiesCommoditiesListWith:page
              completionHandler: ^(inline_response_200 output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var InternalTraceSenseApi = require('internal___trace_sense_api');
var defaultClient = InternalTraceSenseApi.ApiClient.instance;

// Configure HTTP basic authorization: Basic
var Basic = defaultClient.authentications['Basic'];
Basic.username = 'YOUR USERNAME'
Basic.password = 'YOUR PASSWORD'

var api = new InternalTraceSenseApi.ApiApi()

var opts = { 
  'page': 56 // {Integer} A page number within the paginated result set.
};

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

namespace Example
{
    public class apiCommoditiesCommoditiesListExample
    {
        public void main()
        {
            
            // Configure HTTP basic authorization: Basic
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new ApiApi();
            var page = 56;  // Integer | A page number within the paginated result set. (optional) 

            try
            {
                inline_response_200 result = apiInstance.apiCommoditiesCommoditiesList(page);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ApiApi.apiCommoditiesCommoditiesList: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: Basic
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\Api\ApiApi();
$page = 56; // Integer | A page number within the paginated result set.

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

# Configure HTTP basic authorization: Basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::ApiApi->new();
my $page = 56; # Integer | A page number within the paginated result set.

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

# Configure HTTP basic authorization: Basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.ApiApi()
page = 56 # Integer | A page number within the paginated result set. (optional)

try: 
    api_response = api_instance.api_commodities_commodities_list(page=page)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ApiApi->apiCommoditiesCommoditiesList: %s\n" % e)

Parameters

Query parameters
Name Description
page
Integer
A page number within the paginated result set.

Responses

Status: 200 -


apiCommoditiesListCommodityGroupsList


/api/commodities/list/commodity/groups/

Usage and SDK Samples

curl -X GET -H "Accept: application/json" -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://127.0.0.1:8000/api/commodities/list/commodity/groups/"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ApiApi;

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

public class ApiApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: Basic
        HttpBasicAuth Basic = (HttpBasicAuth) defaultClient.getAuthentication("Basic");
        Basic.setUsername("YOUR USERNAME");
        Basic.setPassword("YOUR PASSWORD");

        ApiApi apiInstance = new ApiApi();
        try {
            array[CommodityGroups] result = apiInstance.apiCommoditiesListCommodityGroupsList();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiApi#apiCommoditiesListCommodityGroupsList");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.ApiApi;

public class ApiApiExample {

    public static void main(String[] args) {
        ApiApi apiInstance = new ApiApi();
        try {
            array[CommodityGroups] result = apiInstance.apiCommoditiesListCommodityGroupsList();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiApi#apiCommoditiesListCommodityGroupsList");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: Basic)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];


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

[apiInstance apiCommoditiesListCommodityGroupsListWithCompletionHandler: 
              ^(array[CommodityGroups] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var InternalTraceSenseApi = require('internal___trace_sense_api');
var defaultClient = InternalTraceSenseApi.ApiClient.instance;

// Configure HTTP basic authorization: Basic
var Basic = defaultClient.authentications['Basic'];
Basic.username = 'YOUR USERNAME'
Basic.password = 'YOUR PASSWORD'

var api = new InternalTraceSenseApi.ApiApi()

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

namespace Example
{
    public class apiCommoditiesListCommodityGroupsListExample
    {
        public void main()
        {
            
            // Configure HTTP basic authorization: Basic
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new ApiApi();

            try
            {
                array[CommodityGroups] result = apiInstance.apiCommoditiesListCommodityGroupsList();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ApiApi.apiCommoditiesListCommodityGroupsList: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: Basic
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

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

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

# Configure HTTP basic authorization: Basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

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

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

# Configure HTTP basic authorization: Basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

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

try: 
    api_response = api_instance.api_commodities_list_commodity_groups_list()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ApiApi->apiCommoditiesListCommodityGroupsList: %s\n" % e)

Parameters

Responses

Status: 200 -


apiCommoditiesListList


/api/commodities/list/

Usage and SDK Samples

curl -X GET -H "Accept: application/json" -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://127.0.0.1:8000/api/commodities/list/"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ApiApi;

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

public class ApiApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: Basic
        HttpBasicAuth Basic = (HttpBasicAuth) defaultClient.getAuthentication("Basic");
        Basic.setUsername("YOUR USERNAME");
        Basic.setPassword("YOUR PASSWORD");

        ApiApi apiInstance = new ApiApi();
        try {
            array[Commodities] result = apiInstance.apiCommoditiesListList();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiApi#apiCommoditiesListList");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.ApiApi;

public class ApiApiExample {

    public static void main(String[] args) {
        ApiApi apiInstance = new ApiApi();
        try {
            array[Commodities] result = apiInstance.apiCommoditiesListList();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiApi#apiCommoditiesListList");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: Basic)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];


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

[apiInstance apiCommoditiesListListWithCompletionHandler: 
              ^(array[Commodities] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var InternalTraceSenseApi = require('internal___trace_sense_api');
var defaultClient = InternalTraceSenseApi.ApiClient.instance;

// Configure HTTP basic authorization: Basic
var Basic = defaultClient.authentications['Basic'];
Basic.username = 'YOUR USERNAME'
Basic.password = 'YOUR PASSWORD'

var api = new InternalTraceSenseApi.ApiApi()

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

namespace Example
{
    public class apiCommoditiesListListExample
    {
        public void main()
        {
            
            // Configure HTTP basic authorization: Basic
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new ApiApi();

            try
            {
                array[Commodities] result = apiInstance.apiCommoditiesListList();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ApiApi.apiCommoditiesListList: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: Basic
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

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

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

# Configure HTTP basic authorization: Basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

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

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

# Configure HTTP basic authorization: Basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

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

try: 
    api_response = api_instance.api_commodities_list_list()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ApiApi->apiCommoditiesListList: %s\n" % e)

Parameters

Responses

Status: 200 -


apiCommoditiesListSuppliersList


/api/commodities/list/suppliers/

Usage and SDK Samples

curl -X GET -H "Accept: application/json" -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://127.0.0.1:8000/api/commodities/list/suppliers/"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ApiApi;

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

public class ApiApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: Basic
        HttpBasicAuth Basic = (HttpBasicAuth) defaultClient.getAuthentication("Basic");
        Basic.setUsername("YOUR USERNAME");
        Basic.setPassword("YOUR PASSWORD");

        ApiApi apiInstance = new ApiApi();
        try {
            array[Suppliers] result = apiInstance.apiCommoditiesListSuppliersList();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiApi#apiCommoditiesListSuppliersList");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.ApiApi;

public class ApiApiExample {

    public static void main(String[] args) {
        ApiApi apiInstance = new ApiApi();
        try {
            array[Suppliers] result = apiInstance.apiCommoditiesListSuppliersList();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiApi#apiCommoditiesListSuppliersList");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: Basic)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];


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

[apiInstance apiCommoditiesListSuppliersListWithCompletionHandler: 
              ^(array[Suppliers] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var InternalTraceSenseApi = require('internal___trace_sense_api');
var defaultClient = InternalTraceSenseApi.ApiClient.instance;

// Configure HTTP basic authorization: Basic
var Basic = defaultClient.authentications['Basic'];
Basic.username = 'YOUR USERNAME'
Basic.password = 'YOUR PASSWORD'

var api = new InternalTraceSenseApi.ApiApi()

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

namespace Example
{
    public class apiCommoditiesListSuppliersListExample
    {
        public void main()
        {
            
            // Configure HTTP basic authorization: Basic
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new ApiApi();

            try
            {
                array[Suppliers] result = apiInstance.apiCommoditiesListSuppliersList();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ApiApi.apiCommoditiesListSuppliersList: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: Basic
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

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

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

# Configure HTTP basic authorization: Basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

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

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

# Configure HTTP basic authorization: Basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

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

try: 
    api_response = api_instance.api_commodities_list_suppliers_list()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ApiApi->apiCommoditiesListSuppliersList: %s\n" % e)

Parameters

Responses

Status: 200 -


apiCommoditiesSupplierAddCsvCreate

Checks relevant directory and inserts data into database


/api/commodities/supplier/add/csv/

Usage and SDK Samples

curl -X POST -H "Accept: application/json" -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://127.0.0.1:8000/api/commodities/supplier/add/csv/"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ApiApi;

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

public class ApiApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: Basic
        HttpBasicAuth Basic = (HttpBasicAuth) defaultClient.getAuthentication("Basic");
        Basic.setUsername("YOUR USERNAME");
        Basic.setPassword("YOUR PASSWORD");

        ApiApi apiInstance = new ApiApi();
        try {
            apiInstance.apiCommoditiesSupplierAddCsvCreate();
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiApi#apiCommoditiesSupplierAddCsvCreate");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.ApiApi;

public class ApiApiExample {

    public static void main(String[] args) {
        ApiApi apiInstance = new ApiApi();
        try {
            apiInstance.apiCommoditiesSupplierAddCsvCreate();
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiApi#apiCommoditiesSupplierAddCsvCreate");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: Basic)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];


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

[apiInstance apiCommoditiesSupplierAddCsvCreateWithCompletionHandler: 
              ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var InternalTraceSenseApi = require('internal___trace_sense_api');
var defaultClient = InternalTraceSenseApi.ApiClient.instance;

// Configure HTTP basic authorization: Basic
var Basic = defaultClient.authentications['Basic'];
Basic.username = 'YOUR USERNAME'
Basic.password = 'YOUR PASSWORD'

var api = new InternalTraceSenseApi.ApiApi()

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

namespace Example
{
    public class apiCommoditiesSupplierAddCsvCreateExample
    {
        public void main()
        {
            
            // Configure HTTP basic authorization: Basic
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new ApiApi();

            try
            {
                apiInstance.apiCommoditiesSupplierAddCsvCreate();
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ApiApi.apiCommoditiesSupplierAddCsvCreate: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: Basic
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

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

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

# Configure HTTP basic authorization: Basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

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

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

# Configure HTTP basic authorization: Basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

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

try: 
    api_instance.api_commodities_supplier_add_csv_create()
except ApiException as e:
    print("Exception when calling ApiApi->apiCommoditiesSupplierAddCsvCreate: %s\n" % e)

Parameters

Responses

Status: 201 -


apiCommoditiesSupplierCreate


/api/commodities/supplier/

Usage and SDK Samples

curl -X POST -H "Accept: application/json" -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://127.0.0.1:8000/api/commodities/supplier/"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ApiApi;

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

public class ApiApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: Basic
        HttpBasicAuth Basic = (HttpBasicAuth) defaultClient.getAuthentication("Basic");
        Basic.setUsername("YOUR USERNAME");
        Basic.setPassword("YOUR PASSWORD");

        ApiApi apiInstance = new ApiApi();
        Suppliers data = ; // Suppliers | 
        try {
            Suppliers result = apiInstance.apiCommoditiesSupplierCreate(data);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiApi#apiCommoditiesSupplierCreate");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.ApiApi;

public class ApiApiExample {

    public static void main(String[] args) {
        ApiApi apiInstance = new ApiApi();
        Suppliers data = ; // Suppliers | 
        try {
            Suppliers result = apiInstance.apiCommoditiesSupplierCreate(data);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiApi#apiCommoditiesSupplierCreate");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: Basic)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

Suppliers *data = ; // 

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

[apiInstance apiCommoditiesSupplierCreateWith:data
              completionHandler: ^(Suppliers output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var InternalTraceSenseApi = require('internal___trace_sense_api');
var defaultClient = InternalTraceSenseApi.ApiClient.instance;

// Configure HTTP basic authorization: Basic
var Basic = defaultClient.authentications['Basic'];
Basic.username = 'YOUR USERNAME'
Basic.password = 'YOUR PASSWORD'

var api = new InternalTraceSenseApi.ApiApi()

var data = ; // {Suppliers} 


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

namespace Example
{
    public class apiCommoditiesSupplierCreateExample
    {
        public void main()
        {
            
            // Configure HTTP basic authorization: Basic
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new ApiApi();
            var data = new Suppliers(); // Suppliers | 

            try
            {
                Suppliers result = apiInstance.apiCommoditiesSupplierCreate(data);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ApiApi.apiCommoditiesSupplierCreate: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: Basic
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\Api\ApiApi();
$data = ; // Suppliers | 

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

# Configure HTTP basic authorization: Basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::ApiApi->new();
my $data = WWW::SwaggerClient::Object::Suppliers->new(); # Suppliers | 

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

# Configure HTTP basic authorization: Basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.ApiApi()
data =  # Suppliers | 

try: 
    api_response = api_instance.api_commodities_supplier_create(data)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ApiApi->apiCommoditiesSupplierCreate: %s\n" % e)

Parameters

Body parameters
Name Description
data *

Responses

Status: 201 -


apiCommoditiesSupplierList


/api/commodities/supplier/

Usage and SDK Samples

curl -X GET -H "Accept: application/json" -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://127.0.0.1:8000/api/commodities/supplier/?page="
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ApiApi;

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

public class ApiApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: Basic
        HttpBasicAuth Basic = (HttpBasicAuth) defaultClient.getAuthentication("Basic");
        Basic.setUsername("YOUR USERNAME");
        Basic.setPassword("YOUR PASSWORD");

        ApiApi apiInstance = new ApiApi();
        Integer page = 56; // Integer | A page number within the paginated result set.
        try {
            inline_response_200_1 result = apiInstance.apiCommoditiesSupplierList(page);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiApi#apiCommoditiesSupplierList");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.ApiApi;

public class ApiApiExample {

    public static void main(String[] args) {
        ApiApi apiInstance = new ApiApi();
        Integer page = 56; // Integer | A page number within the paginated result set.
        try {
            inline_response_200_1 result = apiInstance.apiCommoditiesSupplierList(page);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiApi#apiCommoditiesSupplierList");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: Basic)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

Integer *page = 56; // A page number within the paginated result set. (optional)

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

[apiInstance apiCommoditiesSupplierListWith:page
              completionHandler: ^(inline_response_200_1 output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var InternalTraceSenseApi = require('internal___trace_sense_api');
var defaultClient = InternalTraceSenseApi.ApiClient.instance;

// Configure HTTP basic authorization: Basic
var Basic = defaultClient.authentications['Basic'];
Basic.username = 'YOUR USERNAME'
Basic.password = 'YOUR PASSWORD'

var api = new InternalTraceSenseApi.ApiApi()

var opts = { 
  'page': 56 // {Integer} A page number within the paginated result set.
};

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

namespace Example
{
    public class apiCommoditiesSupplierListExample
    {
        public void main()
        {
            
            // Configure HTTP basic authorization: Basic
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new ApiApi();
            var page = 56;  // Integer | A page number within the paginated result set. (optional) 

            try
            {
                inline_response_200_1 result = apiInstance.apiCommoditiesSupplierList(page);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ApiApi.apiCommoditiesSupplierList: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: Basic
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\Api\ApiApi();
$page = 56; // Integer | A page number within the paginated result set.

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

# Configure HTTP basic authorization: Basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::ApiApi->new();
my $page = 56; # Integer | A page number within the paginated result set.

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

# Configure HTTP basic authorization: Basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.ApiApi()
page = 56 # Integer | A page number within the paginated result set. (optional)

try: 
    api_response = api_instance.api_commodities_supplier_list(page=page)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ApiApi->apiCommoditiesSupplierList: %s\n" % e)

Parameters

Query parameters
Name Description
page
Integer
A page number within the paginated result set.

Responses

Status: 200 -


apiDispatchListCustomersList


/api/dispatch/list/customers/

Usage and SDK Samples

curl -X GET -H "Accept: application/json" -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://127.0.0.1:8000/api/dispatch/list/customers/"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ApiApi;

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

public class ApiApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: Basic
        HttpBasicAuth Basic = (HttpBasicAuth) defaultClient.getAuthentication("Basic");
        Basic.setUsername("YOUR USERNAME");
        Basic.setPassword("YOUR PASSWORD");

        ApiApi apiInstance = new ApiApi();
        try {
            array[Customers] result = apiInstance.apiDispatchListCustomersList();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiApi#apiDispatchListCustomersList");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.ApiApi;

public class ApiApiExample {

    public static void main(String[] args) {
        ApiApi apiInstance = new ApiApi();
        try {
            array[Customers] result = apiInstance.apiDispatchListCustomersList();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiApi#apiDispatchListCustomersList");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: Basic)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];


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

[apiInstance apiDispatchListCustomersListWithCompletionHandler: 
              ^(array[Customers] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var InternalTraceSenseApi = require('internal___trace_sense_api');
var defaultClient = InternalTraceSenseApi.ApiClient.instance;

// Configure HTTP basic authorization: Basic
var Basic = defaultClient.authentications['Basic'];
Basic.username = 'YOUR USERNAME'
Basic.password = 'YOUR PASSWORD'

var api = new InternalTraceSenseApi.ApiApi()

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

namespace Example
{
    public class apiDispatchListCustomersListExample
    {
        public void main()
        {
            
            // Configure HTTP basic authorization: Basic
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new ApiApi();

            try
            {
                array[Customers] result = apiInstance.apiDispatchListCustomersList();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ApiApi.apiDispatchListCustomersList: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: Basic
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

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

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

# Configure HTTP basic authorization: Basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

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

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

# Configure HTTP basic authorization: Basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

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

try: 
    api_response = api_instance.api_dispatch_list_customers_list()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ApiApi->apiDispatchListCustomersList: %s\n" % e)

Parameters

Responses

Status: 200 -


apiDispatchListSalesOrdersList


/api/dispatch/list/sales/orders/

Usage and SDK Samples

curl -X GET -H "Accept: application/json" -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://127.0.0.1:8000/api/dispatch/list/sales/orders/"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ApiApi;

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

public class ApiApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: Basic
        HttpBasicAuth Basic = (HttpBasicAuth) defaultClient.getAuthentication("Basic");
        Basic.setUsername("YOUR USERNAME");
        Basic.setPassword("YOUR PASSWORD");

        ApiApi apiInstance = new ApiApi();
        try {
            array[SalesOrderHeader] result = apiInstance.apiDispatchListSalesOrdersList();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiApi#apiDispatchListSalesOrdersList");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.ApiApi;

public class ApiApiExample {

    public static void main(String[] args) {
        ApiApi apiInstance = new ApiApi();
        try {
            array[SalesOrderHeader] result = apiInstance.apiDispatchListSalesOrdersList();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiApi#apiDispatchListSalesOrdersList");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: Basic)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];


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

[apiInstance apiDispatchListSalesOrdersListWithCompletionHandler: 
              ^(array[SalesOrderHeader] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var InternalTraceSenseApi = require('internal___trace_sense_api');
var defaultClient = InternalTraceSenseApi.ApiClient.instance;

// Configure HTTP basic authorization: Basic
var Basic = defaultClient.authentications['Basic'];
Basic.username = 'YOUR USERNAME'
Basic.password = 'YOUR PASSWORD'

var api = new InternalTraceSenseApi.ApiApi()

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

namespace Example
{
    public class apiDispatchListSalesOrdersListExample
    {
        public void main()
        {
            
            // Configure HTTP basic authorization: Basic
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new ApiApi();

            try
            {
                array[SalesOrderHeader] result = apiInstance.apiDispatchListSalesOrdersList();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ApiApi.apiDispatchListSalesOrdersList: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: Basic
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

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

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

# Configure HTTP basic authorization: Basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

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

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

# Configure HTTP basic authorization: Basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

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

try: 
    api_response = api_instance.api_dispatch_list_sales_orders_list()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ApiApi->apiDispatchListSalesOrdersList: %s\n" % e)

Parameters

Responses

Status: 200 -


apiDispatchSalesOrderDetailsList


/api/dispatch/sales/order/details/

Usage and SDK Samples

curl -X GET -H "Accept: application/json" -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://127.0.0.1:8000/api/dispatch/sales/order/details/"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ApiApi;

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

public class ApiApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: Basic
        HttpBasicAuth Basic = (HttpBasicAuth) defaultClient.getAuthentication("Basic");
        Basic.setUsername("YOUR USERNAME");
        Basic.setPassword("YOUR PASSWORD");

        ApiApi apiInstance = new ApiApi();
        try {
            array[SalesOrderDetail] result = apiInstance.apiDispatchSalesOrderDetailsList();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiApi#apiDispatchSalesOrderDetailsList");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.ApiApi;

public class ApiApiExample {

    public static void main(String[] args) {
        ApiApi apiInstance = new ApiApi();
        try {
            array[SalesOrderDetail] result = apiInstance.apiDispatchSalesOrderDetailsList();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiApi#apiDispatchSalesOrderDetailsList");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: Basic)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];


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

[apiInstance apiDispatchSalesOrderDetailsListWithCompletionHandler: 
              ^(array[SalesOrderDetail] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var InternalTraceSenseApi = require('internal___trace_sense_api');
var defaultClient = InternalTraceSenseApi.ApiClient.instance;

// Configure HTTP basic authorization: Basic
var Basic = defaultClient.authentications['Basic'];
Basic.username = 'YOUR USERNAME'
Basic.password = 'YOUR PASSWORD'

var api = new InternalTraceSenseApi.ApiApi()

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

namespace Example
{
    public class apiDispatchSalesOrderDetailsListExample
    {
        public void main()
        {
            
            // Configure HTTP basic authorization: Basic
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new ApiApi();

            try
            {
                array[SalesOrderDetail] result = apiInstance.apiDispatchSalesOrderDetailsList();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ApiApi.apiDispatchSalesOrderDetailsList: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: Basic
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

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

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

# Configure HTTP basic authorization: Basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

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

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

# Configure HTTP basic authorization: Basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

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

try: 
    api_response = api_instance.api_dispatch_sales_order_details_list()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ApiApi->apiDispatchSalesOrderDetailsList: %s\n" % e)

Parameters

Responses

Status: 200 -


apiDispatchV1SalesordersCreate

Checks relevant directory and inserts data into database


/api/dispatch/v1/salesorders/

Usage and SDK Samples

curl -X POST -H "Accept: application/json" -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://127.0.0.1:8000/api/dispatch/v1/salesorders/"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ApiApi;

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

public class ApiApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: Basic
        HttpBasicAuth Basic = (HttpBasicAuth) defaultClient.getAuthentication("Basic");
        Basic.setUsername("YOUR USERNAME");
        Basic.setPassword("YOUR PASSWORD");

        ApiApi apiInstance = new ApiApi();
        try {
            apiInstance.apiDispatchV1SalesordersCreate();
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiApi#apiDispatchV1SalesordersCreate");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.ApiApi;

public class ApiApiExample {

    public static void main(String[] args) {
        ApiApi apiInstance = new ApiApi();
        try {
            apiInstance.apiDispatchV1SalesordersCreate();
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiApi#apiDispatchV1SalesordersCreate");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: Basic)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];


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

[apiInstance apiDispatchV1SalesordersCreateWithCompletionHandler: 
              ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var InternalTraceSenseApi = require('internal___trace_sense_api');
var defaultClient = InternalTraceSenseApi.ApiClient.instance;

// Configure HTTP basic authorization: Basic
var Basic = defaultClient.authentications['Basic'];
Basic.username = 'YOUR USERNAME'
Basic.password = 'YOUR PASSWORD'

var api = new InternalTraceSenseApi.ApiApi()

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

namespace Example
{
    public class apiDispatchV1SalesordersCreateExample
    {
        public void main()
        {
            
            // Configure HTTP basic authorization: Basic
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new ApiApi();

            try
            {
                apiInstance.apiDispatchV1SalesordersCreate();
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ApiApi.apiDispatchV1SalesordersCreate: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: Basic
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

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

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

# Configure HTTP basic authorization: Basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

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

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

# Configure HTTP basic authorization: Basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

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

try: 
    api_instance.api_dispatch_v1_salesorders_create()
except ApiException as e:
    print("Exception when calling ApiApi->apiDispatchV1SalesordersCreate: %s\n" % e)

Parameters

Responses

Status: 201 -


apiDocumentsUploadCreate


/api/documents/upload/

Usage and SDK Samples

curl -X POST -H "Accept: application/json" -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://127.0.0.1:8000/api/documents/upload/"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ApiApi;

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

public class ApiApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: Basic
        HttpBasicAuth Basic = (HttpBasicAuth) defaultClient.getAuthentication("Basic");
        Basic.setUsername("YOUR USERNAME");
        Basic.setPassword("YOUR PASSWORD");

        ApiApi apiInstance = new ApiApi();
        try {
            apiInstance.apiDocumentsUploadCreate();
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiApi#apiDocumentsUploadCreate");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.ApiApi;

public class ApiApiExample {

    public static void main(String[] args) {
        ApiApi apiInstance = new ApiApi();
        try {
            apiInstance.apiDocumentsUploadCreate();
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiApi#apiDocumentsUploadCreate");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: Basic)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];


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

[apiInstance apiDocumentsUploadCreateWithCompletionHandler: 
              ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var InternalTraceSenseApi = require('internal___trace_sense_api');
var defaultClient = InternalTraceSenseApi.ApiClient.instance;

// Configure HTTP basic authorization: Basic
var Basic = defaultClient.authentications['Basic'];
Basic.username = 'YOUR USERNAME'
Basic.password = 'YOUR PASSWORD'

var api = new InternalTraceSenseApi.ApiApi()

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

namespace Example
{
    public class apiDocumentsUploadCreateExample
    {
        public void main()
        {
            
            // Configure HTTP basic authorization: Basic
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new ApiApi();

            try
            {
                apiInstance.apiDocumentsUploadCreate();
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ApiApi.apiDocumentsUploadCreate: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: Basic
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

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

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

# Configure HTTP basic authorization: Basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

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

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

# Configure HTTP basic authorization: Basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

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

try: 
    api_instance.api_documents_upload_create()
except ApiException as e:
    print("Exception when calling ApiApi->apiDocumentsUploadCreate: %s\n" % e)

Parameters

Responses

Status: 201 -


apiJobListHeadersList


/api/job/list/headers/

Usage and SDK Samples

curl -X GET -H "Accept: application/json" -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://127.0.0.1:8000/api/job/list/headers/"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ApiApi;

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

public class ApiApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: Basic
        HttpBasicAuth Basic = (HttpBasicAuth) defaultClient.getAuthentication("Basic");
        Basic.setUsername("YOUR USERNAME");
        Basic.setPassword("YOUR PASSWORD");

        ApiApi apiInstance = new ApiApi();
        try {
            array[JobHeader] result = apiInstance.apiJobListHeadersList();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiApi#apiJobListHeadersList");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.ApiApi;

public class ApiApiExample {

    public static void main(String[] args) {
        ApiApi apiInstance = new ApiApi();
        try {
            array[JobHeader] result = apiInstance.apiJobListHeadersList();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiApi#apiJobListHeadersList");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: Basic)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];


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

[apiInstance apiJobListHeadersListWithCompletionHandler: 
              ^(array[JobHeader] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var InternalTraceSenseApi = require('internal___trace_sense_api');
var defaultClient = InternalTraceSenseApi.ApiClient.instance;

// Configure HTTP basic authorization: Basic
var Basic = defaultClient.authentications['Basic'];
Basic.username = 'YOUR USERNAME'
Basic.password = 'YOUR PASSWORD'

var api = new InternalTraceSenseApi.ApiApi()

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

namespace Example
{
    public class apiJobListHeadersListExample
    {
        public void main()
        {
            
            // Configure HTTP basic authorization: Basic
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new ApiApi();

            try
            {
                array[JobHeader] result = apiInstance.apiJobListHeadersList();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ApiApi.apiJobListHeadersList: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: Basic
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

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

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

# Configure HTTP basic authorization: Basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

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

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

# Configure HTTP basic authorization: Basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

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

try: 
    api_response = api_instance.api_job_list_headers_list()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ApiApi->apiJobListHeadersList: %s\n" % e)

Parameters

Responses

Status: 200 -


apiMaintenancesPlannedTasksCreate


/api/maintenances/planned-tasks/

Usage and SDK Samples

curl -X POST -H "Accept: application/json" -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://127.0.0.1:8000/api/maintenances/planned-tasks/"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ApiApi;

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

public class ApiApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: Basic
        HttpBasicAuth Basic = (HttpBasicAuth) defaultClient.getAuthentication("Basic");
        Basic.setUsername("YOUR USERNAME");
        Basic.setPassword("YOUR PASSWORD");

        ApiApi apiInstance = new ApiApi();
        PlannedTaskCreate data = ; // PlannedTaskCreate | 
        try {
            PlannedTaskCreate result = apiInstance.apiMaintenancesPlannedTasksCreate(data);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiApi#apiMaintenancesPlannedTasksCreate");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.ApiApi;

public class ApiApiExample {

    public static void main(String[] args) {
        ApiApi apiInstance = new ApiApi();
        PlannedTaskCreate data = ; // PlannedTaskCreate | 
        try {
            PlannedTaskCreate result = apiInstance.apiMaintenancesPlannedTasksCreate(data);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiApi#apiMaintenancesPlannedTasksCreate");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: Basic)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

PlannedTaskCreate *data = ; // 

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

[apiInstance apiMaintenancesPlannedTasksCreateWith:data
              completionHandler: ^(PlannedTaskCreate output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var InternalTraceSenseApi = require('internal___trace_sense_api');
var defaultClient = InternalTraceSenseApi.ApiClient.instance;

// Configure HTTP basic authorization: Basic
var Basic = defaultClient.authentications['Basic'];
Basic.username = 'YOUR USERNAME'
Basic.password = 'YOUR PASSWORD'

var api = new InternalTraceSenseApi.ApiApi()

var data = ; // {PlannedTaskCreate} 


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

namespace Example
{
    public class apiMaintenancesPlannedTasksCreateExample
    {
        public void main()
        {
            
            // Configure HTTP basic authorization: Basic
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new ApiApi();
            var data = new PlannedTaskCreate(); // PlannedTaskCreate | 

            try
            {
                PlannedTaskCreate result = apiInstance.apiMaintenancesPlannedTasksCreate(data);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ApiApi.apiMaintenancesPlannedTasksCreate: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: Basic
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\Api\ApiApi();
$data = ; // PlannedTaskCreate | 

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

# Configure HTTP basic authorization: Basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::ApiApi->new();
my $data = WWW::SwaggerClient::Object::PlannedTaskCreate->new(); # PlannedTaskCreate | 

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

# Configure HTTP basic authorization: Basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.ApiApi()
data =  # PlannedTaskCreate | 

try: 
    api_response = api_instance.api_maintenances_planned_tasks_create(data)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ApiApi->apiMaintenancesPlannedTasksCreate: %s\n" % e)

Parameters

Body parameters
Name Description
data *

Responses

Status: 201 -


apiMaintenancesPlannedTasksDelete


/api/maintenances/planned-tasks/{id}/

Usage and SDK Samples

curl -X DELETE -H "Accept: application/json" -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://127.0.0.1:8000/api/maintenances/planned-tasks/{id}/"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ApiApi;

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

public class ApiApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: Basic
        HttpBasicAuth Basic = (HttpBasicAuth) defaultClient.getAuthentication("Basic");
        Basic.setUsername("YOUR USERNAME");
        Basic.setPassword("YOUR PASSWORD");

        ApiApi apiInstance = new ApiApi();
        String id = id_example; // String | 
        try {
            apiInstance.apiMaintenancesPlannedTasksDelete(id);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiApi#apiMaintenancesPlannedTasksDelete");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.ApiApi;

public class ApiApiExample {

    public static void main(String[] args) {
        ApiApi apiInstance = new ApiApi();
        String id = id_example; // String | 
        try {
            apiInstance.apiMaintenancesPlannedTasksDelete(id);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiApi#apiMaintenancesPlannedTasksDelete");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: Basic)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

String *id = id_example; // 

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

[apiInstance apiMaintenancesPlannedTasksDeleteWith:id
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var InternalTraceSenseApi = require('internal___trace_sense_api');
var defaultClient = InternalTraceSenseApi.ApiClient.instance;

// Configure HTTP basic authorization: Basic
var Basic = defaultClient.authentications['Basic'];
Basic.username = 'YOUR USERNAME'
Basic.password = 'YOUR PASSWORD'

var api = new InternalTraceSenseApi.ApiApi()

var id = id_example; // {String} 


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

namespace Example
{
    public class apiMaintenancesPlannedTasksDeleteExample
    {
        public void main()
        {
            
            // Configure HTTP basic authorization: Basic
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new ApiApi();
            var id = id_example;  // String | 

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

// Configure HTTP basic authorization: Basic
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\Api\ApiApi();
$id = id_example; // String | 

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

# Configure HTTP basic authorization: Basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::ApiApi->new();
my $id = id_example; # String | 

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

# Configure HTTP basic authorization: Basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.ApiApi()
id = id_example # String | 

try: 
    api_instance.api_maintenances_planned_tasks_delete(id)
except ApiException as e:
    print("Exception when calling ApiApi->apiMaintenancesPlannedTasksDelete: %s\n" % e)

Parameters

Path parameters
Name Description
id*
String
Required

Responses

Status: 204 -


apiMaintenancesPlannedTasksList


/api/maintenances/planned-tasks/

Usage and SDK Samples

curl -X GET -H "Accept: application/json" -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://127.0.0.1:8000/api/maintenances/planned-tasks/"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ApiApi;

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

public class ApiApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: Basic
        HttpBasicAuth Basic = (HttpBasicAuth) defaultClient.getAuthentication("Basic");
        Basic.setUsername("YOUR USERNAME");
        Basic.setPassword("YOUR PASSWORD");

        ApiApi apiInstance = new ApiApi();
        try {
            array[PlannedTask] result = apiInstance.apiMaintenancesPlannedTasksList();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiApi#apiMaintenancesPlannedTasksList");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.ApiApi;

public class ApiApiExample {

    public static void main(String[] args) {
        ApiApi apiInstance = new ApiApi();
        try {
            array[PlannedTask] result = apiInstance.apiMaintenancesPlannedTasksList();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiApi#apiMaintenancesPlannedTasksList");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: Basic)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];


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

[apiInstance apiMaintenancesPlannedTasksListWithCompletionHandler: 
              ^(array[PlannedTask] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var InternalTraceSenseApi = require('internal___trace_sense_api');
var defaultClient = InternalTraceSenseApi.ApiClient.instance;

// Configure HTTP basic authorization: Basic
var Basic = defaultClient.authentications['Basic'];
Basic.username = 'YOUR USERNAME'
Basic.password = 'YOUR PASSWORD'

var api = new InternalTraceSenseApi.ApiApi()

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

namespace Example
{
    public class apiMaintenancesPlannedTasksListExample
    {
        public void main()
        {
            
            // Configure HTTP basic authorization: Basic
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new ApiApi();

            try
            {
                array[PlannedTask] result = apiInstance.apiMaintenancesPlannedTasksList();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ApiApi.apiMaintenancesPlannedTasksList: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: Basic
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

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

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

# Configure HTTP basic authorization: Basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

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

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

# Configure HTTP basic authorization: Basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

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

try: 
    api_response = api_instance.api_maintenances_planned_tasks_list()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ApiApi->apiMaintenancesPlannedTasksList: %s\n" % e)

Parameters

Responses

Status: 200 -


apiMaintenancesPlannedTasksPartialUpdate


/api/maintenances/planned-tasks/{id}/

Usage and SDK Samples

curl -X PATCH -H "Accept: application/json" -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://127.0.0.1:8000/api/maintenances/planned-tasks/{id}/"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ApiApi;

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

public class ApiApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: Basic
        HttpBasicAuth Basic = (HttpBasicAuth) defaultClient.getAuthentication("Basic");
        Basic.setUsername("YOUR USERNAME");
        Basic.setPassword("YOUR PASSWORD");

        ApiApi apiInstance = new ApiApi();
        String id = id_example; // String | 
        PlannedTaskCreate data = ; // PlannedTaskCreate | 
        try {
            PlannedTaskCreate result = apiInstance.apiMaintenancesPlannedTasksPartialUpdate(id, data);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiApi#apiMaintenancesPlannedTasksPartialUpdate");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.ApiApi;

public class ApiApiExample {

    public static void main(String[] args) {
        ApiApi apiInstance = new ApiApi();
        String id = id_example; // String | 
        PlannedTaskCreate data = ; // PlannedTaskCreate | 
        try {
            PlannedTaskCreate result = apiInstance.apiMaintenancesPlannedTasksPartialUpdate(id, data);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiApi#apiMaintenancesPlannedTasksPartialUpdate");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: Basic)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

String *id = id_example; // 
PlannedTaskCreate *data = ; // 

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

[apiInstance apiMaintenancesPlannedTasksPartialUpdateWith:id
    data:data
              completionHandler: ^(PlannedTaskCreate output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var InternalTraceSenseApi = require('internal___trace_sense_api');
var defaultClient = InternalTraceSenseApi.ApiClient.instance;

// Configure HTTP basic authorization: Basic
var Basic = defaultClient.authentications['Basic'];
Basic.username = 'YOUR USERNAME'
Basic.password = 'YOUR PASSWORD'

var api = new InternalTraceSenseApi.ApiApi()

var id = id_example; // {String} 

var data = ; // {PlannedTaskCreate} 


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

namespace Example
{
    public class apiMaintenancesPlannedTasksPartialUpdateExample
    {
        public void main()
        {
            
            // Configure HTTP basic authorization: Basic
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new ApiApi();
            var id = id_example;  // String | 
            var data = new PlannedTaskCreate(); // PlannedTaskCreate | 

            try
            {
                PlannedTaskCreate result = apiInstance.apiMaintenancesPlannedTasksPartialUpdate(id, data);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ApiApi.apiMaintenancesPlannedTasksPartialUpdate: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: Basic
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\Api\ApiApi();
$id = id_example; // String | 
$data = ; // PlannedTaskCreate | 

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

# Configure HTTP basic authorization: Basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::ApiApi->new();
my $id = id_example; # String | 
my $data = WWW::SwaggerClient::Object::PlannedTaskCreate->new(); # PlannedTaskCreate | 

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

# Configure HTTP basic authorization: Basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.ApiApi()
id = id_example # String | 
data =  # PlannedTaskCreate | 

try: 
    api_response = api_instance.api_maintenances_planned_tasks_partial_update(id, data)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ApiApi->apiMaintenancesPlannedTasksPartialUpdate: %s\n" % e)

Parameters

Path parameters
Name Description
id*
String
Required
Body parameters
Name Description
data *

Responses

Status: 200 -


apiMaintenancesPlannedTasksRead


/api/maintenances/planned-tasks/{id}/

Usage and SDK Samples

curl -X GET -H "Accept: application/json" -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://127.0.0.1:8000/api/maintenances/planned-tasks/{id}/"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ApiApi;

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

public class ApiApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: Basic
        HttpBasicAuth Basic = (HttpBasicAuth) defaultClient.getAuthentication("Basic");
        Basic.setUsername("YOUR USERNAME");
        Basic.setPassword("YOUR PASSWORD");

        ApiApi apiInstance = new ApiApi();
        String id = id_example; // String | 
        try {
            PlannedTask result = apiInstance.apiMaintenancesPlannedTasksRead(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiApi#apiMaintenancesPlannedTasksRead");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.ApiApi;

public class ApiApiExample {

    public static void main(String[] args) {
        ApiApi apiInstance = new ApiApi();
        String id = id_example; // String | 
        try {
            PlannedTask result = apiInstance.apiMaintenancesPlannedTasksRead(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiApi#apiMaintenancesPlannedTasksRead");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: Basic)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

String *id = id_example; // 

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

[apiInstance apiMaintenancesPlannedTasksReadWith:id
              completionHandler: ^(PlannedTask output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var InternalTraceSenseApi = require('internal___trace_sense_api');
var defaultClient = InternalTraceSenseApi.ApiClient.instance;

// Configure HTTP basic authorization: Basic
var Basic = defaultClient.authentications['Basic'];
Basic.username = 'YOUR USERNAME'
Basic.password = 'YOUR PASSWORD'

var api = new InternalTraceSenseApi.ApiApi()

var id = id_example; // {String} 


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

namespace Example
{
    public class apiMaintenancesPlannedTasksReadExample
    {
        public void main()
        {
            
            // Configure HTTP basic authorization: Basic
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new ApiApi();
            var id = id_example;  // String | 

            try
            {
                PlannedTask result = apiInstance.apiMaintenancesPlannedTasksRead(id);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ApiApi.apiMaintenancesPlannedTasksRead: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: Basic
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\Api\ApiApi();
$id = id_example; // String | 

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

# Configure HTTP basic authorization: Basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::ApiApi->new();
my $id = id_example; # String | 

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

# Configure HTTP basic authorization: Basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.ApiApi()
id = id_example # String | 

try: 
    api_response = api_instance.api_maintenances_planned_tasks_read(id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ApiApi->apiMaintenancesPlannedTasksRead: %s\n" % e)

Parameters

Path parameters
Name Description
id*
String
Required

Responses

Status: 200 -


apiMaintenancesPlannedTasksUpdate


/api/maintenances/planned-tasks/{id}/

Usage and SDK Samples

curl -X PUT -H "Accept: application/json" -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://127.0.0.1:8000/api/maintenances/planned-tasks/{id}/"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ApiApi;

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

public class ApiApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: Basic
        HttpBasicAuth Basic = (HttpBasicAuth) defaultClient.getAuthentication("Basic");
        Basic.setUsername("YOUR USERNAME");
        Basic.setPassword("YOUR PASSWORD");

        ApiApi apiInstance = new ApiApi();
        String id = id_example; // String | 
        PlannedTaskCreate data = ; // PlannedTaskCreate | 
        try {
            PlannedTaskCreate result = apiInstance.apiMaintenancesPlannedTasksUpdate(id, data);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiApi#apiMaintenancesPlannedTasksUpdate");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.ApiApi;

public class ApiApiExample {

    public static void main(String[] args) {
        ApiApi apiInstance = new ApiApi();
        String id = id_example; // String | 
        PlannedTaskCreate data = ; // PlannedTaskCreate | 
        try {
            PlannedTaskCreate result = apiInstance.apiMaintenancesPlannedTasksUpdate(id, data);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiApi#apiMaintenancesPlannedTasksUpdate");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: Basic)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

String *id = id_example; // 
PlannedTaskCreate *data = ; // 

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

[apiInstance apiMaintenancesPlannedTasksUpdateWith:id
    data:data
              completionHandler: ^(PlannedTaskCreate output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var InternalTraceSenseApi = require('internal___trace_sense_api');
var defaultClient = InternalTraceSenseApi.ApiClient.instance;

// Configure HTTP basic authorization: Basic
var Basic = defaultClient.authentications['Basic'];
Basic.username = 'YOUR USERNAME'
Basic.password = 'YOUR PASSWORD'

var api = new InternalTraceSenseApi.ApiApi()

var id = id_example; // {String} 

var data = ; // {PlannedTaskCreate} 


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

namespace Example
{
    public class apiMaintenancesPlannedTasksUpdateExample
    {
        public void main()
        {
            
            // Configure HTTP basic authorization: Basic
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new ApiApi();
            var id = id_example;  // String | 
            var data = new PlannedTaskCreate(); // PlannedTaskCreate | 

            try
            {
                PlannedTaskCreate result = apiInstance.apiMaintenancesPlannedTasksUpdate(id, data);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ApiApi.apiMaintenancesPlannedTasksUpdate: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: Basic
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\Api\ApiApi();
$id = id_example; // String | 
$data = ; // PlannedTaskCreate | 

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

# Configure HTTP basic authorization: Basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::ApiApi->new();
my $id = id_example; # String | 
my $data = WWW::SwaggerClient::Object::PlannedTaskCreate->new(); # PlannedTaskCreate | 

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

# Configure HTTP basic authorization: Basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.ApiApi()
id = id_example # String | 
data =  # PlannedTaskCreate | 

try: 
    api_response = api_instance.api_maintenances_planned_tasks_update(id, data)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ApiApi->apiMaintenancesPlannedTasksUpdate: %s\n" % e)

Parameters

Path parameters
Name Description
id*
String
Required
Body parameters
Name Description
data *

Responses

Status: 200 -


apiMaintenancesSchedulesCreate


/api/maintenances/schedules/

Usage and SDK Samples

curl -X POST -H "Accept: application/json" -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://127.0.0.1:8000/api/maintenances/schedules/"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ApiApi;

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

public class ApiApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: Basic
        HttpBasicAuth Basic = (HttpBasicAuth) defaultClient.getAuthentication("Basic");
        Basic.setUsername("YOUR USERNAME");
        Basic.setPassword("YOUR PASSWORD");

        ApiApi apiInstance = new ApiApi();
        Schedule data = ; // Schedule | 
        try {
            Schedule result = apiInstance.apiMaintenancesSchedulesCreate(data);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiApi#apiMaintenancesSchedulesCreate");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.ApiApi;

public class ApiApiExample {

    public static void main(String[] args) {
        ApiApi apiInstance = new ApiApi();
        Schedule data = ; // Schedule | 
        try {
            Schedule result = apiInstance.apiMaintenancesSchedulesCreate(data);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiApi#apiMaintenancesSchedulesCreate");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: Basic)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

Schedule *data = ; // 

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

[apiInstance apiMaintenancesSchedulesCreateWith:data
              completionHandler: ^(Schedule output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var InternalTraceSenseApi = require('internal___trace_sense_api');
var defaultClient = InternalTraceSenseApi.ApiClient.instance;

// Configure HTTP basic authorization: Basic
var Basic = defaultClient.authentications['Basic'];
Basic.username = 'YOUR USERNAME'
Basic.password = 'YOUR PASSWORD'

var api = new InternalTraceSenseApi.ApiApi()

var data = ; // {Schedule} 


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

namespace Example
{
    public class apiMaintenancesSchedulesCreateExample
    {
        public void main()
        {
            
            // Configure HTTP basic authorization: Basic
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new ApiApi();
            var data = new Schedule(); // Schedule | 

            try
            {
                Schedule result = apiInstance.apiMaintenancesSchedulesCreate(data);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ApiApi.apiMaintenancesSchedulesCreate: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: Basic
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\Api\ApiApi();
$data = ; // Schedule | 

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

# Configure HTTP basic authorization: Basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::ApiApi->new();
my $data = WWW::SwaggerClient::Object::Schedule->new(); # Schedule | 

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

# Configure HTTP basic authorization: Basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.ApiApi()
data =  # Schedule | 

try: 
    api_response = api_instance.api_maintenances_schedules_create(data)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ApiApi->apiMaintenancesSchedulesCreate: %s\n" % e)

Parameters

Body parameters
Name Description
data *

Responses

Status: 201 -


apiMaintenancesSchedulesDelete


/api/maintenances/schedules/{id}/

Usage and SDK Samples

curl -X DELETE -H "Accept: application/json" -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://127.0.0.1:8000/api/maintenances/schedules/{id}/"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ApiApi;

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

public class ApiApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: Basic
        HttpBasicAuth Basic = (HttpBasicAuth) defaultClient.getAuthentication("Basic");
        Basic.setUsername("YOUR USERNAME");
        Basic.setPassword("YOUR PASSWORD");

        ApiApi apiInstance = new ApiApi();
        String id = id_example; // String | 
        try {
            apiInstance.apiMaintenancesSchedulesDelete(id);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiApi#apiMaintenancesSchedulesDelete");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.ApiApi;

public class ApiApiExample {

    public static void main(String[] args) {
        ApiApi apiInstance = new ApiApi();
        String id = id_example; // String | 
        try {
            apiInstance.apiMaintenancesSchedulesDelete(id);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiApi#apiMaintenancesSchedulesDelete");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: Basic)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

String *id = id_example; // 

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

[apiInstance apiMaintenancesSchedulesDeleteWith:id
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var InternalTraceSenseApi = require('internal___trace_sense_api');
var defaultClient = InternalTraceSenseApi.ApiClient.instance;

// Configure HTTP basic authorization: Basic
var Basic = defaultClient.authentications['Basic'];
Basic.username = 'YOUR USERNAME'
Basic.password = 'YOUR PASSWORD'

var api = new InternalTraceSenseApi.ApiApi()

var id = id_example; // {String} 


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

namespace Example
{
    public class apiMaintenancesSchedulesDeleteExample
    {
        public void main()
        {
            
            // Configure HTTP basic authorization: Basic
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new ApiApi();
            var id = id_example;  // String | 

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

// Configure HTTP basic authorization: Basic
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\Api\ApiApi();
$id = id_example; // String | 

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

# Configure HTTP basic authorization: Basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::ApiApi->new();
my $id = id_example; # String | 

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

# Configure HTTP basic authorization: Basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.ApiApi()
id = id_example # String | 

try: 
    api_instance.api_maintenances_schedules_delete(id)
except ApiException as e:
    print("Exception when calling ApiApi->apiMaintenancesSchedulesDelete: %s\n" % e)

Parameters

Path parameters
Name Description
id*
String
Required

Responses

Status: 204 -


apiMaintenancesSchedulesList


/api/maintenances/schedules/

Usage and SDK Samples

curl -X GET -H "Accept: application/json" -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://127.0.0.1:8000/api/maintenances/schedules/"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ApiApi;

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

public class ApiApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: Basic
        HttpBasicAuth Basic = (HttpBasicAuth) defaultClient.getAuthentication("Basic");
        Basic.setUsername("YOUR USERNAME");
        Basic.setPassword("YOUR PASSWORD");

        ApiApi apiInstance = new ApiApi();
        try {
            array[Schedule] result = apiInstance.apiMaintenancesSchedulesList();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiApi#apiMaintenancesSchedulesList");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.ApiApi;

public class ApiApiExample {

    public static void main(String[] args) {
        ApiApi apiInstance = new ApiApi();
        try {
            array[Schedule] result = apiInstance.apiMaintenancesSchedulesList();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiApi#apiMaintenancesSchedulesList");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: Basic)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];


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

[apiInstance apiMaintenancesSchedulesListWithCompletionHandler: 
              ^(array[Schedule] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var InternalTraceSenseApi = require('internal___trace_sense_api');
var defaultClient = InternalTraceSenseApi.ApiClient.instance;

// Configure HTTP basic authorization: Basic
var Basic = defaultClient.authentications['Basic'];
Basic.username = 'YOUR USERNAME'
Basic.password = 'YOUR PASSWORD'

var api = new InternalTraceSenseApi.ApiApi()

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

namespace Example
{
    public class apiMaintenancesSchedulesListExample
    {
        public void main()
        {
            
            // Configure HTTP basic authorization: Basic
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new ApiApi();

            try
            {
                array[Schedule] result = apiInstance.apiMaintenancesSchedulesList();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ApiApi.apiMaintenancesSchedulesList: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: Basic
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

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

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

# Configure HTTP basic authorization: Basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

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

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

# Configure HTTP basic authorization: Basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

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

try: 
    api_response = api_instance.api_maintenances_schedules_list()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ApiApi->apiMaintenancesSchedulesList: %s\n" % e)

Parameters

Responses

Status: 200 -


apiMaintenancesSchedulesPartialUpdate


/api/maintenances/schedules/{id}/

Usage and SDK Samples

curl -X PATCH -H "Accept: application/json" -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://127.0.0.1:8000/api/maintenances/schedules/{id}/"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ApiApi;

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

public class ApiApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: Basic
        HttpBasicAuth Basic = (HttpBasicAuth) defaultClient.getAuthentication("Basic");
        Basic.setUsername("YOUR USERNAME");
        Basic.setPassword("YOUR PASSWORD");

        ApiApi apiInstance = new ApiApi();
        String id = id_example; // String | 
        Schedule data = ; // Schedule | 
        try {
            Schedule result = apiInstance.apiMaintenancesSchedulesPartialUpdate(id, data);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiApi#apiMaintenancesSchedulesPartialUpdate");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.ApiApi;

public class ApiApiExample {

    public static void main(String[] args) {
        ApiApi apiInstance = new ApiApi();
        String id = id_example; // String | 
        Schedule data = ; // Schedule | 
        try {
            Schedule result = apiInstance.apiMaintenancesSchedulesPartialUpdate(id, data);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiApi#apiMaintenancesSchedulesPartialUpdate");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: Basic)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

String *id = id_example; // 
Schedule *data = ; // 

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

[apiInstance apiMaintenancesSchedulesPartialUpdateWith:id
    data:data
              completionHandler: ^(Schedule output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var InternalTraceSenseApi = require('internal___trace_sense_api');
var defaultClient = InternalTraceSenseApi.ApiClient.instance;

// Configure HTTP basic authorization: Basic
var Basic = defaultClient.authentications['Basic'];
Basic.username = 'YOUR USERNAME'
Basic.password = 'YOUR PASSWORD'

var api = new InternalTraceSenseApi.ApiApi()

var id = id_example; // {String} 

var data = ; // {Schedule} 


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

namespace Example
{
    public class apiMaintenancesSchedulesPartialUpdateExample
    {
        public void main()
        {
            
            // Configure HTTP basic authorization: Basic
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new ApiApi();
            var id = id_example;  // String | 
            var data = new Schedule(); // Schedule | 

            try
            {
                Schedule result = apiInstance.apiMaintenancesSchedulesPartialUpdate(id, data);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ApiApi.apiMaintenancesSchedulesPartialUpdate: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: Basic
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\Api\ApiApi();
$id = id_example; // String | 
$data = ; // Schedule | 

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

# Configure HTTP basic authorization: Basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::ApiApi->new();
my $id = id_example; # String | 
my $data = WWW::SwaggerClient::Object::Schedule->new(); # Schedule | 

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

# Configure HTTP basic authorization: Basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.ApiApi()
id = id_example # String | 
data =  # Schedule | 

try: 
    api_response = api_instance.api_maintenances_schedules_partial_update(id, data)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ApiApi->apiMaintenancesSchedulesPartialUpdate: %s\n" % e)

Parameters

Path parameters
Name Description
id*
String
Required
Body parameters
Name Description
data *

Responses

Status: 200 -


apiMaintenancesSchedulesRead


/api/maintenances/schedules/{id}/

Usage and SDK Samples

curl -X GET -H "Accept: application/json" -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://127.0.0.1:8000/api/maintenances/schedules/{id}/"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ApiApi;

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

public class ApiApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: Basic
        HttpBasicAuth Basic = (HttpBasicAuth) defaultClient.getAuthentication("Basic");
        Basic.setUsername("YOUR USERNAME");
        Basic.setPassword("YOUR PASSWORD");

        ApiApi apiInstance = new ApiApi();
        String id = id_example; // String | 
        try {
            Schedule result = apiInstance.apiMaintenancesSchedulesRead(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiApi#apiMaintenancesSchedulesRead");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.ApiApi;

public class ApiApiExample {

    public static void main(String[] args) {
        ApiApi apiInstance = new ApiApi();
        String id = id_example; // String | 
        try {
            Schedule result = apiInstance.apiMaintenancesSchedulesRead(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiApi#apiMaintenancesSchedulesRead");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: Basic)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

String *id = id_example; // 

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

[apiInstance apiMaintenancesSchedulesReadWith:id
              completionHandler: ^(Schedule output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var InternalTraceSenseApi = require('internal___trace_sense_api');
var defaultClient = InternalTraceSenseApi.ApiClient.instance;

// Configure HTTP basic authorization: Basic
var Basic = defaultClient.authentications['Basic'];
Basic.username = 'YOUR USERNAME'
Basic.password = 'YOUR PASSWORD'

var api = new InternalTraceSenseApi.ApiApi()

var id = id_example; // {String} 


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

namespace Example
{
    public class apiMaintenancesSchedulesReadExample
    {
        public void main()
        {
            
            // Configure HTTP basic authorization: Basic
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new ApiApi();
            var id = id_example;  // String | 

            try
            {
                Schedule result = apiInstance.apiMaintenancesSchedulesRead(id);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ApiApi.apiMaintenancesSchedulesRead: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: Basic
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\Api\ApiApi();
$id = id_example; // String | 

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

# Configure HTTP basic authorization: Basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::ApiApi->new();
my $id = id_example; # String | 

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

# Configure HTTP basic authorization: Basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.ApiApi()
id = id_example # String | 

try: 
    api_response = api_instance.api_maintenances_schedules_read(id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ApiApi->apiMaintenancesSchedulesRead: %s\n" % e)

Parameters

Path parameters
Name Description
id*
String
Required

Responses

Status: 200 -


apiMaintenancesSchedulesUpdate


/api/maintenances/schedules/{id}/

Usage and SDK Samples

curl -X PUT -H "Accept: application/json" -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://127.0.0.1:8000/api/maintenances/schedules/{id}/"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ApiApi;

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

public class ApiApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: Basic
        HttpBasicAuth Basic = (HttpBasicAuth) defaultClient.getAuthentication("Basic");
        Basic.setUsername("YOUR USERNAME");
        Basic.setPassword("YOUR PASSWORD");

        ApiApi apiInstance = new ApiApi();
        String id = id_example; // String | 
        Schedule data = ; // Schedule | 
        try {
            Schedule result = apiInstance.apiMaintenancesSchedulesUpdate(id, data);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiApi#apiMaintenancesSchedulesUpdate");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.ApiApi;

public class ApiApiExample {

    public static void main(String[] args) {
        ApiApi apiInstance = new ApiApi();
        String id = id_example; // String | 
        Schedule data = ; // Schedule | 
        try {
            Schedule result = apiInstance.apiMaintenancesSchedulesUpdate(id, data);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiApi#apiMaintenancesSchedulesUpdate");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: Basic)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

String *id = id_example; // 
Schedule *data = ; // 

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

[apiInstance apiMaintenancesSchedulesUpdateWith:id
    data:data
              completionHandler: ^(Schedule output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var InternalTraceSenseApi = require('internal___trace_sense_api');
var defaultClient = InternalTraceSenseApi.ApiClient.instance;

// Configure HTTP basic authorization: Basic
var Basic = defaultClient.authentications['Basic'];
Basic.username = 'YOUR USERNAME'
Basic.password = 'YOUR PASSWORD'

var api = new InternalTraceSenseApi.ApiApi()

var id = id_example; // {String} 

var data = ; // {Schedule} 


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

namespace Example
{
    public class apiMaintenancesSchedulesUpdateExample
    {
        public void main()
        {
            
            // Configure HTTP basic authorization: Basic
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new ApiApi();
            var id = id_example;  // String | 
            var data = new Schedule(); // Schedule | 

            try
            {
                Schedule result = apiInstance.apiMaintenancesSchedulesUpdate(id, data);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ApiApi.apiMaintenancesSchedulesUpdate: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: Basic
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\Api\ApiApi();
$id = id_example; // String | 
$data = ; // Schedule | 

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

# Configure HTTP basic authorization: Basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::ApiApi->new();
my $id = id_example; # String | 
my $data = WWW::SwaggerClient::Object::Schedule->new(); # Schedule | 

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

# Configure HTTP basic authorization: Basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.ApiApi()
id = id_example # String | 
data =  # Schedule | 

try: 
    api_response = api_instance.api_maintenances_schedules_update(id, data)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ApiApi->apiMaintenancesSchedulesUpdate: %s\n" % e)

Parameters

Path parameters
Name Description
id*
String
Required
Body parameters
Name Description
data *

Responses

Status: 200 -


apiMaintenancesTaskColorsCreate


/api/maintenances/task-colors/

Usage and SDK Samples

curl -X POST -H "Accept: application/json" -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://127.0.0.1:8000/api/maintenances/task-colors/"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ApiApi;

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

public class ApiApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: Basic
        HttpBasicAuth Basic = (HttpBasicAuth) defaultClient.getAuthentication("Basic");
        Basic.setUsername("YOUR USERNAME");
        Basic.setPassword("YOUR PASSWORD");

        ApiApi apiInstance = new ApiApi();
        try {
            apiInstance.apiMaintenancesTaskColorsCreate();
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiApi#apiMaintenancesTaskColorsCreate");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.ApiApi;

public class ApiApiExample {

    public static void main(String[] args) {
        ApiApi apiInstance = new ApiApi();
        try {
            apiInstance.apiMaintenancesTaskColorsCreate();
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiApi#apiMaintenancesTaskColorsCreate");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: Basic)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];


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

[apiInstance apiMaintenancesTaskColorsCreateWithCompletionHandler: 
              ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var InternalTraceSenseApi = require('internal___trace_sense_api');
var defaultClient = InternalTraceSenseApi.ApiClient.instance;

// Configure HTTP basic authorization: Basic
var Basic = defaultClient.authentications['Basic'];
Basic.username = 'YOUR USERNAME'
Basic.password = 'YOUR PASSWORD'

var api = new InternalTraceSenseApi.ApiApi()

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

namespace Example
{
    public class apiMaintenancesTaskColorsCreateExample
    {
        public void main()
        {
            
            // Configure HTTP basic authorization: Basic
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new ApiApi();

            try
            {
                apiInstance.apiMaintenancesTaskColorsCreate();
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ApiApi.apiMaintenancesTaskColorsCreate: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: Basic
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

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

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

# Configure HTTP basic authorization: Basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

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

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

# Configure HTTP basic authorization: Basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

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

try: 
    api_instance.api_maintenances_task_colors_create()
except ApiException as e:
    print("Exception when calling ApiApi->apiMaintenancesTaskColorsCreate: %s\n" % e)

Parameters

Responses

Status: 201 -


apiMaintenancesTaskColorsList


/api/maintenances/task-colors/

Usage and SDK Samples

curl -X GET -H "Accept: application/json" -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://127.0.0.1:8000/api/maintenances/task-colors/"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ApiApi;

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

public class ApiApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: Basic
        HttpBasicAuth Basic = (HttpBasicAuth) defaultClient.getAuthentication("Basic");
        Basic.setUsername("YOUR USERNAME");
        Basic.setPassword("YOUR PASSWORD");

        ApiApi apiInstance = new ApiApi();
        try {
            apiInstance.apiMaintenancesTaskColorsList();
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiApi#apiMaintenancesTaskColorsList");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.ApiApi;

public class ApiApiExample {

    public static void main(String[] args) {
        ApiApi apiInstance = new ApiApi();
        try {
            apiInstance.apiMaintenancesTaskColorsList();
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiApi#apiMaintenancesTaskColorsList");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: Basic)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];


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

[apiInstance apiMaintenancesTaskColorsListWithCompletionHandler: 
              ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var InternalTraceSenseApi = require('internal___trace_sense_api');
var defaultClient = InternalTraceSenseApi.ApiClient.instance;

// Configure HTTP basic authorization: Basic
var Basic = defaultClient.authentications['Basic'];
Basic.username = 'YOUR USERNAME'
Basic.password = 'YOUR PASSWORD'

var api = new InternalTraceSenseApi.ApiApi()

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

namespace Example
{
    public class apiMaintenancesTaskColorsListExample
    {
        public void main()
        {
            
            // Configure HTTP basic authorization: Basic
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new ApiApi();

            try
            {
                apiInstance.apiMaintenancesTaskColorsList();
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ApiApi.apiMaintenancesTaskColorsList: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: Basic
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

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

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

# Configure HTTP basic authorization: Basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

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

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

# Configure HTTP basic authorization: Basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

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

try: 
    api_instance.api_maintenances_task_colors_list()
except ApiException as e:
    print("Exception when calling ApiApi->apiMaintenancesTaskColorsList: %s\n" % e)

Parameters

Responses

Status: 200 -


apiMaintenancesUnplannedTasksCreate


/api/maintenances/unplanned-tasks/

Usage and SDK Samples

curl -X POST -H "Accept: application/json" -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://127.0.0.1:8000/api/maintenances/unplanned-tasks/"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ApiApi;

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

public class ApiApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: Basic
        HttpBasicAuth Basic = (HttpBasicAuth) defaultClient.getAuthentication("Basic");
        Basic.setUsername("YOUR USERNAME");
        Basic.setPassword("YOUR PASSWORD");

        ApiApi apiInstance = new ApiApi();
        UnplannedTask data = ; // UnplannedTask | 
        try {
            UnplannedTask result = apiInstance.apiMaintenancesUnplannedTasksCreate(data);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiApi#apiMaintenancesUnplannedTasksCreate");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.ApiApi;

public class ApiApiExample {

    public static void main(String[] args) {
        ApiApi apiInstance = new ApiApi();
        UnplannedTask data = ; // UnplannedTask | 
        try {
            UnplannedTask result = apiInstance.apiMaintenancesUnplannedTasksCreate(data);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiApi#apiMaintenancesUnplannedTasksCreate");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: Basic)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

UnplannedTask *data = ; // 

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

[apiInstance apiMaintenancesUnplannedTasksCreateWith:data
              completionHandler: ^(UnplannedTask output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var InternalTraceSenseApi = require('internal___trace_sense_api');
var defaultClient = InternalTraceSenseApi.ApiClient.instance;

// Configure HTTP basic authorization: Basic
var Basic = defaultClient.authentications['Basic'];
Basic.username = 'YOUR USERNAME'
Basic.password = 'YOUR PASSWORD'

var api = new InternalTraceSenseApi.ApiApi()

var data = ; // {UnplannedTask} 


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

namespace Example
{
    public class apiMaintenancesUnplannedTasksCreateExample
    {
        public void main()
        {
            
            // Configure HTTP basic authorization: Basic
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new ApiApi();
            var data = new UnplannedTask(); // UnplannedTask | 

            try
            {
                UnplannedTask result = apiInstance.apiMaintenancesUnplannedTasksCreate(data);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ApiApi.apiMaintenancesUnplannedTasksCreate: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: Basic
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\Api\ApiApi();
$data = ; // UnplannedTask | 

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

# Configure HTTP basic authorization: Basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::ApiApi->new();
my $data = WWW::SwaggerClient::Object::UnplannedTask->new(); # UnplannedTask | 

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

# Configure HTTP basic authorization: Basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.ApiApi()
data =  # UnplannedTask | 

try: 
    api_response = api_instance.api_maintenances_unplanned_tasks_create(data)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ApiApi->apiMaintenancesUnplannedTasksCreate: %s\n" % e)

Parameters

Body parameters
Name Description
data *

Responses

Status: 201 -


apiMaintenancesUnplannedTasksDelete


/api/maintenances/unplanned-tasks/{id}/

Usage and SDK Samples

curl -X DELETE -H "Accept: application/json" -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://127.0.0.1:8000/api/maintenances/unplanned-tasks/{id}/"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ApiApi;

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

public class ApiApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: Basic
        HttpBasicAuth Basic = (HttpBasicAuth) defaultClient.getAuthentication("Basic");
        Basic.setUsername("YOUR USERNAME");
        Basic.setPassword("YOUR PASSWORD");

        ApiApi apiInstance = new ApiApi();
        String id = id_example; // String | 
        try {
            apiInstance.apiMaintenancesUnplannedTasksDelete(id);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiApi#apiMaintenancesUnplannedTasksDelete");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.ApiApi;

public class ApiApiExample {

    public static void main(String[] args) {
        ApiApi apiInstance = new ApiApi();
        String id = id_example; // String | 
        try {
            apiInstance.apiMaintenancesUnplannedTasksDelete(id);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiApi#apiMaintenancesUnplannedTasksDelete");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: Basic)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

String *id = id_example; // 

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

[apiInstance apiMaintenancesUnplannedTasksDeleteWith:id
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var InternalTraceSenseApi = require('internal___trace_sense_api');
var defaultClient = InternalTraceSenseApi.ApiClient.instance;

// Configure HTTP basic authorization: Basic
var Basic = defaultClient.authentications['Basic'];
Basic.username = 'YOUR USERNAME'
Basic.password = 'YOUR PASSWORD'

var api = new InternalTraceSenseApi.ApiApi()

var id = id_example; // {String} 


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

namespace Example
{
    public class apiMaintenancesUnplannedTasksDeleteExample
    {
        public void main()
        {
            
            // Configure HTTP basic authorization: Basic
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new ApiApi();
            var id = id_example;  // String | 

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

// Configure HTTP basic authorization: Basic
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\Api\ApiApi();
$id = id_example; // String | 

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

# Configure HTTP basic authorization: Basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::ApiApi->new();
my $id = id_example; # String | 

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

# Configure HTTP basic authorization: Basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.ApiApi()
id = id_example # String | 

try: 
    api_instance.api_maintenances_unplanned_tasks_delete(id)
except ApiException as e:
    print("Exception when calling ApiApi->apiMaintenancesUnplannedTasksDelete: %s\n" % e)

Parameters

Path parameters
Name Description
id*
String
Required

Responses

Status: 204 -


apiMaintenancesUnplannedTasksList


/api/maintenances/unplanned-tasks/

Usage and SDK Samples

curl -X GET -H "Accept: application/json" -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://127.0.0.1:8000/api/maintenances/unplanned-tasks/"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ApiApi;

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

public class ApiApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: Basic
        HttpBasicAuth Basic = (HttpBasicAuth) defaultClient.getAuthentication("Basic");
        Basic.setUsername("YOUR USERNAME");
        Basic.setPassword("YOUR PASSWORD");

        ApiApi apiInstance = new ApiApi();
        try {
            array[UnplannedTask] result = apiInstance.apiMaintenancesUnplannedTasksList();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiApi#apiMaintenancesUnplannedTasksList");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.ApiApi;

public class ApiApiExample {

    public static void main(String[] args) {
        ApiApi apiInstance = new ApiApi();
        try {
            array[UnplannedTask] result = apiInstance.apiMaintenancesUnplannedTasksList();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiApi#apiMaintenancesUnplannedTasksList");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: Basic)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];


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

[apiInstance apiMaintenancesUnplannedTasksListWithCompletionHandler: 
              ^(array[UnplannedTask] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var InternalTraceSenseApi = require('internal___trace_sense_api');
var defaultClient = InternalTraceSenseApi.ApiClient.instance;

// Configure HTTP basic authorization: Basic
var Basic = defaultClient.authentications['Basic'];
Basic.username = 'YOUR USERNAME'
Basic.password = 'YOUR PASSWORD'

var api = new InternalTraceSenseApi.ApiApi()

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

namespace Example
{
    public class apiMaintenancesUnplannedTasksListExample
    {
        public void main()
        {
            
            // Configure HTTP basic authorization: Basic
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new ApiApi();

            try
            {
                array[UnplannedTask] result = apiInstance.apiMaintenancesUnplannedTasksList();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ApiApi.apiMaintenancesUnplannedTasksList: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: Basic
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

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

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

# Configure HTTP basic authorization: Basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

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

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

# Configure HTTP basic authorization: Basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

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

try: 
    api_response = api_instance.api_maintenances_unplanned_tasks_list()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ApiApi->apiMaintenancesUnplannedTasksList: %s\n" % e)

Parameters

Responses

Status: 200 -


apiMaintenancesUnplannedTasksPartialUpdate


/api/maintenances/unplanned-tasks/{id}/

Usage and SDK Samples

curl -X PATCH -H "Accept: application/json" -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://127.0.0.1:8000/api/maintenances/unplanned-tasks/{id}/"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ApiApi;

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

public class ApiApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: Basic
        HttpBasicAuth Basic = (HttpBasicAuth) defaultClient.getAuthentication("Basic");
        Basic.setUsername("YOUR USERNAME");
        Basic.setPassword("YOUR PASSWORD");

        ApiApi apiInstance = new ApiApi();
        String id = id_example; // String | 
        UnplannedTask data = ; // UnplannedTask | 
        try {
            UnplannedTask result = apiInstance.apiMaintenancesUnplannedTasksPartialUpdate(id, data);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiApi#apiMaintenancesUnplannedTasksPartialUpdate");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.ApiApi;

public class ApiApiExample {

    public static void main(String[] args) {
        ApiApi apiInstance = new ApiApi();
        String id = id_example; // String | 
        UnplannedTask data = ; // UnplannedTask | 
        try {
            UnplannedTask result = apiInstance.apiMaintenancesUnplannedTasksPartialUpdate(id, data);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiApi#apiMaintenancesUnplannedTasksPartialUpdate");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: Basic)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

String *id = id_example; // 
UnplannedTask *data = ; // 

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

[apiInstance apiMaintenancesUnplannedTasksPartialUpdateWith:id
    data:data
              completionHandler: ^(UnplannedTask output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var InternalTraceSenseApi = require('internal___trace_sense_api');
var defaultClient = InternalTraceSenseApi.ApiClient.instance;

// Configure HTTP basic authorization: Basic
var Basic = defaultClient.authentications['Basic'];
Basic.username = 'YOUR USERNAME'
Basic.password = 'YOUR PASSWORD'

var api = new InternalTraceSenseApi.ApiApi()

var id = id_example; // {String} 

var data = ; // {UnplannedTask} 


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

namespace Example
{
    public class apiMaintenancesUnplannedTasksPartialUpdateExample
    {
        public void main()
        {
            
            // Configure HTTP basic authorization: Basic
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new ApiApi();
            var id = id_example;  // String | 
            var data = new UnplannedTask(); // UnplannedTask | 

            try
            {
                UnplannedTask result = apiInstance.apiMaintenancesUnplannedTasksPartialUpdate(id, data);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ApiApi.apiMaintenancesUnplannedTasksPartialUpdate: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: Basic
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\Api\ApiApi();
$id = id_example; // String | 
$data = ; // UnplannedTask | 

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

# Configure HTTP basic authorization: Basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::ApiApi->new();
my $id = id_example; # String | 
my $data = WWW::SwaggerClient::Object::UnplannedTask->new(); # UnplannedTask | 

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

# Configure HTTP basic authorization: Basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.ApiApi()
id = id_example # String | 
data =  # UnplannedTask | 

try: 
    api_response = api_instance.api_maintenances_unplanned_tasks_partial_update(id, data)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ApiApi->apiMaintenancesUnplannedTasksPartialUpdate: %s\n" % e)

Parameters

Path parameters
Name Description
id*
String
Required
Body parameters
Name Description
data *

Responses

Status: 200 -


apiMaintenancesUnplannedTasksRead


/api/maintenances/unplanned-tasks/{id}/

Usage and SDK Samples

curl -X GET -H "Accept: application/json" -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://127.0.0.1:8000/api/maintenances/unplanned-tasks/{id}/"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ApiApi;

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

public class ApiApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: Basic
        HttpBasicAuth Basic = (HttpBasicAuth) defaultClient.getAuthentication("Basic");
        Basic.setUsername("YOUR USERNAME");
        Basic.setPassword("YOUR PASSWORD");

        ApiApi apiInstance = new ApiApi();
        String id = id_example; // String | 
        try {
            UnplannedTask result = apiInstance.apiMaintenancesUnplannedTasksRead(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiApi#apiMaintenancesUnplannedTasksRead");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.ApiApi;

public class ApiApiExample {

    public static void main(String[] args) {
        ApiApi apiInstance = new ApiApi();
        String id = id_example; // String | 
        try {
            UnplannedTask result = apiInstance.apiMaintenancesUnplannedTasksRead(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiApi#apiMaintenancesUnplannedTasksRead");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: Basic)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

String *id = id_example; // 

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

[apiInstance apiMaintenancesUnplannedTasksReadWith:id
              completionHandler: ^(UnplannedTask output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var InternalTraceSenseApi = require('internal___trace_sense_api');
var defaultClient = InternalTraceSenseApi.ApiClient.instance;

// Configure HTTP basic authorization: Basic
var Basic = defaultClient.authentications['Basic'];
Basic.username = 'YOUR USERNAME'
Basic.password = 'YOUR PASSWORD'

var api = new InternalTraceSenseApi.ApiApi()

var id = id_example; // {String} 


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

namespace Example
{
    public class apiMaintenancesUnplannedTasksReadExample
    {
        public void main()
        {
            
            // Configure HTTP basic authorization: Basic
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new ApiApi();
            var id = id_example;  // String | 

            try
            {
                UnplannedTask result = apiInstance.apiMaintenancesUnplannedTasksRead(id);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ApiApi.apiMaintenancesUnplannedTasksRead: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: Basic
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\Api\ApiApi();
$id = id_example; // String | 

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

# Configure HTTP basic authorization: Basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::ApiApi->new();
my $id = id_example; # String | 

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

# Configure HTTP basic authorization: Basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.ApiApi()
id = id_example # String | 

try: 
    api_response = api_instance.api_maintenances_unplanned_tasks_read(id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ApiApi->apiMaintenancesUnplannedTasksRead: %s\n" % e)

Parameters

Path parameters
Name Description
id*
String
Required

Responses

Status: 200 -


apiMaintenancesUnplannedTasksUpdate


/api/maintenances/unplanned-tasks/{id}/

Usage and SDK Samples

curl -X PUT -H "Accept: application/json" -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://127.0.0.1:8000/api/maintenances/unplanned-tasks/{id}/"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ApiApi;

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

public class ApiApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: Basic
        HttpBasicAuth Basic = (HttpBasicAuth) defaultClient.getAuthentication("Basic");
        Basic.setUsername("YOUR USERNAME");
        Basic.setPassword("YOUR PASSWORD");

        ApiApi apiInstance = new ApiApi();
        String id = id_example; // String | 
        UnplannedTask data = ; // UnplannedTask | 
        try {
            UnplannedTask result = apiInstance.apiMaintenancesUnplannedTasksUpdate(id, data);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiApi#apiMaintenancesUnplannedTasksUpdate");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.ApiApi;

public class ApiApiExample {

    public static void main(String[] args) {
        ApiApi apiInstance = new ApiApi();
        String id = id_example; // String | 
        UnplannedTask data = ; // UnplannedTask | 
        try {
            UnplannedTask result = apiInstance.apiMaintenancesUnplannedTasksUpdate(id, data);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiApi#apiMaintenancesUnplannedTasksUpdate");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: Basic)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

String *id = id_example; // 
UnplannedTask *data = ; // 

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

[apiInstance apiMaintenancesUnplannedTasksUpdateWith:id
    data:data
              completionHandler: ^(UnplannedTask output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var InternalTraceSenseApi = require('internal___trace_sense_api');
var defaultClient = InternalTraceSenseApi.ApiClient.instance;

// Configure HTTP basic authorization: Basic
var Basic = defaultClient.authentications['Basic'];
Basic.username = 'YOUR USERNAME'
Basic.password = 'YOUR PASSWORD'

var api = new InternalTraceSenseApi.ApiApi()

var id = id_example; // {String} 

var data = ; // {UnplannedTask} 


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

namespace Example
{
    public class apiMaintenancesUnplannedTasksUpdateExample
    {
        public void main()
        {
            
            // Configure HTTP basic authorization: Basic
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new ApiApi();
            var id = id_example;  // String | 
            var data = new UnplannedTask(); // UnplannedTask | 

            try
            {
                UnplannedTask result = apiInstance.apiMaintenancesUnplannedTasksUpdate(id, data);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ApiApi.apiMaintenancesUnplannedTasksUpdate: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: Basic
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\Api\ApiApi();
$id = id_example; // String | 
$data = ; // UnplannedTask | 

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

# Configure HTTP basic authorization: Basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::ApiApi->new();
my $id = id_example; # String | 
my $data = WWW::SwaggerClient::Object::UnplannedTask->new(); # UnplannedTask | 

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

# Configure HTTP basic authorization: Basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.ApiApi()
id = id_example # String | 
data =  # UnplannedTask | 

try: 
    api_response = api_instance.api_maintenances_unplanned_tasks_update(id, data)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ApiApi->apiMaintenancesUnplannedTasksUpdate: %s\n" % e)

Parameters

Path parameters
Name Description
id*
String
Required
Body parameters
Name Description
data *

Responses

Status: 200 -


apiMaintenancesWorkOrdersCreate


/api/maintenances/work-orders/

Usage and SDK Samples

curl -X POST -H "Accept: application/json" -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://127.0.0.1:8000/api/maintenances/work-orders/"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ApiApi;

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

public class ApiApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: Basic
        HttpBasicAuth Basic = (HttpBasicAuth) defaultClient.getAuthentication("Basic");
        Basic.setUsername("YOUR USERNAME");
        Basic.setPassword("YOUR PASSWORD");

        ApiApi apiInstance = new ApiApi();
        MaintenanceWorkOrderCreate data = ; // MaintenanceWorkOrderCreate | 
        try {
            MaintenanceWorkOrderCreate result = apiInstance.apiMaintenancesWorkOrdersCreate(data);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiApi#apiMaintenancesWorkOrdersCreate");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.ApiApi;

public class ApiApiExample {

    public static void main(String[] args) {
        ApiApi apiInstance = new ApiApi();
        MaintenanceWorkOrderCreate data = ; // MaintenanceWorkOrderCreate | 
        try {
            MaintenanceWorkOrderCreate result = apiInstance.apiMaintenancesWorkOrdersCreate(data);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiApi#apiMaintenancesWorkOrdersCreate");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: Basic)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

MaintenanceWorkOrderCreate *data = ; // 

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

[apiInstance apiMaintenancesWorkOrdersCreateWith:data
              completionHandler: ^(MaintenanceWorkOrderCreate output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var InternalTraceSenseApi = require('internal___trace_sense_api');
var defaultClient = InternalTraceSenseApi.ApiClient.instance;

// Configure HTTP basic authorization: Basic
var Basic = defaultClient.authentications['Basic'];
Basic.username = 'YOUR USERNAME'
Basic.password = 'YOUR PASSWORD'

var api = new InternalTraceSenseApi.ApiApi()

var data = ; // {MaintenanceWorkOrderCreate} 


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

namespace Example
{
    public class apiMaintenancesWorkOrdersCreateExample
    {
        public void main()
        {
            
            // Configure HTTP basic authorization: Basic
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new ApiApi();
            var data = new MaintenanceWorkOrderCreate(); // MaintenanceWorkOrderCreate | 

            try
            {
                MaintenanceWorkOrderCreate result = apiInstance.apiMaintenancesWorkOrdersCreate(data);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ApiApi.apiMaintenancesWorkOrdersCreate: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: Basic
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\Api\ApiApi();
$data = ; // MaintenanceWorkOrderCreate | 

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

# Configure HTTP basic authorization: Basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::ApiApi->new();
my $data = WWW::SwaggerClient::Object::MaintenanceWorkOrderCreate->new(); # MaintenanceWorkOrderCreate | 

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

# Configure HTTP basic authorization: Basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.ApiApi()
data =  # MaintenanceWorkOrderCreate | 

try: 
    api_response = api_instance.api_maintenances_work_orders_create(data)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ApiApi->apiMaintenancesWorkOrdersCreate: %s\n" % e)

Parameters

Body parameters
Name Description
data *

Responses

Status: 201 -


apiMaintenancesWorkOrdersDelete


/api/maintenances/work-orders/{id}/

Usage and SDK Samples

curl -X DELETE -H "Accept: application/json" -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://127.0.0.1:8000/api/maintenances/work-orders/{id}/"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ApiApi;

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

public class ApiApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: Basic
        HttpBasicAuth Basic = (HttpBasicAuth) defaultClient.getAuthentication("Basic");
        Basic.setUsername("YOUR USERNAME");
        Basic.setPassword("YOUR PASSWORD");

        ApiApi apiInstance = new ApiApi();
        String id = id_example; // String | 
        try {
            apiInstance.apiMaintenancesWorkOrdersDelete(id);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiApi#apiMaintenancesWorkOrdersDelete");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.ApiApi;

public class ApiApiExample {

    public static void main(String[] args) {
        ApiApi apiInstance = new ApiApi();
        String id = id_example; // String | 
        try {
            apiInstance.apiMaintenancesWorkOrdersDelete(id);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiApi#apiMaintenancesWorkOrdersDelete");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: Basic)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

String *id = id_example; // 

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

[apiInstance apiMaintenancesWorkOrdersDeleteWith:id
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var InternalTraceSenseApi = require('internal___trace_sense_api');
var defaultClient = InternalTraceSenseApi.ApiClient.instance;

// Configure HTTP basic authorization: Basic
var Basic = defaultClient.authentications['Basic'];
Basic.username = 'YOUR USERNAME'
Basic.password = 'YOUR PASSWORD'

var api = new InternalTraceSenseApi.ApiApi()

var id = id_example; // {String} 


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

namespace Example
{
    public class apiMaintenancesWorkOrdersDeleteExample
    {
        public void main()
        {
            
            // Configure HTTP basic authorization: Basic
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new ApiApi();
            var id = id_example;  // String | 

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

// Configure HTTP basic authorization: Basic
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\Api\ApiApi();
$id = id_example; // String | 

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

# Configure HTTP basic authorization: Basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::ApiApi->new();
my $id = id_example; # String | 

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

# Configure HTTP basic authorization: Basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.ApiApi()
id = id_example # String | 

try: 
    api_instance.api_maintenances_work_orders_delete(id)
except ApiException as e:
    print("Exception when calling ApiApi->apiMaintenancesWorkOrdersDelete: %s\n" % e)

Parameters

Path parameters
Name Description
id*
String
Required

Responses

Status: 204 -


apiMaintenancesWorkOrdersList


/api/maintenances/work-orders/

Usage and SDK Samples

curl -X GET -H "Accept: application/json" -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://127.0.0.1:8000/api/maintenances/work-orders/"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ApiApi;

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

public class ApiApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: Basic
        HttpBasicAuth Basic = (HttpBasicAuth) defaultClient.getAuthentication("Basic");
        Basic.setUsername("YOUR USERNAME");
        Basic.setPassword("YOUR PASSWORD");

        ApiApi apiInstance = new ApiApi();
        try {
            array[MaintenanceWorkOrder] result = apiInstance.apiMaintenancesWorkOrdersList();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiApi#apiMaintenancesWorkOrdersList");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.ApiApi;

public class ApiApiExample {

    public static void main(String[] args) {
        ApiApi apiInstance = new ApiApi();
        try {
            array[MaintenanceWorkOrder] result = apiInstance.apiMaintenancesWorkOrdersList();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiApi#apiMaintenancesWorkOrdersList");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: Basic)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];


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

[apiInstance apiMaintenancesWorkOrdersListWithCompletionHandler: 
              ^(array[MaintenanceWorkOrder] output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var InternalTraceSenseApi = require('internal___trace_sense_api');
var defaultClient = InternalTraceSenseApi.ApiClient.instance;

// Configure HTTP basic authorization: Basic
var Basic = defaultClient.authentications['Basic'];
Basic.username = 'YOUR USERNAME'
Basic.password = 'YOUR PASSWORD'

var api = new InternalTraceSenseApi.ApiApi()

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

namespace Example
{
    public class apiMaintenancesWorkOrdersListExample
    {
        public void main()
        {
            
            // Configure HTTP basic authorization: Basic
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new ApiApi();

            try
            {
                array[MaintenanceWorkOrder] result = apiInstance.apiMaintenancesWorkOrdersList();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ApiApi.apiMaintenancesWorkOrdersList: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: Basic
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

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

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

# Configure HTTP basic authorization: Basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

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

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

# Configure HTTP basic authorization: Basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

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

try: 
    api_response = api_instance.api_maintenances_work_orders_list()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ApiApi->apiMaintenancesWorkOrdersList: %s\n" % e)

Parameters

Responses

Status: 200 -


apiMaintenancesWorkOrdersPartialUpdate


/api/maintenances/work-orders/{id}/

Usage and SDK Samples

curl -X PATCH -H "Accept: application/json" -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://127.0.0.1:8000/api/maintenances/work-orders/{id}/"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ApiApi;

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

public class ApiApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: Basic
        HttpBasicAuth Basic = (HttpBasicAuth) defaultClient.getAuthentication("Basic");
        Basic.setUsername("YOUR USERNAME");
        Basic.setPassword("YOUR PASSWORD");

        ApiApi apiInstance = new ApiApi();
        String id = id_example; // String | 
        MaintenanceWorkOrderCreate data = ; // MaintenanceWorkOrderCreate | 
        try {
            MaintenanceWorkOrderCreate result = apiInstance.apiMaintenancesWorkOrdersPartialUpdate(id, data);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiApi#apiMaintenancesWorkOrdersPartialUpdate");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.ApiApi;

public class ApiApiExample {

    public static void main(String[] args) {
        ApiApi apiInstance = new ApiApi();
        String id = id_example; // String | 
        MaintenanceWorkOrderCreate data = ; // MaintenanceWorkOrderCreate | 
        try {
            MaintenanceWorkOrderCreate result = apiInstance.apiMaintenancesWorkOrdersPartialUpdate(id, data);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiApi#apiMaintenancesWorkOrdersPartialUpdate");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: Basic)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

String *id = id_example; // 
MaintenanceWorkOrderCreate *data = ; // 

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

[apiInstance apiMaintenancesWorkOrdersPartialUpdateWith:id
    data:data
              completionHandler: ^(MaintenanceWorkOrderCreate output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var InternalTraceSenseApi = require('internal___trace_sense_api');
var defaultClient = InternalTraceSenseApi.ApiClient.instance;

// Configure HTTP basic authorization: Basic
var Basic = defaultClient.authentications['Basic'];
Basic.username = 'YOUR USERNAME'
Basic.password = 'YOUR PASSWORD'

var api = new InternalTraceSenseApi.ApiApi()

var id = id_example; // {String} 

var data = ; // {MaintenanceWorkOrderCreate} 


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

namespace Example
{
    public class apiMaintenancesWorkOrdersPartialUpdateExample
    {
        public void main()
        {
            
            // Configure HTTP basic authorization: Basic
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new ApiApi();
            var id = id_example;  // String | 
            var data = new MaintenanceWorkOrderCreate(); // MaintenanceWorkOrderCreate | 

            try
            {
                MaintenanceWorkOrderCreate result = apiInstance.apiMaintenancesWorkOrdersPartialUpdate(id, data);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ApiApi.apiMaintenancesWorkOrdersPartialUpdate: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: Basic
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\Api\ApiApi();
$id = id_example; // String | 
$data = ; // MaintenanceWorkOrderCreate | 

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

# Configure HTTP basic authorization: Basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::ApiApi->new();
my $id = id_example; # String | 
my $data = WWW::SwaggerClient::Object::MaintenanceWorkOrderCreate->new(); # MaintenanceWorkOrderCreate | 

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

# Configure HTTP basic authorization: Basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.ApiApi()
id = id_example # String | 
data =  # MaintenanceWorkOrderCreate | 

try: 
    api_response = api_instance.api_maintenances_work_orders_partial_update(id, data)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ApiApi->apiMaintenancesWorkOrdersPartialUpdate: %s\n" % e)

Parameters

Path parameters
Name Description
id*
String
Required
Body parameters
Name Description
data *

Responses

Status: 200 -


apiMaintenancesWorkOrdersRead


/api/maintenances/work-orders/{id}/

Usage and SDK Samples

curl -X GET -H "Accept: application/json" -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://127.0.0.1:8000/api/maintenances/work-orders/{id}/"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ApiApi;

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

public class ApiApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: Basic
        HttpBasicAuth Basic = (HttpBasicAuth) defaultClient.getAuthentication("Basic");
        Basic.setUsername("YOUR USERNAME");
        Basic.setPassword("YOUR PASSWORD");

        ApiApi apiInstance = new ApiApi();
        String id = id_example; // String | 
        try {
            MaintenanceWorkOrder result = apiInstance.apiMaintenancesWorkOrdersRead(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiApi#apiMaintenancesWorkOrdersRead");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.ApiApi;

public class ApiApiExample {

    public static void main(String[] args) {
        ApiApi apiInstance = new ApiApi();
        String id = id_example; // String | 
        try {
            MaintenanceWorkOrder result = apiInstance.apiMaintenancesWorkOrdersRead(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiApi#apiMaintenancesWorkOrdersRead");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: Basic)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

String *id = id_example; // 

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

[apiInstance apiMaintenancesWorkOrdersReadWith:id
              completionHandler: ^(MaintenanceWorkOrder output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var InternalTraceSenseApi = require('internal___trace_sense_api');
var defaultClient = InternalTraceSenseApi.ApiClient.instance;

// Configure HTTP basic authorization: Basic
var Basic = defaultClient.authentications['Basic'];
Basic.username = 'YOUR USERNAME'
Basic.password = 'YOUR PASSWORD'

var api = new InternalTraceSenseApi.ApiApi()

var id = id_example; // {String} 


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

namespace Example
{
    public class apiMaintenancesWorkOrdersReadExample
    {
        public void main()
        {
            
            // Configure HTTP basic authorization: Basic
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new ApiApi();
            var id = id_example;  // String | 

            try
            {
                MaintenanceWorkOrder result = apiInstance.apiMaintenancesWorkOrdersRead(id);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ApiApi.apiMaintenancesWorkOrdersRead: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: Basic
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\Api\ApiApi();
$id = id_example; // String | 

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

# Configure HTTP basic authorization: Basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::ApiApi->new();
my $id = id_example; # String | 

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

# Configure HTTP basic authorization: Basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.ApiApi()
id = id_example # String | 

try: 
    api_response = api_instance.api_maintenances_work_orders_read(id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ApiApi->apiMaintenancesWorkOrdersRead: %s\n" % e)

Parameters

Path parameters
Name Description
id*
String
Required

Responses

Status: 200 -


apiMaintenancesWorkOrdersUpdate


/api/maintenances/work-orders/{id}/

Usage and SDK Samples

curl -X PUT -H "Accept: application/json" -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://127.0.0.1:8000/api/maintenances/work-orders/{id}/"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ApiApi;

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

public class ApiApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: Basic
        HttpBasicAuth Basic = (HttpBasicAuth) defaultClient.getAuthentication("Basic");
        Basic.setUsername("YOUR USERNAME");
        Basic.setPassword("YOUR PASSWORD");

        ApiApi apiInstance = new ApiApi();
        String id = id_example; // String | 
        MaintenanceWorkOrderCreate data = ; // MaintenanceWorkOrderCreate | 
        try {
            MaintenanceWorkOrderCreate result = apiInstance.apiMaintenancesWorkOrdersUpdate(id, data);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiApi#apiMaintenancesWorkOrdersUpdate");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.ApiApi;

public class ApiApiExample {

    public static void main(String[] args) {
        ApiApi apiInstance = new ApiApi();
        String id = id_example; // String | 
        MaintenanceWorkOrderCreate data = ; // MaintenanceWorkOrderCreate | 
        try {
            MaintenanceWorkOrderCreate result = apiInstance.apiMaintenancesWorkOrdersUpdate(id, data);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiApi#apiMaintenancesWorkOrdersUpdate");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: Basic)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

String *id = id_example; // 
MaintenanceWorkOrderCreate *data = ; // 

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

[apiInstance apiMaintenancesWorkOrdersUpdateWith:id
    data:data
              completionHandler: ^(MaintenanceWorkOrderCreate output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var InternalTraceSenseApi = require('internal___trace_sense_api');
var defaultClient = InternalTraceSenseApi.ApiClient.instance;

// Configure HTTP basic authorization: Basic
var Basic = defaultClient.authentications['Basic'];
Basic.username = 'YOUR USERNAME'
Basic.password = 'YOUR PASSWORD'

var api = new InternalTraceSenseApi.ApiApi()

var id = id_example; // {String} 

var data = ; // {MaintenanceWorkOrderCreate} 


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

namespace Example
{
    public class apiMaintenancesWorkOrdersUpdateExample
    {
        public void main()
        {
            
            // Configure HTTP basic authorization: Basic
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new ApiApi();
            var id = id_example;  // String | 
            var data = new MaintenanceWorkOrderCreate(); // MaintenanceWorkOrderCreate | 

            try
            {
                MaintenanceWorkOrderCreate result = apiInstance.apiMaintenancesWorkOrdersUpdate(id, data);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ApiApi.apiMaintenancesWorkOrdersUpdate: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: Basic
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\Api\ApiApi();
$id = id_example; // String | 
$data = ; // MaintenanceWorkOrderCreate | 

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

# Configure HTTP basic authorization: Basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::ApiApi->new();
my $id = id_example; # String | 
my $data = WWW::SwaggerClient::Object::MaintenanceWorkOrderCreate->new(); # MaintenanceWorkOrderCreate | 

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

# Configure HTTP basic authorization: Basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.ApiApi()
id = id_example # String | 
data =  # MaintenanceWorkOrderCreate | 

try: 
    api_response = api_instance.api_maintenances_work_orders_update(id, data)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ApiApi->apiMaintenancesWorkOrdersUpdate: %s\n" % e)

Parameters

Path parameters
Name Description
id*
String
Required
Body parameters
Name Description
data *

Responses

Status: 200 -


apiMixingsIngredientCreate


/api/mixings/ingredient/

Usage and SDK Samples

curl -X POST -H "Accept: application/json" -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://127.0.0.1:8000/api/mixings/ingredient/"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ApiApi;

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

public class ApiApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: Basic
        HttpBasicAuth Basic = (HttpBasicAuth) defaultClient.getAuthentication("Basic");
        Basic.setUsername("YOUR USERNAME");
        Basic.setPassword("YOUR PASSWORD");

        ApiApi apiInstance = new ApiApi();
        MixIngredient data = ; // MixIngredient | 
        try {
            MixIngredient result = apiInstance.apiMixingsIngredientCreate(data);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiApi#apiMixingsIngredientCreate");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.ApiApi;

public class ApiApiExample {

    public static void main(String[] args) {
        ApiApi apiInstance = new ApiApi();
        MixIngredient data = ; // MixIngredient | 
        try {
            MixIngredient result = apiInstance.apiMixingsIngredientCreate(data);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiApi#apiMixingsIngredientCreate");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: Basic)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

MixIngredient *data = ; // 

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

[apiInstance apiMixingsIngredientCreateWith:data
              completionHandler: ^(MixIngredient output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var InternalTraceSenseApi = require('internal___trace_sense_api');
var defaultClient = InternalTraceSenseApi.ApiClient.instance;

// Configure HTTP basic authorization: Basic
var Basic = defaultClient.authentications['Basic'];
Basic.username = 'YOUR USERNAME'
Basic.password = 'YOUR PASSWORD'

var api = new InternalTraceSenseApi.ApiApi()

var data = ; // {MixIngredient} 


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

namespace Example
{
    public class apiMixingsIngredientCreateExample
    {
        public void main()
        {
            
            // Configure HTTP basic authorization: Basic
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new ApiApi();
            var data = new MixIngredient(); // MixIngredient | 

            try
            {
                MixIngredient result = apiInstance.apiMixingsIngredientCreate(data);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ApiApi.apiMixingsIngredientCreate: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: Basic
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\Api\ApiApi();
$data = ; // MixIngredient | 

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

# Configure HTTP basic authorization: Basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::ApiApi->new();
my $data = WWW::SwaggerClient::Object::MixIngredient->new(); # MixIngredient | 

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

# Configure HTTP basic authorization: Basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.ApiApi()
data =  # MixIngredient | 

try: 
    api_response = api_instance.api_mixings_ingredient_create(data)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ApiApi->apiMixingsIngredientCreate: %s\n" % e)

Parameters

Body parameters
Name Description
data *

Responses

Status: 201 -


apiMixingsIngredientList


/api/mixings/ingredient/

Usage and SDK Samples

curl -X GET -H "Accept: application/json" -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://127.0.0.1:8000/api/mixings/ingredient/?page="
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ApiApi;

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

public class ApiApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: Basic
        HttpBasicAuth Basic = (HttpBasicAuth) defaultClient.getAuthentication("Basic");
        Basic.setUsername("YOUR USERNAME");
        Basic.setPassword("YOUR PASSWORD");

        ApiApi apiInstance = new ApiApi();
        Integer page = 56; // Integer | A page number within the paginated result set.
        try {
            inline_response_200_2 result = apiInstance.apiMixingsIngredientList(page);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiApi#apiMixingsIngredientList");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.ApiApi;

public class ApiApiExample {

    public static void main(String[] args) {
        ApiApi apiInstance = new ApiApi();
        Integer page = 56; // Integer | A page number within the paginated result set.
        try {
            inline_response_200_2 result = apiInstance.apiMixingsIngredientList(page);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiApi#apiMixingsIngredientList");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: Basic)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

Integer *page = 56; // A page number within the paginated result set. (optional)

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

[apiInstance apiMixingsIngredientListWith:page
              completionHandler: ^(inline_response_200_2 output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var InternalTraceSenseApi = require('internal___trace_sense_api');
var defaultClient = InternalTraceSenseApi.ApiClient.instance;

// Configure HTTP basic authorization: Basic
var Basic = defaultClient.authentications['Basic'];
Basic.username = 'YOUR USERNAME'
Basic.password = 'YOUR PASSWORD'

var api = new InternalTraceSenseApi.ApiApi()

var opts = { 
  'page': 56 // {Integer} A page number within the paginated result set.
};

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

namespace Example
{
    public class apiMixingsIngredientListExample
    {
        public void main()
        {
            
            // Configure HTTP basic authorization: Basic
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new ApiApi();
            var page = 56;  // Integer | A page number within the paginated result set. (optional) 

            try
            {
                inline_response_200_2 result = apiInstance.apiMixingsIngredientList(page);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ApiApi.apiMixingsIngredientList: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: Basic
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\Api\ApiApi();
$page = 56; // Integer | A page number within the paginated result set.

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

# Configure HTTP basic authorization: Basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::ApiApi->new();
my $page = 56; # Integer | A page number within the paginated result set.

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

# Configure HTTP basic authorization: Basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.ApiApi()
page = 56 # Integer | A page number within the paginated result set. (optional)

try: 
    api_response = api_instance.api_mixings_ingredient_list(page=page)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ApiApi->apiMixingsIngredientList: %s\n" % e)

Parameters

Query parameters
Name Description
page
Integer
A page number within the paginated result set.

Responses

Status: 200 -


apiMixingsProducedCreate


/api/mixings/produced/

Usage and SDK Samples

curl -X POST -H "Accept: application/json" -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://127.0.0.1:8000/api/mixings/produced/"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ApiApi;

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

public class ApiApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: Basic
        HttpBasicAuth Basic = (HttpBasicAuth) defaultClient.getAuthentication("Basic");
        Basic.setUsername("YOUR USERNAME");
        Basic.setPassword("YOUR PASSWORD");

        ApiApi apiInstance = new ApiApi();
        MixProduced data = ; // MixProduced | 
        try {
            MixProduced result = apiInstance.apiMixingsProducedCreate(data);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiApi#apiMixingsProducedCreate");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.ApiApi;

public class ApiApiExample {

    public static void main(String[] args) {
        ApiApi apiInstance = new ApiApi();
        MixProduced data = ; // MixProduced | 
        try {
            MixProduced result = apiInstance.apiMixingsProducedCreate(data);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiApi#apiMixingsProducedCreate");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: Basic)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

MixProduced *data = ; // 

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

[apiInstance apiMixingsProducedCreateWith:data
              completionHandler: ^(MixProduced output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var InternalTraceSenseApi = require('internal___trace_sense_api');
var defaultClient = InternalTraceSenseApi.ApiClient.instance;

// Configure HTTP basic authorization: Basic
var Basic = defaultClient.authentications['Basic'];
Basic.username = 'YOUR USERNAME'
Basic.password = 'YOUR PASSWORD'

var api = new InternalTraceSenseApi.ApiApi()

var data = ; // {MixProduced} 


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

namespace Example
{
    public class apiMixingsProducedCreateExample
    {
        public void main()
        {
            
            // Configure HTTP basic authorization: Basic
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new ApiApi();
            var data = new MixProduced(); // MixProduced | 

            try
            {
                MixProduced result = apiInstance.apiMixingsProducedCreate(data);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ApiApi.apiMixingsProducedCreate: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: Basic
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\Api\ApiApi();
$data = ; // MixProduced | 

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

# Configure HTTP basic authorization: Basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::ApiApi->new();
my $data = WWW::SwaggerClient::Object::MixProduced->new(); # MixProduced | 

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

# Configure HTTP basic authorization: Basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.ApiApi()
data =  # MixProduced | 

try: 
    api_response = api_instance.api_mixings_produced_create(data)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ApiApi->apiMixingsProducedCreate: %s\n" % e)

Parameters

Body parameters
Name Description
data *

Responses

Status: 201 -


apiMixingsProducedList


/api/mixings/produced/

Usage and SDK Samples

curl -X GET -H "Accept: application/json" -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://127.0.0.1:8000/api/mixings/produced/?page="
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ApiApi;

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

public class ApiApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: Basic
        HttpBasicAuth Basic = (HttpBasicAuth) defaultClient.getAuthentication("Basic");
        Basic.setUsername("YOUR USERNAME");
        Basic.setPassword("YOUR PASSWORD");

        ApiApi apiInstance = new ApiApi();
        Integer page = 56; // Integer | A page number within the paginated result set.
        try {
            inline_response_200_3 result = apiInstance.apiMixingsProducedList(page);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiApi#apiMixingsProducedList");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.ApiApi;

public class ApiApiExample {

    public static void main(String[] args) {
        ApiApi apiInstance = new ApiApi();
        Integer page = 56; // Integer | A page number within the paginated result set.
        try {
            inline_response_200_3 result = apiInstance.apiMixingsProducedList(page);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiApi#apiMixingsProducedList");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: Basic)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

Integer *page = 56; // A page number within the paginated result set. (optional)

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

[apiInstance apiMixingsProducedListWith:page
              completionHandler: ^(inline_response_200_3 output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var InternalTraceSenseApi = require('internal___trace_sense_api');
var defaultClient = InternalTraceSenseApi.ApiClient.instance;

// Configure HTTP basic authorization: Basic
var Basic = defaultClient.authentications['Basic'];
Basic.username = 'YOUR USERNAME'
Basic.password = 'YOUR PASSWORD'

var api = new InternalTraceSenseApi.ApiApi()

var opts = { 
  'page': 56 // {Integer} A page number within the paginated result set.
};

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

namespace Example
{
    public class apiMixingsProducedListExample
    {
        public void main()
        {
            
            // Configure HTTP basic authorization: Basic
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new ApiApi();
            var page = 56;  // Integer | A page number within the paginated result set. (optional) 

            try
            {
                inline_response_200_3 result = apiInstance.apiMixingsProducedList(page);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ApiApi.apiMixingsProducedList: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: Basic
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\Api\ApiApi();
$page = 56; // Integer | A page number within the paginated result set.

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

# Configure HTTP basic authorization: Basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::ApiApi->new();
my $page = 56; # Integer | A page number within the paginated result set.

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

# Configure HTTP basic authorization: Basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.ApiApi()
page = 56 # Integer | A page number within the paginated result set. (optional)

try: 
    api_response = api_instance.api_mixings_produced_list(page=page)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ApiApi->apiMixingsProducedList: %s\n" % e)

Parameters

Query parameters
Name Description
page
Integer
A page number within the paginated result set.

Responses

Status: 200 -


apiMixingsScaleOnlyList


/api/mixings/scale-only/

Usage and SDK Samples

curl -X GET -H "Accept: application/json" -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://127.0.0.1:8000/api/mixings/scale-only/"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ApiApi;

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

public class ApiApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: Basic
        HttpBasicAuth Basic = (HttpBasicAuth) defaultClient.getAuthentication("Basic");
        Basic.setUsername("YOUR USERNAME");
        Basic.setPassword("YOUR PASSWORD");

        ApiApi apiInstance = new ApiApi();
        try {
            apiInstance.apiMixingsScaleOnlyList();
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiApi#apiMixingsScaleOnlyList");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.ApiApi;

public class ApiApiExample {

    public static void main(String[] args) {
        ApiApi apiInstance = new ApiApi();
        try {
            apiInstance.apiMixingsScaleOnlyList();
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiApi#apiMixingsScaleOnlyList");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: Basic)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];


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

[apiInstance apiMixingsScaleOnlyListWithCompletionHandler: 
              ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var InternalTraceSenseApi = require('internal___trace_sense_api');
var defaultClient = InternalTraceSenseApi.ApiClient.instance;

// Configure HTTP basic authorization: Basic
var Basic = defaultClient.authentications['Basic'];
Basic.username = 'YOUR USERNAME'
Basic.password = 'YOUR PASSWORD'

var api = new InternalTraceSenseApi.ApiApi()

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

namespace Example
{
    public class apiMixingsScaleOnlyListExample
    {
        public void main()
        {
            
            // Configure HTTP basic authorization: Basic
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new ApiApi();

            try
            {
                apiInstance.apiMixingsScaleOnlyList();
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ApiApi.apiMixingsScaleOnlyList: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: Basic
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

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

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

# Configure HTTP basic authorization: Basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

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

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

# Configure HTTP basic authorization: Basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

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

try: 
    api_instance.api_mixings_scale_only_list()
except ApiException as e:
    print("Exception when calling ApiApi->apiMixingsScaleOnlyList: %s\n" % e)

Parameters

Responses

Status: 200 -


apiPlanningProductionPlansCreate


/api/planning/production-plans/

Usage and SDK Samples

curl -X POST -H "Accept: application/json" -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://127.0.0.1:8000/api/planning/production-plans/"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ApiApi;

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

public class ApiApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: Basic
        HttpBasicAuth Basic = (HttpBasicAuth) defaultClient.getAuthentication("Basic");
        Basic.setUsername("YOUR USERNAME");
        Basic.setPassword("YOUR PASSWORD");

        ApiApi apiInstance = new ApiApi();
        ProductionPlan data = ; // ProductionPlan | 
        try {
            ProductionPlan result = apiInstance.apiPlanningProductionPlansCreate(data);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiApi#apiPlanningProductionPlansCreate");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.ApiApi;

public class ApiApiExample {

    public static void main(String[] args) {
        ApiApi apiInstance = new ApiApi();
        ProductionPlan data = ; // ProductionPlan | 
        try {
            ProductionPlan result = apiInstance.apiPlanningProductionPlansCreate(data);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiApi#apiPlanningProductionPlansCreate");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: Basic)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

ProductionPlan *data = ; // 

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

[apiInstance apiPlanningProductionPlansCreateWith:data
              completionHandler: ^(ProductionPlan output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var InternalTraceSenseApi = require('internal___trace_sense_api');
var defaultClient = InternalTraceSenseApi.ApiClient.instance;

// Configure HTTP basic authorization: Basic
var Basic = defaultClient.authentications['Basic'];
Basic.username = 'YOUR USERNAME'
Basic.password = 'YOUR PASSWORD'

var api = new InternalTraceSenseApi.ApiApi()

var data = ; // {ProductionPlan} 


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

namespace Example
{
    public class apiPlanningProductionPlansCreateExample
    {
        public void main()
        {
            
            // Configure HTTP basic authorization: Basic
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new ApiApi();
            var data = new ProductionPlan(); // ProductionPlan | 

            try
            {
                ProductionPlan result = apiInstance.apiPlanningProductionPlansCreate(data);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ApiApi.apiPlanningProductionPlansCreate: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: Basic
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\Api\ApiApi();
$data = ; // ProductionPlan | 

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

# Configure HTTP basic authorization: Basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::ApiApi->new();
my $data = WWW::SwaggerClient::Object::ProductionPlan->new(); # ProductionPlan | 

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

# Configure HTTP basic authorization: Basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.ApiApi()
data =  # ProductionPlan | 

try: 
    api_response = api_instance.api_planning_production_plans_create(data)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ApiApi->apiPlanningProductionPlansCreate: %s\n" % e)

Parameters

Body parameters
Name Description
data *

Responses

Status: 201 -


apiPlanningProductionPlansDelete


/api/planning/production-plans/{id}/

Usage and SDK Samples

curl -X DELETE -H "Accept: application/json" -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://127.0.0.1:8000/api/planning/production-plans/{id}/"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ApiApi;

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

public class ApiApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: Basic
        HttpBasicAuth Basic = (HttpBasicAuth) defaultClient.getAuthentication("Basic");
        Basic.setUsername("YOUR USERNAME");
        Basic.setPassword("YOUR PASSWORD");

        ApiApi apiInstance = new ApiApi();
        Integer id = 56; // Integer | A unique integer value identifying this Plan.
        try {
            apiInstance.apiPlanningProductionPlansDelete(id);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiApi#apiPlanningProductionPlansDelete");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.ApiApi;

public class ApiApiExample {

    public static void main(String[] args) {
        ApiApi apiInstance = new ApiApi();
        Integer id = 56; // Integer | A unique integer value identifying this Plan.
        try {
            apiInstance.apiPlanningProductionPlansDelete(id);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiApi#apiPlanningProductionPlansDelete");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: Basic)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

Integer *id = 56; // A unique integer value identifying this Plan.

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

[apiInstance apiPlanningProductionPlansDeleteWith:id
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var InternalTraceSenseApi = require('internal___trace_sense_api');
var defaultClient = InternalTraceSenseApi.ApiClient.instance;

// Configure HTTP basic authorization: Basic
var Basic = defaultClient.authentications['Basic'];
Basic.username = 'YOUR USERNAME'
Basic.password = 'YOUR PASSWORD'

var api = new InternalTraceSenseApi.ApiApi()

var id = 56; // {Integer} A unique integer value identifying this Plan.


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

namespace Example
{
    public class apiPlanningProductionPlansDeleteExample
    {
        public void main()
        {
            
            // Configure HTTP basic authorization: Basic
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new ApiApi();
            var id = 56;  // Integer | A unique integer value identifying this Plan.

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

// Configure HTTP basic authorization: Basic
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\Api\ApiApi();
$id = 56; // Integer | A unique integer value identifying this Plan.

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

# Configure HTTP basic authorization: Basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::ApiApi->new();
my $id = 56; # Integer | A unique integer value identifying this Plan.

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

# Configure HTTP basic authorization: Basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.ApiApi()
id = 56 # Integer | A unique integer value identifying this Plan.

try: 
    api_instance.api_planning_production_plans_delete(id)
except ApiException as e:
    print("Exception when calling ApiApi->apiPlanningProductionPlansDelete: %s\n" % e)

Parameters

Path parameters
Name Description
id*
Integer
A unique integer value identifying this Plan.
Required

Responses

Status: 204 -


apiPlanningProductionPlansList


/api/planning/production-plans/

Usage and SDK Samples

curl -X GET -H "Accept: application/json" -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://127.0.0.1:8000/api/planning/production-plans/?page="
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ApiApi;

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

public class ApiApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: Basic
        HttpBasicAuth Basic = (HttpBasicAuth) defaultClient.getAuthentication("Basic");
        Basic.setUsername("YOUR USERNAME");
        Basic.setPassword("YOUR PASSWORD");

        ApiApi apiInstance = new ApiApi();
        Integer page = 56; // Integer | A page number within the paginated result set.
        try {
            inline_response_200_4 result = apiInstance.apiPlanningProductionPlansList(page);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiApi#apiPlanningProductionPlansList");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.ApiApi;

public class ApiApiExample {

    public static void main(String[] args) {
        ApiApi apiInstance = new ApiApi();
        Integer page = 56; // Integer | A page number within the paginated result set.
        try {
            inline_response_200_4 result = apiInstance.apiPlanningProductionPlansList(page);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiApi#apiPlanningProductionPlansList");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: Basic)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

Integer *page = 56; // A page number within the paginated result set. (optional)

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

[apiInstance apiPlanningProductionPlansListWith:page
              completionHandler: ^(inline_response_200_4 output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var InternalTraceSenseApi = require('internal___trace_sense_api');
var defaultClient = InternalTraceSenseApi.ApiClient.instance;

// Configure HTTP basic authorization: Basic
var Basic = defaultClient.authentications['Basic'];
Basic.username = 'YOUR USERNAME'
Basic.password = 'YOUR PASSWORD'

var api = new InternalTraceSenseApi.ApiApi()

var opts = { 
  'page': 56 // {Integer} A page number within the paginated result set.
};

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

namespace Example
{
    public class apiPlanningProductionPlansListExample
    {
        public void main()
        {
            
            // Configure HTTP basic authorization: Basic
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new ApiApi();
            var page = 56;  // Integer | A page number within the paginated result set. (optional) 

            try
            {
                inline_response_200_4 result = apiInstance.apiPlanningProductionPlansList(page);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ApiApi.apiPlanningProductionPlansList: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: Basic
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\Api\ApiApi();
$page = 56; // Integer | A page number within the paginated result set.

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

# Configure HTTP basic authorization: Basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::ApiApi->new();
my $page = 56; # Integer | A page number within the paginated result set.

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

# Configure HTTP basic authorization: Basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.ApiApi()
page = 56 # Integer | A page number within the paginated result set. (optional)

try: 
    api_response = api_instance.api_planning_production_plans_list(page=page)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ApiApi->apiPlanningProductionPlansList: %s\n" % e)

Parameters

Query parameters
Name Description
page
Integer
A page number within the paginated result set.

Responses

Status: 200 -


apiPlanningProductionPlansPartialUpdate


/api/planning/production-plans/{id}/

Usage and SDK Samples

curl -X PATCH -H "Accept: application/json" -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://127.0.0.1:8000/api/planning/production-plans/{id}/"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ApiApi;

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

public class ApiApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: Basic
        HttpBasicAuth Basic = (HttpBasicAuth) defaultClient.getAuthentication("Basic");
        Basic.setUsername("YOUR USERNAME");
        Basic.setPassword("YOUR PASSWORD");

        ApiApi apiInstance = new ApiApi();
        Integer id = 56; // Integer | A unique integer value identifying this Plan.
        ProductionPlan data = ; // ProductionPlan | 
        try {
            ProductionPlan result = apiInstance.apiPlanningProductionPlansPartialUpdate(id, data);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiApi#apiPlanningProductionPlansPartialUpdate");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.ApiApi;

public class ApiApiExample {

    public static void main(String[] args) {
        ApiApi apiInstance = new ApiApi();
        Integer id = 56; // Integer | A unique integer value identifying this Plan.
        ProductionPlan data = ; // ProductionPlan | 
        try {
            ProductionPlan result = apiInstance.apiPlanningProductionPlansPartialUpdate(id, data);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiApi#apiPlanningProductionPlansPartialUpdate");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: Basic)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

Integer *id = 56; // A unique integer value identifying this Plan.
ProductionPlan *data = ; // 

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

[apiInstance apiPlanningProductionPlansPartialUpdateWith:id
    data:data
              completionHandler: ^(ProductionPlan output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var InternalTraceSenseApi = require('internal___trace_sense_api');
var defaultClient = InternalTraceSenseApi.ApiClient.instance;

// Configure HTTP basic authorization: Basic
var Basic = defaultClient.authentications['Basic'];
Basic.username = 'YOUR USERNAME'
Basic.password = 'YOUR PASSWORD'

var api = new InternalTraceSenseApi.ApiApi()

var id = 56; // {Integer} A unique integer value identifying this Plan.

var data = ; // {ProductionPlan} 


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

namespace Example
{
    public class apiPlanningProductionPlansPartialUpdateExample
    {
        public void main()
        {
            
            // Configure HTTP basic authorization: Basic
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new ApiApi();
            var id = 56;  // Integer | A unique integer value identifying this Plan.
            var data = new ProductionPlan(); // ProductionPlan | 

            try
            {
                ProductionPlan result = apiInstance.apiPlanningProductionPlansPartialUpdate(id, data);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ApiApi.apiPlanningProductionPlansPartialUpdate: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: Basic
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\Api\ApiApi();
$id = 56; // Integer | A unique integer value identifying this Plan.
$data = ; // ProductionPlan | 

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

# Configure HTTP basic authorization: Basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::ApiApi->new();
my $id = 56; # Integer | A unique integer value identifying this Plan.
my $data = WWW::SwaggerClient::Object::ProductionPlan->new(); # ProductionPlan | 

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

# Configure HTTP basic authorization: Basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.ApiApi()
id = 56 # Integer | A unique integer value identifying this Plan.
data =  # ProductionPlan | 

try: 
    api_response = api_instance.api_planning_production_plans_partial_update(id, data)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ApiApi->apiPlanningProductionPlansPartialUpdate: %s\n" % e)

Parameters

Path parameters
Name Description
id*
Integer
A unique integer value identifying this Plan.
Required
Body parameters
Name Description
data *

Responses

Status: 200 -


apiPlanningProductionPlansRead


/api/planning/production-plans/{id}/

Usage and SDK Samples

curl -X GET -H "Accept: application/json" -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://127.0.0.1:8000/api/planning/production-plans/{id}/"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ApiApi;

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

public class ApiApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: Basic
        HttpBasicAuth Basic = (HttpBasicAuth) defaultClient.getAuthentication("Basic");
        Basic.setUsername("YOUR USERNAME");
        Basic.setPassword("YOUR PASSWORD");

        ApiApi apiInstance = new ApiApi();
        Integer id = 56; // Integer | A unique integer value identifying this Plan.
        try {
            ProductionPlan result = apiInstance.apiPlanningProductionPlansRead(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiApi#apiPlanningProductionPlansRead");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.ApiApi;

public class ApiApiExample {

    public static void main(String[] args) {
        ApiApi apiInstance = new ApiApi();
        Integer id = 56; // Integer | A unique integer value identifying this Plan.
        try {
            ProductionPlan result = apiInstance.apiPlanningProductionPlansRead(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiApi#apiPlanningProductionPlansRead");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: Basic)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

Integer *id = 56; // A unique integer value identifying this Plan.

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

[apiInstance apiPlanningProductionPlansReadWith:id
              completionHandler: ^(ProductionPlan output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var InternalTraceSenseApi = require('internal___trace_sense_api');
var defaultClient = InternalTraceSenseApi.ApiClient.instance;

// Configure HTTP basic authorization: Basic
var Basic = defaultClient.authentications['Basic'];
Basic.username = 'YOUR USERNAME'
Basic.password = 'YOUR PASSWORD'

var api = new InternalTraceSenseApi.ApiApi()

var id = 56; // {Integer} A unique integer value identifying this Plan.


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

namespace Example
{
    public class apiPlanningProductionPlansReadExample
    {
        public void main()
        {
            
            // Configure HTTP basic authorization: Basic
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new ApiApi();
            var id = 56;  // Integer | A unique integer value identifying this Plan.

            try
            {
                ProductionPlan result = apiInstance.apiPlanningProductionPlansRead(id);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ApiApi.apiPlanningProductionPlansRead: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: Basic
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\Api\ApiApi();
$id = 56; // Integer | A unique integer value identifying this Plan.

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

# Configure HTTP basic authorization: Basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::ApiApi->new();
my $id = 56; # Integer | A unique integer value identifying this Plan.

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

# Configure HTTP basic authorization: Basic
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

# create an instance of the API class
api_instance = swagger_client.ApiApi()
id = 56 # Integer | A unique integer value identifying this Plan.

try: 
    api_response = api_instance.api_planning_production_plans_read(id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ApiApi->apiPlanningProductionPlansRead: %s\n" % e)

Parameters

Path parameters
Name Description
id*
Integer
A unique integer value identifying this Plan.
Required

Responses

Status: 200 -


apiPlanningProductionPlansUpdate


/api/planning/production-plans/{id}/

Usage and SDK Samples

curl -X PUT -H "Accept: application/json" -H "Content-Type: application/json" -H "Authorization: Basic [[basicHash]]" "http://127.0.0.1:8000/api/planning/production-plans/{id}/"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ApiApi;

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

public class ApiApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();
        
        // Configure HTTP basic authorization: Basic
        HttpBasicAuth Basic = (HttpBasicAuth) defaultClient.getAuthentication("Basic");
        Basic.setUsername("YOUR USERNAME");
        Basic.setPassword("YOUR PASSWORD");

        ApiApi apiInstance = new ApiApi();
        Integer id = 56; // Integer | A unique integer value identifying this Plan.
        ProductionPlan data = ; // ProductionPlan | 
        try {
            ProductionPlan result = apiInstance.apiPlanningProductionPlansUpdate(id, data);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiApi#apiPlanningProductionPlansUpdate");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.ApiApi;

public class ApiApiExample {

    public static void main(String[] args) {
        ApiApi apiInstance = new ApiApi();
        Integer id = 56; // Integer | A unique integer value identifying this Plan.
        ProductionPlan data = ; // ProductionPlan | 
        try {
            ProductionPlan result = apiInstance.apiPlanningProductionPlansUpdate(id, data);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiApi#apiPlanningProductionPlansUpdate");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: Basic)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];

Integer *id = 56; // A unique integer value identifying this Plan.
ProductionPlan *data = ; // 

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

[apiInstance apiPlanningProductionPlansUpdateWith:id
    data:data
              completionHandler: ^(ProductionPlan output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var InternalTraceSenseApi = require('internal___trace_sense_api');
var defaultClient = InternalTraceSenseApi.ApiClient.instance;

// Configure HTTP basic authorization: Basic
var Basic = defaultClient.authentications['Basic'];
Basic.username = 'YOUR USERNAME'
Basic.password = 'YOUR PASSWORD'

var api = new InternalTraceSenseApi.ApiApi()

var id = 56; // {Integer} A unique integer value identifying this Plan.

var data = ; // {ProductionPlan} 


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

namespace Example
{
    public class apiPlanningProductionPlansUpdateExample
    {
        public void main()
        {
            
            // Configure HTTP basic authorization: Basic
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new ApiApi();
            var id = 56;  // Integer | A unique integer value identifying this Plan.
            var data = new ProductionPlan(); // ProductionPlan | 

            try
            {
                ProductionPlan result = apiInstance.apiPlanningProductionPlansUpdate(id, data);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ApiApi.apiPlanningProductionPlansUpdate: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Configure HTTP basic authorization: Basic
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\Api\ApiApi();
$id = 56; // Integer | A unique integer value identifying this Plan.
$data = ; // ProductionPlan | 

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

# Configure HTTP basic authorization: Basic
$WWW::SwaggerClient::Configuration::username = 'YOUR_USERNAME';
$WWW::SwaggerClient::Configuration::password = 'YOUR_PASSWORD';

my $api_instance = WWW::SwaggerClient::ApiApi->new();
my $id = 56; # Integer | A unique integer value identifying this Plan.
my $data = WWW::SwaggerClient::Object::ProductionPlan->new(); # ProductionPlan | 

eval { 
    m