IRIS Supply Chain Data Model API

Default

addAttribute

Add a custom attribute to an object


/attributes/{objectName}

Usage and SDK Samples

curl -X POST "http://localhost/api/scdata/v1/attributes/{objectName}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.DefaultApi;

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

public class DefaultApiExample {

    public static void main(String[] args) {

        DefaultApi apiInstance = new DefaultApi();
        String objectName = objectName_example; // String | Object name
        PropertyDefinition body = ; // PropertyDefinition | 
        try {
            apiInstance.addAttribute(objectName, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#addAttribute");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.DefaultApi;

public class DefaultApiExample {

    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        String objectName = objectName_example; // String | Object name
        PropertyDefinition body = ; // PropertyDefinition | 
        try {
            apiInstance.addAttribute(objectName, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#addAttribute");
            e.printStackTrace();
        }
    }
}
String *objectName = objectName_example; // Object name
PropertyDefinition *body = ; // 

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

[apiInstance addAttributeWith:objectName

    body:body

              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var IrisSupplyChainDataModelApi = require('iris_supply_chain_data_model_api');

var api = new IrisSupplyChainDataModelApi.DefaultApi()

var objectName = objectName_example; // {String} Object name

var body = ; // {PropertyDefinition} 


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

namespace Example
{
    public class addAttributeExample

    {
        public void main()
        {

            var apiInstance = new DefaultApi();
            var objectName = objectName_example;  // String | Object name
            var body = new PropertyDefinition(); // PropertyDefinition | 

            try
            {
                apiInstance.addAttribute(objectName, body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DefaultApi.addAttribute: " + e.Message );
            }
        }
    }
}
<?php

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

$api_instance = new Swagger\Client\Api\DefaultApi();
$objectName = objectName_example; // String | Object name
$body = ; // PropertyDefinition | 

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

my $api_instance = WWW::SwaggerClient::DefaultApi->new();
my $objectName = objectName_example; # String | Object name
my $body = WWW::SwaggerClient::Object::PropertyDefinition->new(); # PropertyDefinition | 

eval {
    $api_instance->addAttribute(objectName => $objectName, body => $body);
};
if ($@) {
    warn "Exception when calling DefaultApi->addAttribute: $@\n";
}
from __future__ import print_statement

import time

import swagger_client

from swagger_client.rest import ApiException
from pprint import pprint


# create an instance of the API class
api_instance = swagger_client.DefaultApi()
objectName = objectName_example # String | Object name
body =  # PropertyDefinition | 

try:
    api_instance.add_attribute(objectName, body)
except ApiException as e:
    print("Exception when calling DefaultApi->addAttribute: %s\n" % e)

Parameters

Path parameters
Name Description
objectName*
String
Object name
Required
Body parameters
Name Description
body *
{
Required: name,type
name:
string
type:
string
required:
number
description:
string
}

Responses

Status: 200 - Success

Status: 500 - Server error

createBOM

Add a new BOM


/billofmaterials

Usage and SDK Samples

curl -X POST "http://localhost/api/scdata/v1/billofmaterials"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.DefaultApi;

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

public class DefaultApiExample {

    public static void main(String[] args) {

        DefaultApi apiInstance = new DefaultApi();
        BOM body = ; // BOM | 
        try {
            BOM result = apiInstance.createBOM(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#createBOM");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.DefaultApi;

public class DefaultApiExample {

    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        BOM body = ; // BOM | 
        try {
            BOM result = apiInstance.createBOM(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#createBOM");
            e.printStackTrace();
        }
    }
}
BOM *body = ; // 

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

[apiInstance createBOMWith:body

              completionHandler: ^(BOM output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var IrisSupplyChainDataModelApi = require('iris_supply_chain_data_model_api');

var api = new IrisSupplyChainDataModelApi.DefaultApi()

var body = ; // {BOM} 


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

namespace Example
{
    public class createBOMExample

    {
        public void main()
        {

            var apiInstance = new DefaultApi();
            var body = new BOM(); // BOM | 

            try
            {
                BOM result = apiInstance.createBOM(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DefaultApi.createBOM: " + e.Message );
            }
        }
    }
}
<?php

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

$api_instance = new Swagger\Client\Api\DefaultApi();
$body = ; // BOM | 

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

my $api_instance = WWW::SwaggerClient::DefaultApi->new();
my $body = WWW::SwaggerClient::Object::BOM->new(); # BOM | 

eval {
    my $result = $api_instance->createBOM(body => $body);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->createBOM: $@\n";
}
from __future__ import print_statement

import time

import swagger_client

from swagger_client.rest import ApiException
from pprint import pprint


# create an instance of the API class
api_instance = swagger_client.DefaultApi()
body =  # BOM | 

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

Parameters

Body parameters
Name Description
body *
{
Required: uid
uid:
string
productId:
string
itemId:
string
parentItemId:
string
isAlternate:
number
substituteFor:
string
quantity:
number
unitOfMeasure:
string
effectiveStartDate:
string (date-time)
effectiveEndDate:
string (date-time)
}

Responses

Status: 200 - Details of the created supplier

{
Required: uid
uid:
string
productId:
string
itemId:
string
parentItemId:
string
isAlternate:
number
substituteFor:
string
quantity:
number
unitOfMeasure:
string
effectiveStartDate:
string (date-time)
effectiveEndDate:
string (date-time)
}

Status: 400 - Invalid message body

Status: 500 - Server error

createCarrier

Add a new carrier


/carriers

Usage and SDK Samples

curl -X POST "http://localhost/api/scdata/v1/carriers"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.DefaultApi;

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

public class DefaultApiExample {

    public static void main(String[] args) {

        DefaultApi apiInstance = new DefaultApi();
        Carrier body = ; // Carrier | 
        try {
            Carrier result = apiInstance.createCarrier(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#createCarrier");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.DefaultApi;

public class DefaultApiExample {

    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        Carrier body = ; // Carrier | 
        try {
            Carrier result = apiInstance.createCarrier(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#createCarrier");
            e.printStackTrace();
        }
    }
}
Carrier *body = ; // 

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

[apiInstance createCarrierWith:body

              completionHandler: ^(Carrier output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var IrisSupplyChainDataModelApi = require('iris_supply_chain_data_model_api');

var api = new IrisSupplyChainDataModelApi.DefaultApi()

var body = ; // {Carrier} 


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

namespace Example
{
    public class createCarrierExample

    {
        public void main()
        {

            var apiInstance = new DefaultApi();
            var body = new Carrier(); // Carrier | 

            try
            {
                Carrier result = apiInstance.createCarrier(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DefaultApi.createCarrier: " + e.Message );
            }
        }
    }
}
<?php

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

$api_instance = new Swagger\Client\Api\DefaultApi();
$body = ; // Carrier | 

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

my $api_instance = WWW::SwaggerClient::DefaultApi->new();
my $body = WWW::SwaggerClient::Object::Carrier->new(); # Carrier | 

eval {
    my $result = $api_instance->createCarrier(body => $body);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->createCarrier: $@\n";
}
from __future__ import print_statement

import time

import swagger_client

from swagger_client.rest import ApiException
from pprint import pprint


# create an instance of the API class
api_instance = swagger_client.DefaultApi()
body =  # Carrier | 

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

Parameters

Body parameters
Name Description
body *
{
Required: uid
uid:
string
name:
string
type:
string
status:
string
url:
string
scac:
string
trackingUrl:
string
primaryContact:
string
primaryPhone:
string
}

Responses

Status: 200 - Details of the created product

{
Required: uid
uid:
string
name:
string
type:
string
status:
string
url:
string
scac:
string
trackingUrl:
string
primaryContact:
string
primaryPhone:
string
}

Status: 400 - Invalid message body

Status: 500 - Server error

createCustomer

Add a new customer


/customers

Usage and SDK Samples

curl -X POST "http://localhost/api/scdata/v1/customers"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.DefaultApi;

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

public class DefaultApiExample {

    public static void main(String[] args) {

        DefaultApi apiInstance = new DefaultApi();
        Customer body = ; // Customer | 
        try {
            apiInstance.createCustomer(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#createCustomer");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.DefaultApi;

public class DefaultApiExample {

    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        Customer body = ; // Customer | 
        try {
            apiInstance.createCustomer(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#createCustomer");
            e.printStackTrace();
        }
    }
}
Customer *body = ; // 

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

[apiInstance createCustomerWith:body

              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var IrisSupplyChainDataModelApi = require('iris_supply_chain_data_model_api');

var api = new IrisSupplyChainDataModelApi.DefaultApi()

var body = ; // {Customer} 


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

namespace Example
{
    public class createCustomerExample

    {
        public void main()
        {

            var apiInstance = new DefaultApi();
            var body = new Customer(); // Customer | 

            try
            {
                apiInstance.createCustomer(body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DefaultApi.createCustomer: " + e.Message );
            }
        }
    }
}
<?php

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

$api_instance = new Swagger\Client\Api\DefaultApi();
$body = ; // Customer | 

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

my $api_instance = WWW::SwaggerClient::DefaultApi->new();
my $body = WWW::SwaggerClient::Object::Customer->new(); # Customer | 

eval {
    $api_instance->createCustomer(body => $body);
};
if ($@) {
    warn "Exception when calling DefaultApi->createCustomer: $@\n";
}
from __future__ import print_statement

import time

import swagger_client

from swagger_client.rest import ApiException
from pprint import pprint


# create an instance of the API class
api_instance = swagger_client.DefaultApi()
body =  # Customer | 

try:
    api_instance.create_customer(body)
except ApiException as e:
    print("Exception when calling DefaultApi->createCustomer: %s\n" % e)

Parameters

Body parameters
Name Description
body *
{
Required: name,uid
uid:
string
name:
string
primaryContact:
string
primaryPhone:
string
url:
string
status:
string
type:
string
shipToLocationId:
string
primaryLocationId:
string
}

Responses

Status: 200 - Success

Status: 400 - Invalid message body

Status: 500 - Server error

createDemandPlan

Add a new demand plan


/demandplans

Usage and SDK Samples

curl -X POST "http://localhost/api/scdata/v1/demandplans"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.DefaultApi;

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

public class DefaultApiExample {

    public static void main(String[] args) {

        DefaultApi apiInstance = new DefaultApi();
        DemandPlan body = ; // DemandPlan | 
        try {
            DemandPlan result = apiInstance.createDemandPlan(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#createDemandPlan");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.DefaultApi;

public class DefaultApiExample {

    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        DemandPlan body = ; // DemandPlan | 
        try {
            DemandPlan result = apiInstance.createDemandPlan(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#createDemandPlan");
            e.printStackTrace();
        }
    }
}
DemandPlan *body = ; // 

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

[apiInstance createDemandPlanWith:body

              completionHandler: ^(DemandPlan output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var IrisSupplyChainDataModelApi = require('iris_supply_chain_data_model_api');

var api = new IrisSupplyChainDataModelApi.DefaultApi()

var body = ; // {DemandPlan} 


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

namespace Example
{
    public class createDemandPlanExample

    {
        public void main()
        {

            var apiInstance = new DefaultApi();
            var body = new DemandPlan(); // DemandPlan | 

            try
            {
                DemandPlan result = apiInstance.createDemandPlan(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DefaultApi.createDemandPlan: " + e.Message );
            }
        }
    }
}
<?php

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

$api_instance = new Swagger\Client\Api\DefaultApi();
$body = ; // DemandPlan | 

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

my $api_instance = WWW::SwaggerClient::DefaultApi->new();
my $body = WWW::SwaggerClient::Object::DemandPlan->new(); # DemandPlan | 

eval {
    my $result = $api_instance->createDemandPlan(body => $body);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->createDemandPlan: $@\n";
}
from __future__ import print_statement

import time

import swagger_client

from swagger_client.rest import ApiException
from pprint import pprint


# create an instance of the API class
api_instance = swagger_client.DefaultApi()
body =  # DemandPlan | 

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

Parameters

Body parameters
Name Description
body *
{
Required: uid
uid:
string
locationId:
string
productId:
string
planCycle:
string
planType:
string
quantity:
number
unitOfMeasure:
string
startDate:
string (date-time)
validFromDate:
string (date-time)
validToDate:
string (date-time)
}

Responses

Status: 200 - Details of the newly created object

{
Required: uid
uid:
string
locationId:
string
productId:
string
planCycle:
string
planType:
string
quantity:
number
unitOfMeasure:
string
startDate:
string (date-time)
validFromDate:
string (date-time)
validToDate:
string (date-time)
}

Status: 400 - Invalid message body

Status: 500 - Server error

createException

Add a new exception


/scexceptions

Usage and SDK Samples

curl -X POST "http://localhost/api/scdata/v1/scexceptions"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.DefaultApi;

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

public class DefaultApiExample {

    public static void main(String[] args) {

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

public class DefaultApiExample {

    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        Exception body = ; // Exception | 
        try {
            Exception result = apiInstance.createException(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#createException");
            e.printStackTrace();
        }
    }
}
Exception *body = ; // 

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

[apiInstance createExceptionWith:body

              completionHandler: ^(Exception output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var IrisSupplyChainDataModelApi = require('iris_supply_chain_data_model_api');

var api = new IrisSupplyChainDataModelApi.DefaultApi()

var body = ; // {Exception} 


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

namespace Example
{
    public class createExceptionExample

    {
        public void main()
        {

            var apiInstance = new DefaultApi();
            var body = new Exception(); // Exception | 

            try
            {
                Exception result = apiInstance.createException(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DefaultApi.createException: " + e.Message );
            }
        }
    }
}
<?php

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

$api_instance = new Swagger\Client\Api\DefaultApi();
$body = ; // Exception | 

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

my $api_instance = WWW::SwaggerClient::DefaultApi->new();
my $body = WWW::SwaggerClient::Object::Exception->new(); # Exception | 

eval {
    my $result = $api_instance->createException(body => $body);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->createException: $@\n";
}
from __future__ import print_statement

import time

import swagger_client

from swagger_client.rest import ApiException
from pprint import pprint


# create an instance of the API class
api_instance = swagger_client.DefaultApi()
body =  # Exception | 

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

Parameters

Body parameters
Name Description
body *
{
Required: uid
uid:
string
description:
string
category:
string
type:
string
reason:
string
action:
string
source:
string
actionDetails:
string
associatedObjectType:
string
associatedObjectId:
string
}

Responses

Status: 200 - Details of the newly created object

{
Required: uid
uid:
string
description:
string
category:
string
type:
string
reason:
string
action:
string
source:
string
actionDetails:
string
associatedObjectType:
string
associatedObjectId:
string
}

Status: 400 - Invalid message body

Status: 500 - Server error

createInventoryThreshold

Add a new inventory threshold


/inventorythresholds

Usage and SDK Samples

curl -X POST "http://localhost/api/scdata/v1/inventorythresholds"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.DefaultApi;

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

public class DefaultApiExample {

    public static void main(String[] args) {

        DefaultApi apiInstance = new DefaultApi();
        InventoryThreshold body = ; // InventoryThreshold | 
        try {
            InventoryThreshold result = apiInstance.createInventoryThreshold(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#createInventoryThreshold");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.DefaultApi;

public class DefaultApiExample {

    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        InventoryThreshold body = ; // InventoryThreshold | 
        try {
            InventoryThreshold result = apiInstance.createInventoryThreshold(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#createInventoryThreshold");
            e.printStackTrace();
        }
    }
}
InventoryThreshold *body = ; // 

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

[apiInstance createInventoryThresholdWith:body

              completionHandler: ^(InventoryThreshold output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var IrisSupplyChainDataModelApi = require('iris_supply_chain_data_model_api');

var api = new IrisSupplyChainDataModelApi.DefaultApi()

var body = ; // {InventoryThreshold} 


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

namespace Example
{
    public class createInventoryThresholdExample

    {
        public void main()
        {

            var apiInstance = new DefaultApi();
            var body = new InventoryThreshold(); // InventoryThreshold | 

            try
            {
                InventoryThreshold result = apiInstance.createInventoryThreshold(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DefaultApi.createInventoryThreshold: " + e.Message );
            }
        }
    }
}
<?php

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

$api_instance = new Swagger\Client\Api\DefaultApi();
$body = ; // InventoryThreshold | 

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

my $api_instance = WWW::SwaggerClient::DefaultApi->new();
my $body = WWW::SwaggerClient::Object::InventoryThreshold->new(); # InventoryThreshold | 

eval {
    my $result = $api_instance->createInventoryThreshold(body => $body);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->createInventoryThreshold: $@\n";
}
from __future__ import print_statement

import time

import swagger_client

from swagger_client.rest import ApiException
from pprint import pprint


# create an instance of the API class
api_instance = swagger_client.DefaultApi()
body =  # InventoryThreshold | 

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

Parameters

Body parameters
Name Description
body *
{
Required: uid
uid:
string
siteLocationId:
string
productId:
string
expectedLeadTime:
number
daysOfSupplyUpperThreshold:
number
daysOfSupplyLowerThreshold:
number
targetDaysOfSupply:
number
quantityUpperThreshold:
number
quantityLowerThreshold:
number
quantityUom:
string
velocityCode:
string
}

Responses

Status: 200 - Details of the newly created object

{
Required: uid
uid:
string
siteLocationId:
string
productId:
string
expectedLeadTime:
number
daysOfSupplyUpperThreshold:
number
daysOfSupplyLowerThreshold:
number
targetDaysOfSupply:
number
quantityUpperThreshold:
number
quantityLowerThreshold:
number
quantityUom:
string
velocityCode:
string
}

Status: 400 - Invalid message body

Status: 500 - Server error

createIssue

Create a new issue


/issues

Usage and SDK Samples

curl -X POST "http://localhost/api/scdata/v1/issues"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.DefaultApi;

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

public class DefaultApiExample {

    public static void main(String[] args) {

        DefaultApi apiInstance = new DefaultApi();
        Issue body = ; // Issue | 
        try {
            apiInstance.createIssue(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#createIssue");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.DefaultApi;

public class DefaultApiExample {

    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        Issue body = ; // Issue | 
        try {
            apiInstance.createIssue(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#createIssue");
            e.printStackTrace();
        }
    }
}
Issue *body = ; // 

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

[apiInstance createIssueWith:body

              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var IrisSupplyChainDataModelApi = require('iris_supply_chain_data_model_api');

var api = new IrisSupplyChainDataModelApi.DefaultApi()

var body = ; // {Issue} 


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

namespace Example
{
    public class createIssueExample

    {
        public void main()
        {

            var apiInstance = new DefaultApi();
            var body = new Issue(); // Issue | 

            try
            {
                apiInstance.createIssue(body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DefaultApi.createIssue: " + e.Message );
            }
        }
    }
}
<?php

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

$api_instance = new Swagger\Client\Api\DefaultApi();
$body = ; // Issue | 

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

my $api_instance = WWW::SwaggerClient::DefaultApi->new();
my $body = WWW::SwaggerClient::Object::Issue->new(); # Issue | 

eval {
    $api_instance->createIssue(body => $body);
};
if ($@) {
    warn "Exception when calling DefaultApi->createIssue: $@\n";
}
from __future__ import print_statement

import time

import swagger_client

from swagger_client.rest import ApiException
from pprint import pprint


# create an instance of the API class
api_instance = swagger_client.DefaultApi()
body =  # Issue | 

try:
    api_instance.create_issue(body)
except ApiException as e:
    print("Exception when calling DefaultApi->createIssue: %s\n" % e)

Parameters

Body parameters
Name Description
body *
{
Required: uid
uid:
string
description:
string
triggerType:
string
triggerObjectId:
string
impactedObjectType:
string
impactedObjectId:
string
severity:
number
closeTime:
string (date-time)
status:
string
}

Responses

Status: 200 - Success

Status: 400 - Invalid message body

Status: 500 - Server error

createLocation

Create a new location


/locations

Usage and SDK Samples

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

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

public class DefaultApiExample {

    public static void main(String[] args) {

        DefaultApi apiInstance = new DefaultApi();
        Location body = ; // Location | 
        try {
            apiInstance.createLocation(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#createLocation");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.DefaultApi;

public class DefaultApiExample {

    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        Location body = ; // Location | 
        try {
            apiInstance.createLocation(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#createLocation");
            e.printStackTrace();
        }
    }
}
Location *body = ; // 

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

[apiInstance createLocationWith:body

              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var IrisSupplyChainDataModelApi = require('iris_supply_chain_data_model_api');

var api = new IrisSupplyChainDataModelApi.DefaultApi()

var body = ; // {Location} 


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

namespace Example
{
    public class createLocationExample

    {
        public void main()
        {

            var apiInstance = new DefaultApi();
            var body = new Location(); // Location | 

            try
            {
                apiInstance.createLocation(body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DefaultApi.createLocation: " + e.Message );
            }
        }
    }
}
<?php

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

$api_instance = new Swagger\Client\Api\DefaultApi();
$body = ; // Location | 

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

my $api_instance = WWW::SwaggerClient::DefaultApi->new();
my $body = WWW::SwaggerClient::Object::Location->new(); # Location | 

eval {
    $api_instance->createLocation(body => $body);
};
if ($@) {
    warn "Exception when calling DefaultApi->createLocation: $@\n";
}
from __future__ import print_statement

import time

import swagger_client

from swagger_client.rest import ApiException
from pprint import pprint


# create an instance of the API class
api_instance = swagger_client.DefaultApi()
body =  # Location | 

try:
    api_instance.create_location(body)
except ApiException as e:
    print("Exception when calling DefaultApi->createLocation: %s\n" % e)

Parameters

Body parameters
Name Description
body *
{
Required: uid
uid:
string
locationName:
string
type:
string
status:
string
street:
string
city:
string
stateProvince:
string
stateProvinceIso2:
string
country:
string
countryIso2:
string
countryIso3:
string
countryPhoneCode:
string
postalCode:
string
coordinates:
string
gln:
string
currencyIso3:
string
region:
string
subregion:
string
}

Responses

Status: 200 - Success

Status: 500 - Server error

createMfgOrder

Add a new mfg order


/manufacturingorders

Usage and SDK Samples

curl -X POST "http://localhost/api/scdata/v1/manufacturingorders"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.DefaultApi;

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

public class DefaultApiExample {

    public static void main(String[] args) {

        DefaultApi apiInstance = new DefaultApi();
        MfgOrder body = ; // MfgOrder | 
        try {
            MfgOrder result = apiInstance.createMfgOrder(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#createMfgOrder");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.DefaultApi;

public class DefaultApiExample {

    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        MfgOrder body = ; // MfgOrder | 
        try {
            MfgOrder result = apiInstance.createMfgOrder(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#createMfgOrder");
            e.printStackTrace();
        }
    }
}
MfgOrder *body = ; // 

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

[apiInstance createMfgOrderWith:body

              completionHandler: ^(MfgOrder output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var IrisSupplyChainDataModelApi = require('iris_supply_chain_data_model_api');

var api = new IrisSupplyChainDataModelApi.DefaultApi()

var body = ; // {MfgOrder} 


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

namespace Example
{
    public class createMfgOrderExample

    {
        public void main()
        {

            var apiInstance = new DefaultApi();
            var body = new MfgOrder(); // MfgOrder | 

            try
            {
                MfgOrder result = apiInstance.createMfgOrder(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DefaultApi.createMfgOrder: " + e.Message );
            }
        }
    }
}
<?php

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

$api_instance = new Swagger\Client\Api\DefaultApi();
$body = ; // MfgOrder | 

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

my $api_instance = WWW::SwaggerClient::DefaultApi->new();
my $body = WWW::SwaggerClient::Object::MfgOrder->new(); # MfgOrder | 

eval {
    my $result = $api_instance->createMfgOrder(body => $body);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->createMfgOrder: $@\n";
}
from __future__ import print_statement

import time

import swagger_client

from swagger_client.rest import ApiException
from pprint import pprint


# create an instance of the API class
api_instance = swagger_client.DefaultApi()
body =  # MfgOrder | 

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

Parameters

Body parameters
Name Description
body *
{
Required: uid
uid:
string
workDescription:
string
orderStatus:
string
workLocationId:
string
orderEntryDate:
string (date-time)
salesOrderId:
string
salesOrderLineNumber:
string
productId:
string
quantity:
number
unitOfMeasure:
string
notes:
string
plannedStartDate:
string (date-time)
plannedEndDate:
string (date-time)
actualStartDate:
string (date-time)
actualEndDate:
string (date-time)
}

Responses

Status: 200 - Details of the newly created object

{
Required: uid
uid:
string
workDescription:
string
orderStatus:
string
workLocationId:
string
orderEntryDate:
string (date-time)
salesOrderId:
string
salesOrderLineNumber:
string
productId:
string
quantity:
number
unitOfMeasure:
string
notes:
string
plannedStartDate:
string (date-time)
plannedEndDate:
string (date-time)
actualStartDate:
string (date-time)
actualEndDate:
string (date-time)
}

Status: 400 - Invalid message body

Status: 500 - Server error

createMilestone

Add a new milestone


/milestones

Usage and SDK Samples

curl -X POST "http://localhost/api/scdata/v1/milestones"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.DefaultApi;

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

public class DefaultApiExample {

    public static void main(String[] args) {

        DefaultApi apiInstance = new DefaultApi();
        Milestone body = ; // Milestone | 
        try {
            Milestone result = apiInstance.createMilestone(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#createMilestone");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.DefaultApi;

public class DefaultApiExample {

    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        Milestone body = ; // Milestone | 
        try {
            Milestone result = apiInstance.createMilestone(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#createMilestone");
            e.printStackTrace();
        }
    }
}
Milestone *body = ; // 

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

[apiInstance createMilestoneWith:body

              completionHandler: ^(Milestone output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var IrisSupplyChainDataModelApi = require('iris_supply_chain_data_model_api');

var api = new IrisSupplyChainDataModelApi.DefaultApi()

var body = ; // {Milestone} 


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

namespace Example
{
    public class createMilestoneExample

    {
        public void main()
        {

            var apiInstance = new DefaultApi();
            var body = new Milestone(); // Milestone | 

            try
            {
                Milestone result = apiInstance.createMilestone(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DefaultApi.createMilestone: " + e.Message );
            }
        }
    }
}
<?php

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

$api_instance = new Swagger\Client\Api\DefaultApi();
$body = ; // Milestone | 

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

my $api_instance = WWW::SwaggerClient::DefaultApi->new();
my $body = WWW::SwaggerClient::Object::Milestone->new(); # Milestone | 

eval {
    my $result = $api_instance->createMilestone(body => $body);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->createMilestone: $@\n";
}
from __future__ import print_statement

import time

import swagger_client

from swagger_client.rest import ApiException
from pprint import pprint


# create an instance of the API class
api_instance = swagger_client.DefaultApi()
body =  # Milestone | 

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

Parameters

Body parameters
Name Description
body *
{
Required: uid
uid:
string
name:
string
milestoneNumber:
number
description:
string
associatedObjectType:
string
associatedObjectId:
string
milestoneOwner:
string
notes:
string
status:
string
plannedStartDate:
string (date-time)
plannedEndDate:
string (date-time)
actualStartDate:
string (date-time)
actualEndDate:
string (date-time)
}

Responses

Status: 200 - Details of the newly created object

{
Required: uid
uid:
string
name:
string
milestoneNumber:
number
description:
string
associatedObjectType:
string
associatedObjectId:
string
milestoneOwner:
string
notes:
string
status:
string
plannedStartDate:
string (date-time)
plannedEndDate:
string (date-time)
actualStartDate:
string (date-time)
actualEndDate:
string (date-time)
}

Status: 400 - Invalid message body

Status: 500 - Server error

createProduct

Add a new product


/products

Usage and SDK Samples

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

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

public class DefaultApiExample {

    public static void main(String[] args) {

        DefaultApi apiInstance = new DefaultApi();
        Product body = ; // Product | 
        try {
            Product result = apiInstance.createProduct(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#createProduct");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.DefaultApi;

public class DefaultApiExample {

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

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

[apiInstance createProductWith:body

              completionHandler: ^(Product output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var IrisSupplyChainDataModelApi = require('iris_supply_chain_data_model_api');

var api = new IrisSupplyChainDataModelApi.DefaultApi()

var body = ; // {Product} 


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

namespace Example
{
    public class createProductExample

    {
        public void main()
        {

            var apiInstance = new DefaultApi();
            var body = new Product(); // Product | 

            try
            {
                Product result = apiInstance.createProduct(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DefaultApi.createProduct: " + e.Message );
            }
        }
    }
}
<?php

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

$api_instance = new Swagger\Client\Api\DefaultApi();
$body = ; // Product | 

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

my $api_instance = WWW::SwaggerClient::DefaultApi->new();
my $body = WWW::SwaggerClient::Object::Product->new(); # Product | 

eval {
    my $result = $api_instance->createProduct(body => $body);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->createProduct: $@\n";
}
from __future__ import print_statement

import time

import swagger_client

from swagger_client.rest import ApiException
from pprint import pprint


# create an instance of the API class
api_instance = swagger_client.DefaultApi()
body =  # Product | 

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

Parameters

Body parameters
Name Description
body *
{
Required: uid
uid:
string
name:
string
productClass:
string
productCategory:
string
productBrand:
string
productFamily:
string
productSegment:
string
productNumber:
string
description:
string
type:
string
status:
string
gtin:
string
defaultUom:
string
shelfLife:
number
agingThreshold:
number
}

Responses

Status: 200 - Details of the created product

{
Required: uid
uid:
string
name:
string
productClass:
string
productCategory:
string
productBrand:
string
productFamily:
string
productSegment:
string
productNumber:
string
description:
string
type:
string
status:
string
gtin:
string
defaultUom:
string
shelfLife:
number
agingThreshold:
number
}

Status: 400 - Invalid message body

Status: 500 - Server error

createProductInventory

Add a new product inventory


/productinventories

Usage and SDK Samples

curl -X POST "http://localhost/api/scdata/v1/productinventories"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.DefaultApi;

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

public class DefaultApiExample {

    public static void main(String[] args) {

        DefaultApi apiInstance = new DefaultApi();
        ProductInventory body = ; // ProductInventory | 
        try {
            ProductInventory result = apiInstance.createProductInventory(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#createProductInventory");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.DefaultApi;

public class DefaultApiExample {

    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        ProductInventory body = ; // ProductInventory | 
        try {
            ProductInventory result = apiInstance.createProductInventory(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#createProductInventory");
            e.printStackTrace();
        }
    }
}
ProductInventory *body = ; // 

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

[apiInstance createProductInventoryWith:body

              completionHandler: ^(ProductInventory output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var IrisSupplyChainDataModelApi = require('iris_supply_chain_data_model_api');

var api = new IrisSupplyChainDataModelApi.DefaultApi()

var body = ; // {ProductInventory} 


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

namespace Example
{
    public class createProductInventoryExample

    {
        public void main()
        {

            var apiInstance = new DefaultApi();
            var body = new ProductInventory(); // ProductInventory | 

            try
            {
                ProductInventory result = apiInstance.createProductInventory(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DefaultApi.createProductInventory: " + e.Message );
            }
        }
    }
}
<?php

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

$api_instance = new Swagger\Client\Api\DefaultApi();
$body = ; // ProductInventory | 

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

my $api_instance = WWW::SwaggerClient::DefaultApi->new();
my $body = WWW::SwaggerClient::Object::ProductInventory->new(); # ProductInventory | 

eval {
    my $result = $api_instance->createProductInventory(body => $body);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->createProductInventory: $@\n";
}
from __future__ import print_statement

import time

import swagger_client

from swagger_client.rest import ApiException
from pprint import pprint


# create an instance of the API class
api_instance = swagger_client.DefaultApi()
body =  # ProductInventory | 

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

Parameters

Body parameters
Name Description
body *
{
Required: uid
uid:
string
siteLocationId:
string
productId:
string
locationNumber:
string
lotNumber:
string
quantity:
number
quantityUom:
string
storageDate:
string (date-time)
expirationDate:
string (date-time)
status:
string
inventoryType:
string
inventoryClass:
string
inventoryValue:
number
valueCurrency:
string
quantityReserved:
number
quantityReservedUom:
string
}

Responses

Status: 200 - Details of the created product inventory

{
Required: uid
uid:
string
siteLocationId:
string
productId:
string
locationNumber:
string
lotNumber:
string
quantity:
number
quantityUom:
string
storageDate:
string (date-time)
expirationDate:
string (date-time)
status:
string
inventoryType:
string
inventoryClass:
string
inventoryValue:
number
valueCurrency:
string
quantityReserved:
number
quantityReservedUom:
string
}

Status: 400 - Invalid message body

Status: 500 - Server error

createProductSupplier

Add a new product supplier


/productsuppliers

Usage and SDK Samples

curl -X POST "http://localhost/api/scdata/v1/productsuppliers"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.DefaultApi;

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

public class DefaultApiExample {

    public static void main(String[] args) {

        DefaultApi apiInstance = new DefaultApi();
        ProductSupplier body = ; // ProductSupplier | 
        try {
            ProductSupplier result = apiInstance.createProductSupplier(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#createProductSupplier");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.DefaultApi;

public class DefaultApiExample {

    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        ProductSupplier body = ; // ProductSupplier | 
        try {
            ProductSupplier result = apiInstance.createProductSupplier(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#createProductSupplier");
            e.printStackTrace();
        }
    }
}
ProductSupplier *body = ; // 

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

[apiInstance createProductSupplierWith:body

              completionHandler: ^(ProductSupplier output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var IrisSupplyChainDataModelApi = require('iris_supply_chain_data_model_api');

var api = new IrisSupplyChainDataModelApi.DefaultApi()

var body = ; // {ProductSupplier} 


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

namespace Example
{
    public class createProductSupplierExample

    {
        public void main()
        {

            var apiInstance = new DefaultApi();
            var body = new ProductSupplier(); // ProductSupplier | 

            try
            {
                ProductSupplier result = apiInstance.createProductSupplier(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DefaultApi.createProductSupplier: " + e.Message );
            }
        }
    }
}
<?php

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

$api_instance = new Swagger\Client\Api\DefaultApi();
$body = ; // ProductSupplier | 

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

my $api_instance = WWW::SwaggerClient::DefaultApi->new();
my $body = WWW::SwaggerClient::Object::ProductSupplier->new(); # ProductSupplier | 

eval {
    my $result = $api_instance->createProductSupplier(body => $body);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->createProductSupplier: $@\n";
}
from __future__ import print_statement

import time

import swagger_client

from swagger_client.rest import ApiException
from pprint import pprint


# create an instance of the API class
api_instance = swagger_client.DefaultApi()
body =  # ProductSupplier | 

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

Parameters

Body parameters
Name Description
body *
{
Required: uid
uid:
string
productId:
string
supplierId:
string
supplierType:
string
hasContract:
number
unitPrice:
number
currency:
string
unitOfMeasure:
string
supplierStatus:
string
leadTime:
number
leadTimeUnit:
string
effectiveStartDate:
string (date-time)
effectiveEndDate:
string (date-time)
}

Responses

Status: 200 - Details of the newly created object

{
Required: uid
uid:
string
productId:
string
supplierId:
string
supplierType:
string
hasContract:
number
unitPrice:
number
currency:
string
unitOfMeasure:
string
supplierStatus:
string
leadTime:
number
leadTimeUnit:
string
effectiveStartDate:
string (date-time)
effectiveEndDate:
string (date-time)
}

Status: 400 - Invalid message body

Status: 500 - Server error

createProductionCapacity

Add a new production capacity


/productioncapacities

Usage and SDK Samples

curl -X POST "http://localhost/api/scdata/v1/productioncapacities"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.DefaultApi;

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

public class DefaultApiExample {

    public static void main(String[] args) {

        DefaultApi apiInstance = new DefaultApi();
        ProductionCapacity body = ; // ProductionCapacity | 
        try {
            ProductionCapacity result = apiInstance.createProductionCapacity(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#createProductionCapacity");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.DefaultApi;

public class DefaultApiExample {

    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        ProductionCapacity body = ; // ProductionCapacity | 
        try {
            ProductionCapacity result = apiInstance.createProductionCapacity(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#createProductionCapacity");
            e.printStackTrace();
        }
    }
}
ProductionCapacity *body = ; // 

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

[apiInstance createProductionCapacityWith:body

              completionHandler: ^(ProductionCapacity output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var IrisSupplyChainDataModelApi = require('iris_supply_chain_data_model_api');

var api = new IrisSupplyChainDataModelApi.DefaultApi()

var body = ; // {ProductionCapacity} 


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

namespace Example
{
    public class createProductionCapacityExample

    {
        public void main()
        {

            var apiInstance = new DefaultApi();
            var body = new ProductionCapacity(); // ProductionCapacity | 

            try
            {
                ProductionCapacity result = apiInstance.createProductionCapacity(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DefaultApi.createProductionCapacity: " + e.Message );
            }
        }
    }
}
<?php

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

$api_instance = new Swagger\Client\Api\DefaultApi();
$body = ; // ProductionCapacity | 

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

my $api_instance = WWW::SwaggerClient::DefaultApi->new();
my $body = WWW::SwaggerClient::Object::ProductionCapacity->new(); # ProductionCapacity | 

eval {
    my $result = $api_instance->createProductionCapacity(body => $body);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->createProductionCapacity: $@\n";
}
from __future__ import print_statement

import time

import swagger_client

from swagger_client.rest import ApiException
from pprint import pprint


# create an instance of the API class
api_instance = swagger_client.DefaultApi()
body =  # ProductionCapacity | 

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

Parameters

Body parameters
Name Description
body *
{
Required: uid
uid:
string
facilityId:
string
productId:
string
bandwidth:
number
bandwidthUom:
string
leadTime:
number
leadTimeUom:
string
unitCost:
number
costCurrency:
string
status:
string
}

Responses

Status: 200 - Details of the newly created production capacity

{
Required: uid
uid:
string
facilityId:
string
productId:
string
bandwidth:
number
bandwidthUom:
string
leadTime:
number
leadTimeUom:
string
unitCost:
number
costCurrency:
string
status:
string
}

Status: 400 - Invalid message body

Status: 500 - Server error

createPurchaseOrder

Create an purchase order


/purchaseorders

Usage and SDK Samples

curl -X POST "http://localhost/api/scdata/v1/purchaseorders"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.DefaultApi;

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

public class DefaultApiExample {

    public static void main(String[] args) {

        DefaultApi apiInstance = new DefaultApi();
        PurchaseOrder body = ; // PurchaseOrder | 
        try {
            apiInstance.createPurchaseOrder(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#createPurchaseOrder");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.DefaultApi;

public class DefaultApiExample {

    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        PurchaseOrder body = ; // PurchaseOrder | 
        try {
            apiInstance.createPurchaseOrder(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#createPurchaseOrder");
            e.printStackTrace();
        }
    }
}
PurchaseOrder *body = ; // 

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

[apiInstance createPurchaseOrderWith:body

              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var IrisSupplyChainDataModelApi = require('iris_supply_chain_data_model_api');

var api = new IrisSupplyChainDataModelApi.DefaultApi()

var body = ; // {PurchaseOrder} 


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

namespace Example
{
    public class createPurchaseOrderExample

    {
        public void main()
        {

            var apiInstance = new DefaultApi();
            var body = new PurchaseOrder(); // PurchaseOrder | 

            try
            {
                apiInstance.createPurchaseOrder(body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DefaultApi.createPurchaseOrder: " + e.Message );
            }
        }
    }
}
<?php

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

$api_instance = new Swagger\Client\Api\DefaultApi();
$body = ; // PurchaseOrder | 

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

my $api_instance = WWW::SwaggerClient::DefaultApi->new();
my $body = WWW::SwaggerClient::Object::PurchaseOrder->new(); # PurchaseOrder | 

eval {
    $api_instance->createPurchaseOrder(body => $body);
};
if ($@) {
    warn "Exception when calling DefaultApi->createPurchaseOrder: $@\n";
}
from __future__ import print_statement

import time

import swagger_client

from swagger_client.rest import ApiException
from pprint import pprint


# create an instance of the API class
api_instance = swagger_client.DefaultApi()
body =  # PurchaseOrder | 

try:
    api_instance.create_purchase_order(body)
except ApiException as e:
    print("Exception when calling DefaultApi->createPurchaseOrder: %s\n" % e)

Parameters

Body parameters
Name Description
body *
{
Required: uid
uid:
string
orderStatus:
string
supplierId:
string
type:
string
requestedShipDate:
string (date-time)
requestedDeliveryDate:
string (date-time)
committedShipDate:
string (date-time)
committedDeliveryDate:
string (date-time)
orderPlacedDate:
string (date-time)
changeOrderDate:
string (date-time)
lastModifiedDate:
string (date-time)
shipToLocationId:
string
orderValue:
number
orderCurrency:
string
dataSource:
string
sourceOrderId:
string
lineItems:
[
{
Required: uid
uid:
string
lineNumber:
string
purchaseOrderId:
string
productId:
string
quantity:
number
unitOfMeasure:
string
value:
number
requestedShipDate:
string (date-time)
requestedDeliveryDate:
string (date-time)
status:
string
type:
string
shipToLocationId:
string
}
]
}

Responses

Status: 200 - Success

Status: 400 - Invalid message body

Status: 500 - Server error

createPurchaseOrderLine

Create an purchase order line


/purchaseorderlines

Usage and SDK Samples

curl -X POST "http://localhost/api/scdata/v1/purchaseorderlines"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.DefaultApi;

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

public class DefaultApiExample {

    public static void main(String[] args) {

        DefaultApi apiInstance = new DefaultApi();
        PurchaseOrderLine body = ; // PurchaseOrderLine | 
        try {
            apiInstance.createPurchaseOrderLine(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#createPurchaseOrderLine");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.DefaultApi;

public class DefaultApiExample {

    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        PurchaseOrderLine body = ; // PurchaseOrderLine | 
        try {
            apiInstance.createPurchaseOrderLine(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#createPurchaseOrderLine");
            e.printStackTrace();
        }
    }
}
PurchaseOrderLine *body = ; // 

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

[apiInstance createPurchaseOrderLineWith:body

              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var IrisSupplyChainDataModelApi = require('iris_supply_chain_data_model_api');

var api = new IrisSupplyChainDataModelApi.DefaultApi()

var body = ; // {PurchaseOrderLine} 


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

namespace Example
{
    public class createPurchaseOrderLineExample

    {
        public void main()
        {

            var apiInstance = new DefaultApi();
            var body = new PurchaseOrderLine(); // PurchaseOrderLine | 

            try
            {
                apiInstance.createPurchaseOrderLine(body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DefaultApi.createPurchaseOrderLine: " + e.Message );
            }
        }
    }
}
<?php

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

$api_instance = new Swagger\Client\Api\DefaultApi();
$body = ; // PurchaseOrderLine | 

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

my $api_instance = WWW::SwaggerClient::DefaultApi->new();
my $body = WWW::SwaggerClient::Object::PurchaseOrderLine->new(); # PurchaseOrderLine | 

eval {
    $api_instance->createPurchaseOrderLine(body => $body);
};
if ($@) {
    warn "Exception when calling DefaultApi->createPurchaseOrderLine: $@\n";
}
from __future__ import print_statement

import time

import swagger_client

from swagger_client.rest import ApiException
from pprint import pprint


# create an instance of the API class
api_instance = swagger_client.DefaultApi()
body =  # PurchaseOrderLine | 

try:
    api_instance.create_purchase_order_line(body)
except ApiException as e:
    print("Exception when calling DefaultApi->createPurchaseOrderLine: %s\n" % e)

Parameters

Body parameters
Name Description
body *
{
Required: uid
uid:
string
lineNumber:
string
purchaseOrderId:
string
productId:
string
quantity:
number
unitOfMeasure:
string
value:
number
requestedShipDate:
string (date-time)
requestedDeliveryDate:
string (date-time)
status:
string
type:
string
shipToLocationId:
string
}

Responses

Status: 200 - Success

Status: 400 - Invalid message body

Status: 500 - Server error

createSLA

Add a new SLA


/slas

Usage and SDK Samples

curl -X POST "http://localhost/api/scdata/v1/slas"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.DefaultApi;

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

public class DefaultApiExample {

    public static void main(String[] args) {

        DefaultApi apiInstance = new DefaultApi();
        SLA body = ; // SLA | 
        try {
            SLA result = apiInstance.createSLA(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#createSLA");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.DefaultApi;

public class DefaultApiExample {

    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        SLA body = ; // SLA | 
        try {
            SLA result = apiInstance.createSLA(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#createSLA");
            e.printStackTrace();
        }
    }
}
SLA *body = ; // 

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

[apiInstance createSLAWith:body

              completionHandler: ^(SLA output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var IrisSupplyChainDataModelApi = require('iris_supply_chain_data_model_api');

var api = new IrisSupplyChainDataModelApi.DefaultApi()

var body = ; // {SLA} 


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

namespace Example
{
    public class createSLAExample

    {
        public void main()
        {

            var apiInstance = new DefaultApi();
            var body = new SLA(); // SLA | 

            try
            {
                SLA result = apiInstance.createSLA(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DefaultApi.createSLA: " + e.Message );
            }
        }
    }
}
<?php

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

$api_instance = new Swagger\Client\Api\DefaultApi();
$body = ; // SLA | 

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

my $api_instance = WWW::SwaggerClient::DefaultApi->new();
my $body = WWW::SwaggerClient::Object::SLA->new(); # SLA | 

eval {
    my $result = $api_instance->createSLA(body => $body);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DefaultApi->createSLA: $@\n";
}
from __future__ import print_statement

import time

import swagger_client

from swagger_client.rest import ApiException
from pprint import pprint


# create an instance of the API class
api_instance = swagger_client.DefaultApi()
body =  # SLA | 

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

Parameters

Body parameters
Name Description
body *
{
Required: uid
uid:
string
type:
string
productId:
string
productBrand:
string
productFamily:
string
operation:
string
cycleTime:
number
cycleTimeUnit:
string
upperBound:
number
lowerBound:
number
boundUnit:
string
}

Responses

Status: 200 - Details of the newly created object

{
Required: uid
uid:
string
type:
string
productId:
string
productBrand:
string
productFamily:
string
operation:
string
cycleTime:
number
cycleTimeUnit:
string
upperBound:
number
lowerBound:
number
boundUnit:
string
}

Status: 400 - Invalid message body

Status: 500 - Server error

createSalesOrder

Create an sales order


/salesorders

Usage and SDK Samples

curl -X POST "http://localhost/api/scdata/v1/salesorders"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.DefaultApi;

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

public class DefaultApiExample {

    public static void main(String[] args) {

        DefaultApi apiInstance = new DefaultApi();
        SalesOrder body = ; // SalesOrder | 
        try {
            apiInstance.createSalesOrder(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#createSalesOrder");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.DefaultApi;

public class DefaultApiExample {

    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        SalesOrder body = ; // SalesOrder | 
        try {
            apiInstance.createSalesOrder(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#createSalesOrder");
            e.printStackTrace();
        }
    }
}
SalesOrder *body = ; // 

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

[apiInstance createSalesOrderWith:body

              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var IrisSupplyChainDataModelApi = require('iris_supply_chain_data_model_api');

var api = new IrisSupplyChainDataModelApi.DefaultApi()

var body = ; // {SalesOrder} 


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

namespace Example
{
    public class createSalesOrderExample

    {
        public void main()
        {

            var apiInstance = new DefaultApi();
            var body = new SalesOrder(); // SalesOrder | 

            try
            {
                apiInstance.createSalesOrder(body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DefaultApi.createSalesOrder: " + e.Message );
            }
        }
    }
}
<?php

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

$api_instance = new Swagger\Client\Api\DefaultApi();
$body = ; // SalesOrder | 

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

my $api_instance = WWW::SwaggerClient::DefaultApi->new();
my $body = WWW::SwaggerClient::Object::SalesOrder->new(); # SalesOrder | 

eval {
    $api_instance->createSalesOrder(body => $body);
};
if ($@) {
    warn "Exception when calling DefaultApi->createSalesOrder: $@\n";
}
from __future__ import print_statement

import time

import swagger_client

from swagger_client.rest import ApiException
from pprint import pprint


# create an instance of the API class
api_instance = swagger_client.DefaultApi()
body =  # SalesOrder | 

try:
    api_instance.create_sales_order(body)
except ApiException as e:
    print("Exception when calling DefaultApi->createSalesOrder: %s\n" % e)

Parameters

Body parameters
Name Description
body *
{
Required: uid
uid:
string
orderStatus:
string
customerId:
string
customerPoNumber:
string
requestedShipDate:
string (date-time)
requestedDeliveryDate:
string (date-time)
committedShipDate:
string (date-time)
committedDeliveryDate:
string (date-time)
orderPlacedDate:
string (date-time)
changeOrderDate:
string (date-time)
lastModifiedDate:
string (date-time)
shipToLocationId:
string
orderValue:
number
orderCurrency:
string
dataSource:
string
sourceOrderId:
string
salesOrganization:
string
salesRegion:
string
lineItems:
[
{
Required: uid
uid:
string
lineNumber:
string
salesOrderId:
string
productId:
string
quantity:
number
unitOfMeasure:
string
value:
number
requestedShipDate:
string (date-time)
requestedDeliveryDate:
string (date-time)
status:
string
type:
string
shipToLocationId:
string
}
]
}

Responses

Status: 200 - Success

Status: 400 - Invalid message body

Status: 500 - Server error

createSalesOrderLine

Create an sales order line


/salesorderlines

Usage and SDK Samples

curl -X POST "http://localhost/api/scdata/v1/salesorderlines"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.DefaultApi;

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

public class DefaultApiExample {

    public static void main(String[] args) {

        DefaultApi apiInstance = new DefaultApi();
        SalesOrderLine body = ; // SalesOrderLine | 
        try {
            apiInstance.createSalesOrderLine(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#createSalesOrderLine");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.DefaultApi;

public class DefaultApiExample {

    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        SalesOrderLine body = ; // SalesOrderLine | 
        try {
            apiInstance.createSalesOrderLine(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#createSalesOrderLine");
            e.printStackTrace();
        }
    }
}
SalesOrderLine *body = ; // 

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

[apiInstance createSalesOrderLineWith:body

              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var IrisSupplyChainDataModelApi = require('iris_supply_chain_data_model_api');

var api = new IrisSupplyChainDataModelApi.DefaultApi()

var body = ; // {SalesOrderLine} 


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

namespace Example
{
    public class createSalesOrderLineExample

    {
        public void main()
        {

            var apiInstance = new DefaultApi();
            var body = new SalesOrderLine(); // SalesOrderLine | 

            try
            {
                apiInstance.createSalesOrderLine(body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DefaultApi.createSalesOrderLine: " + e.Message );
            }
        }
    }
}
<?php

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

$api_instance = new Swagger\Client\Api\DefaultApi();
$body = ; // SalesOrderLine | 

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

my $api_instance = WWW::SwaggerClient::DefaultApi->new();
my $body = WWW::SwaggerClient::Object::SalesOrderLine->new(); # SalesOrderLine | 

eval {
    $api_instance->createSalesOrderLine(body => $body);
};
if ($@) {
    warn "Exception when calling DefaultApi->createSalesOrderLine: $@\n";
}
from __future__ import print_statement

import time

import swagger_client

from swagger_client.rest import ApiException
from pprint import pprint


# create an instance of the API class
api_instance = swagger_client.DefaultApi()
body =  # SalesOrderLine | 

try:
    api_instance.create_sales_order_line(body)
except ApiException as e:
    print("Exception when calling DefaultApi->createSalesOrderLine: %s\n" % e)

Parameters

Body parameters
Name Description
body *
{
Required: uid
uid:
string
lineNumber:
string
salesOrderId:
string
productId:
string
quantity:
number
unitOfMeasure:
string
value:
number
requestedShipDate:
string (date-time)
requestedDeliveryDate:
string (date-time)
status:
string
type:
string
shipToLocationId:
string
}

Responses

Status: 200 - Success

Status: 400 - Invalid message body

Status: 500 - Server error

createSalesShipment

Create an sales shipment


/salesshipments

Usage and SDK Samples

curl -X POST "http://localhost/api/scdata/v1/salesshipments"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.DefaultApi;

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

public class DefaultApiExample {

    public static void main(String[] args) {

        DefaultApi apiInstance = new DefaultApi();
        SalesShipment body = ; // SalesShipment | 
        try {
            apiInstance.createSalesShipment(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#createSalesShipment");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.DefaultApi;

public class DefaultApiExample {

    public static void main(String[] args) {
        DefaultApi apiInstance = new DefaultApi();
        SalesShipment body = ; // SalesShipment | 
        try {
            apiInstance.createSalesShipment(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling DefaultApi#createSalesShipment");
            e.printStackTrace();
        }
    }
}
SalesShipment *body = ; // 

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

[apiInstance createSalesShipmentWith:body

              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];
var IrisSupplyChainDataModelApi = require('iris_supply_chain_data_model_api');

var api = new IrisSupplyChainDataModelApi.DefaultApi()

var body = ; // {SalesShipment} 


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

namespace Example
{
    public class createSalesShipmentExample

    {
        public void main()
        {

            var apiInstance = new DefaultApi();
            var body = new SalesShipment(); // SalesShipment | 

            try
            {
                apiInstance.createSalesShipment(body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DefaultApi.createSalesShipment: " + e.Message );
            }
        }
    }
}
<?php

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

$api_instance = new Swagger\Client\Api\DefaultApi();
$body = ; // SalesShipment | 

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

my $api_instance = WWW::SwaggerClient::DefaultApi->new();
my $body = WWW::SwaggerClient::Object::SalesShipment->new(); # SalesShipment | 

eval {
    $api_instance->createSalesShipment(body => $body);
};
if ($@) {
    warn "Exception when calling DefaultApi->createSalesShipment: $@\n";
}
from __future__ import print_statement

import time

import swagger_client

from swagger_client.rest import ApiException
from pprint import pprint


# create an instance of the API class
api_instance = swagger_client.DefaultApi()
body =  # SalesShipment | 

try:
    api_instance.create_sales_shipment(body)
except ApiException as e:
    print("Exception when calling DefaultApi->createSalesShipment: %s\n" % e)

Parameters

Body parameters
Name Description
body *
{
Required: uid
uid:
string
status:
string
substatus:
string
customerID:
string
type:
string
weight:
string
weightUom:
string
hoursDelayed:
number
trackStartDateTime:
string (date-time)
currentStatusCityName:
string
notifyCarrier:
integer maximum:1
carrierId:
string
originLocationId:
string
destinationLocationId:
string
freightForwarder:
string
billOfLandingNumber:
string
shipmentCategory:
string
carrierBookingNumber:
string
masterAirWaybillNumber:
string
parcelTrackingNumber:
string
houseAirwayBill:
string
externalShipmentID:
string
carrierContainer:
string
transportMode:
string
shipperAccountNumber:
string
shipperName:
string
shippingCost:
number
shippingCostCurrency:
string
requestedTimeOfArrival:
string (date-time)
committedTimeOfArrival:
string (date-time)
actualShipDate:
string (date-time)
estimatedTimeOfArrival:
string (date-time)
updatedEta:
string (date-time)
predictedTimeOfArrival:
string (date-time)
actualTimeOfArrival:
string (date-time)
deliveredDateTime:
string (date-time)