Vending Machine API Document (Call back) - Connectivity Platform - Vending on Track

DataFeedCallbackAPI

feedAlertsPost

Send a vending machine alert to the third party platform

/feed/alerts

Usage and SDK Samples

curl -X POST \
 -H "Authorization: Basic [[basicHash]]" \
-H "X-API-Key: [[apiKey]]" \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "https://3rdparty.connectivityPlatformIntegration.com/feed/alerts" \
 -d '{
  "vm_id" : "vm_id",
  "level" : "level",
  "time" : 0,
  "message" : "message"
}'

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DataFeedCallbackAPIApi;

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

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

        // Configure API key authorization: ApiKeyAuth
        ApiKeyAuth ApiKeyAuth = (ApiKeyAuth) defaultClient.getAuthentication("ApiKeyAuth");
        ApiKeyAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //ApiKeyAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        DataFeedCallbackAPIApi apiInstance = new DataFeedCallbackAPIApi();
        AlertNotification alertNotification = ; // AlertNotification | 

        try {
            CallbackResponse result = apiInstance.feedAlertsPost(alertNotification);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DataFeedCallbackAPIApi#feedAlertsPost");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final AlertNotification alertNotification = new AlertNotification(); // AlertNotification | 

try {
    final result = await api_instance.feedAlertsPost(alertNotification);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->feedAlertsPost: $e\n');
}

import org.openapitools.client.api.DataFeedCallbackAPIApi;

public class DataFeedCallbackAPIApiExample {
    public static void main(String[] args) {
        DataFeedCallbackAPIApi apiInstance = new DataFeedCallbackAPIApi();
        AlertNotification alertNotification = ; // AlertNotification | 

        try {
            CallbackResponse result = apiInstance.feedAlertsPost(alertNotification);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DataFeedCallbackAPIApi#feedAlertsPost");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: BasicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];
// Configure API key authorization: (authentication scheme: ApiKeyAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"X-API-Key"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"X-API-Key"];


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

// Send a vending machine alert to the third party platform
[apiInstance feedAlertsPostWith:alertNotification
              completionHandler: ^(CallbackResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var VendingMachineApiDocumentCallBackConnectivityPlatformVendingOnTrack = require('vending_machine_api_document__call_back_connectivity_platform_vending_on_track');
var defaultClient = VendingMachineApiDocumentCallBackConnectivityPlatformVendingOnTrack.ApiClient.instance;

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

// Configure API key authorization: ApiKeyAuth
var ApiKeyAuth = defaultClient.authentications['ApiKeyAuth'];
ApiKeyAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//ApiKeyAuth.apiKeyPrefix['X-API-Key'] = "Token";

// Create an instance of the API class
var api = new VendingMachineApiDocumentCallBackConnectivityPlatformVendingOnTrack.DataFeedCallbackAPIApi()
var alertNotification = ; // {AlertNotification} 

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

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

namespace Example
{
    public class feedAlertsPostExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: BasicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";
            // Configure API key authorization: ApiKeyAuth
            Configuration.Default.ApiKey.Add("X-API-Key", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("X-API-Key", "Bearer");

            // Create an instance of the API class
            var apiInstance = new DataFeedCallbackAPIApi();
            var alertNotification = new AlertNotification(); // AlertNotification | 

            try {
                // Send a vending machine alert to the third party platform
                CallbackResponse result = apiInstance.feedAlertsPost(alertNotification);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DataFeedCallbackAPIApi.feedAlertsPost: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');
// Configure HTTP basic authorization: BasicAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

// Configure API key authorization: ApiKeyAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('X-API-Key', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('X-API-Key', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DataFeedCallbackAPIApi();
$alertNotification = ; // AlertNotification | 

try {
    $result = $api_instance->feedAlertsPost($alertNotification);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DataFeedCallbackAPIApi->feedAlertsPost: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::DataFeedCallbackAPIApi;
# Configure HTTP basic authorization: BasicAuth
$WWW::OPenAPIClient::Configuration::username = 'YOUR_USERNAME';
$WWW::OPenAPIClient::Configuration::password = 'YOUR_PASSWORD';

# Configure API key authorization: ApiKeyAuth
$WWW::OPenAPIClient::Configuration::api_key->{'X-API-Key'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'X-API-Key'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DataFeedCallbackAPIApi->new();
my $alertNotification = WWW::OPenAPIClient::Object::AlertNotification->new(); # AlertNotification | 

eval {
    my $result = $api_instance->feedAlertsPost(alertNotification => $alertNotification);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DataFeedCallbackAPIApi->feedAlertsPost: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint
# Configure HTTP basic authorization: BasicAuth
openapi_client.configuration.username = 'YOUR_USERNAME'
openapi_client.configuration.password = 'YOUR_PASSWORD'

# Configure API key authorization: ApiKeyAuth
openapi_client.configuration.api_key['X-API-Key'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['X-API-Key'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.DataFeedCallbackAPIApi()
alertNotification =  # AlertNotification | 

try:
    # Send a vending machine alert to the third party platform
    api_response = api_instance.feed_alerts_post(alertNotification)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DataFeedCallbackAPIApi->feedAlertsPost: %s\n" % e)

extern crate DataFeedCallbackAPIApi;

pub fn main() {
    let alertNotification = ; // AlertNotification

    let mut context = DataFeedCallbackAPIApi::Context::default();
    let result = client.feedAlertsPost(alertNotification, &context).wait();

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

Scopes

Parameters

Body parameters

Name	Description
alertNotification *

Responses

Schema

feedButtonActionsPost

Notify the third party platform that a button on the telemetry box has been clicked

/feed/button_actions

Usage and SDK Samples

curl -X POST \
 -H "Authorization: Basic [[basicHash]]" \
-H "X-API-Key: [[apiKey]]" \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "https://3rdparty.connectivityPlatformIntegration.com/feed/button_actions" \
 -d '{
  "button" : 6,
  "vm_id" : "vm_id",
  "time" : 0
}'

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DataFeedCallbackAPIApi;

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

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

        // Configure API key authorization: ApiKeyAuth
        ApiKeyAuth ApiKeyAuth = (ApiKeyAuth) defaultClient.getAuthentication("ApiKeyAuth");
        ApiKeyAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //ApiKeyAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        DataFeedCallbackAPIApi apiInstance = new DataFeedCallbackAPIApi();
        ButtonActionNotification buttonActionNotification = ; // ButtonActionNotification | 

        try {
            CallbackResponse result = apiInstance.feedButtonActionsPost(buttonActionNotification);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DataFeedCallbackAPIApi#feedButtonActionsPost");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final ButtonActionNotification buttonActionNotification = new ButtonActionNotification(); // ButtonActionNotification | 

try {
    final result = await api_instance.feedButtonActionsPost(buttonActionNotification);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->feedButtonActionsPost: $e\n');
}

import org.openapitools.client.api.DataFeedCallbackAPIApi;

public class DataFeedCallbackAPIApiExample {
    public static void main(String[] args) {
        DataFeedCallbackAPIApi apiInstance = new DataFeedCallbackAPIApi();
        ButtonActionNotification buttonActionNotification = ; // ButtonActionNotification | 

        try {
            CallbackResponse result = apiInstance.feedButtonActionsPost(buttonActionNotification);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DataFeedCallbackAPIApi#feedButtonActionsPost");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: BasicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];
// Configure API key authorization: (authentication scheme: ApiKeyAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"X-API-Key"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"X-API-Key"];


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

// Notify the third party platform that a button on the telemetry box has been clicked
[apiInstance feedButtonActionsPostWith:buttonActionNotification
              completionHandler: ^(CallbackResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var VendingMachineApiDocumentCallBackConnectivityPlatformVendingOnTrack = require('vending_machine_api_document__call_back_connectivity_platform_vending_on_track');
var defaultClient = VendingMachineApiDocumentCallBackConnectivityPlatformVendingOnTrack.ApiClient.instance;

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

// Configure API key authorization: ApiKeyAuth
var ApiKeyAuth = defaultClient.authentications['ApiKeyAuth'];
ApiKeyAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//ApiKeyAuth.apiKeyPrefix['X-API-Key'] = "Token";

// Create an instance of the API class
var api = new VendingMachineApiDocumentCallBackConnectivityPlatformVendingOnTrack.DataFeedCallbackAPIApi()
var buttonActionNotification = ; // {ButtonActionNotification} 

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

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

namespace Example
{
    public class feedButtonActionsPostExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: BasicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";
            // Configure API key authorization: ApiKeyAuth
            Configuration.Default.ApiKey.Add("X-API-Key", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("X-API-Key", "Bearer");

            // Create an instance of the API class
            var apiInstance = new DataFeedCallbackAPIApi();
            var buttonActionNotification = new ButtonActionNotification(); // ButtonActionNotification | 

            try {
                // Notify the third party platform that a button on the telemetry box has been clicked
                CallbackResponse result = apiInstance.feedButtonActionsPost(buttonActionNotification);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DataFeedCallbackAPIApi.feedButtonActionsPost: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');
// Configure HTTP basic authorization: BasicAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

// Configure API key authorization: ApiKeyAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('X-API-Key', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('X-API-Key', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DataFeedCallbackAPIApi();
$buttonActionNotification = ; // ButtonActionNotification | 

try {
    $result = $api_instance->feedButtonActionsPost($buttonActionNotification);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DataFeedCallbackAPIApi->feedButtonActionsPost: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::DataFeedCallbackAPIApi;
# Configure HTTP basic authorization: BasicAuth
$WWW::OPenAPIClient::Configuration::username = 'YOUR_USERNAME';
$WWW::OPenAPIClient::Configuration::password = 'YOUR_PASSWORD';

# Configure API key authorization: ApiKeyAuth
$WWW::OPenAPIClient::Configuration::api_key->{'X-API-Key'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'X-API-Key'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DataFeedCallbackAPIApi->new();
my $buttonActionNotification = WWW::OPenAPIClient::Object::ButtonActionNotification->new(); # ButtonActionNotification | 

eval {
    my $result = $api_instance->feedButtonActionsPost(buttonActionNotification => $buttonActionNotification);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DataFeedCallbackAPIApi->feedButtonActionsPost: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint
# Configure HTTP basic authorization: BasicAuth
openapi_client.configuration.username = 'YOUR_USERNAME'
openapi_client.configuration.password = 'YOUR_PASSWORD'

# Configure API key authorization: ApiKeyAuth
openapi_client.configuration.api_key['X-API-Key'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['X-API-Key'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.DataFeedCallbackAPIApi()
buttonActionNotification =  # ButtonActionNotification | 

try:
    # Notify the third party platform that a button on the telemetry box has been clicked
    api_response = api_instance.feed_button_actions_post(buttonActionNotification)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DataFeedCallbackAPIApi->feedButtonActionsPost: %s\n" % e)

extern crate DataFeedCallbackAPIApi;

pub fn main() {
    let buttonActionNotification = ; // ButtonActionNotification

    let mut context = DataFeedCallbackAPIApi::Context::default();
    let result = client.feedButtonActionsPost(buttonActionNotification, &context).wait();

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

Scopes

Parameters

Body parameters

Name	Description
buttonActionNotification *

Responses

Schema

feedConnectPost

Notify the third party platform that a device has connected to the vending machine

Sent when a telemetry device establishes a connection and is associated with a vending machine. The connection_id can be used to correlate connect and disconnect events for the same session.

/feed/connect

Usage and SDK Samples

curl -X POST \
 -H "Authorization: Basic [[basicHash]]" \
-H "X-API-Key: [[apiKey]]" \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "https://3rdparty.connectivityPlatformIntegration.com/feed/connect" \
 -d '{
  "vmid" : "vmid",
  "connection_id" : "connection_id",
  "timestamp" : 0
}'

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DataFeedCallbackAPIApi;

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

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

        // Configure API key authorization: ApiKeyAuth
        ApiKeyAuth ApiKeyAuth = (ApiKeyAuth) defaultClient.getAuthentication("ApiKeyAuth");
        ApiKeyAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //ApiKeyAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        DataFeedCallbackAPIApi apiInstance = new DataFeedCallbackAPIApi();
        ConnectionNotification connectionNotification = ; // ConnectionNotification | 

        try {
            CallbackResponse result = apiInstance.feedConnectPost(connectionNotification);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DataFeedCallbackAPIApi#feedConnectPost");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final ConnectionNotification connectionNotification = new ConnectionNotification(); // ConnectionNotification | 

try {
    final result = await api_instance.feedConnectPost(connectionNotification);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->feedConnectPost: $e\n');
}

import org.openapitools.client.api.DataFeedCallbackAPIApi;

public class DataFeedCallbackAPIApiExample {
    public static void main(String[] args) {
        DataFeedCallbackAPIApi apiInstance = new DataFeedCallbackAPIApi();
        ConnectionNotification connectionNotification = ; // ConnectionNotification | 

        try {
            CallbackResponse result = apiInstance.feedConnectPost(connectionNotification);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DataFeedCallbackAPIApi#feedConnectPost");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: BasicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];
// Configure API key authorization: (authentication scheme: ApiKeyAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"X-API-Key"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"X-API-Key"];


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

// Notify the third party platform that a device has connected to the vending machine
[apiInstance feedConnectPostWith:connectionNotification
              completionHandler: ^(CallbackResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var VendingMachineApiDocumentCallBackConnectivityPlatformVendingOnTrack = require('vending_machine_api_document__call_back_connectivity_platform_vending_on_track');
var defaultClient = VendingMachineApiDocumentCallBackConnectivityPlatformVendingOnTrack.ApiClient.instance;

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

// Configure API key authorization: ApiKeyAuth
var ApiKeyAuth = defaultClient.authentications['ApiKeyAuth'];
ApiKeyAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//ApiKeyAuth.apiKeyPrefix['X-API-Key'] = "Token";

// Create an instance of the API class
var api = new VendingMachineApiDocumentCallBackConnectivityPlatformVendingOnTrack.DataFeedCallbackAPIApi()
var connectionNotification = ; // {ConnectionNotification} 

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

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

namespace Example
{
    public class feedConnectPostExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: BasicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";
            // Configure API key authorization: ApiKeyAuth
            Configuration.Default.ApiKey.Add("X-API-Key", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("X-API-Key", "Bearer");

            // Create an instance of the API class
            var apiInstance = new DataFeedCallbackAPIApi();
            var connectionNotification = new ConnectionNotification(); // ConnectionNotification | 

            try {
                // Notify the third party platform that a device has connected to the vending machine
                CallbackResponse result = apiInstance.feedConnectPost(connectionNotification);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DataFeedCallbackAPIApi.feedConnectPost: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');
// Configure HTTP basic authorization: BasicAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

// Configure API key authorization: ApiKeyAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('X-API-Key', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('X-API-Key', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DataFeedCallbackAPIApi();
$connectionNotification = ; // ConnectionNotification | 

try {
    $result = $api_instance->feedConnectPost($connectionNotification);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DataFeedCallbackAPIApi->feedConnectPost: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::DataFeedCallbackAPIApi;
# Configure HTTP basic authorization: BasicAuth
$WWW::OPenAPIClient::Configuration::username = 'YOUR_USERNAME';
$WWW::OPenAPIClient::Configuration::password = 'YOUR_PASSWORD';

# Configure API key authorization: ApiKeyAuth
$WWW::OPenAPIClient::Configuration::api_key->{'X-API-Key'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'X-API-Key'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DataFeedCallbackAPIApi->new();
my $connectionNotification = WWW::OPenAPIClient::Object::ConnectionNotification->new(); # ConnectionNotification | 

eval {
    my $result = $api_instance->feedConnectPost(connectionNotification => $connectionNotification);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DataFeedCallbackAPIApi->feedConnectPost: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint
# Configure HTTP basic authorization: BasicAuth
openapi_client.configuration.username = 'YOUR_USERNAME'
openapi_client.configuration.password = 'YOUR_PASSWORD'

# Configure API key authorization: ApiKeyAuth
openapi_client.configuration.api_key['X-API-Key'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['X-API-Key'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.DataFeedCallbackAPIApi()
connectionNotification =  # ConnectionNotification | 

try:
    # Notify the third party platform that a device has connected to the vending machine
    api_response = api_instance.feed_connect_post(connectionNotification)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DataFeedCallbackAPIApi->feedConnectPost: %s\n" % e)

extern crate DataFeedCallbackAPIApi;

pub fn main() {
    let connectionNotification = ; // ConnectionNotification

    let mut context = DataFeedCallbackAPIApi::Context::default();
    let result = client.feedConnectPost(connectionNotification, &context).wait();

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

Scopes

Parameters

Body parameters

Name	Description
connectionNotification *

Responses

Schema

feedDisconnectPost

Notify the third party platform that a device has disconnected from the vending machine

Sent when a telemetry device connection is closed. The connection_id matches the value from the corresponding /feed/connect callback, allowing third parties to calculate session duration and track connectivity patterns.

/feed/disconnect

Usage and SDK Samples

curl -X POST \
 -H "Authorization: Basic [[basicHash]]" \
-H "X-API-Key: [[apiKey]]" \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "https://3rdparty.connectivityPlatformIntegration.com/feed/disconnect" \
 -d '{
  "vmid" : "vmid",
  "connection_id" : "connection_id",
  "timestamp" : 0
}'

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DataFeedCallbackAPIApi;

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

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

        // Configure API key authorization: ApiKeyAuth
        ApiKeyAuth ApiKeyAuth = (ApiKeyAuth) defaultClient.getAuthentication("ApiKeyAuth");
        ApiKeyAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //ApiKeyAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        DataFeedCallbackAPIApi apiInstance = new DataFeedCallbackAPIApi();
        ConnectionNotification connectionNotification = ; // ConnectionNotification | 

        try {
            CallbackResponse result = apiInstance.feedDisconnectPost(connectionNotification);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DataFeedCallbackAPIApi#feedDisconnectPost");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final ConnectionNotification connectionNotification = new ConnectionNotification(); // ConnectionNotification | 

try {
    final result = await api_instance.feedDisconnectPost(connectionNotification);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->feedDisconnectPost: $e\n');
}

import org.openapitools.client.api.DataFeedCallbackAPIApi;

public class DataFeedCallbackAPIApiExample {
    public static void main(String[] args) {
        DataFeedCallbackAPIApi apiInstance = new DataFeedCallbackAPIApi();
        ConnectionNotification connectionNotification = ; // ConnectionNotification | 

        try {
            CallbackResponse result = apiInstance.feedDisconnectPost(connectionNotification);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DataFeedCallbackAPIApi#feedDisconnectPost");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: BasicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];
// Configure API key authorization: (authentication scheme: ApiKeyAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"X-API-Key"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"X-API-Key"];


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

// Notify the third party platform that a device has disconnected from the vending machine
[apiInstance feedDisconnectPostWith:connectionNotification
              completionHandler: ^(CallbackResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var VendingMachineApiDocumentCallBackConnectivityPlatformVendingOnTrack = require('vending_machine_api_document__call_back_connectivity_platform_vending_on_track');
var defaultClient = VendingMachineApiDocumentCallBackConnectivityPlatformVendingOnTrack.ApiClient.instance;

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

// Configure API key authorization: ApiKeyAuth
var ApiKeyAuth = defaultClient.authentications['ApiKeyAuth'];
ApiKeyAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//ApiKeyAuth.apiKeyPrefix['X-API-Key'] = "Token";

// Create an instance of the API class
var api = new VendingMachineApiDocumentCallBackConnectivityPlatformVendingOnTrack.DataFeedCallbackAPIApi()
var connectionNotification = ; // {ConnectionNotification} 

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

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

namespace Example
{
    public class feedDisconnectPostExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: BasicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";
            // Configure API key authorization: ApiKeyAuth
            Configuration.Default.ApiKey.Add("X-API-Key", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("X-API-Key", "Bearer");

            // Create an instance of the API class
            var apiInstance = new DataFeedCallbackAPIApi();
            var connectionNotification = new ConnectionNotification(); // ConnectionNotification | 

            try {
                // Notify the third party platform that a device has disconnected from the vending machine
                CallbackResponse result = apiInstance.feedDisconnectPost(connectionNotification);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DataFeedCallbackAPIApi.feedDisconnectPost: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');
// Configure HTTP basic authorization: BasicAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

// Configure API key authorization: ApiKeyAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('X-API-Key', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('X-API-Key', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DataFeedCallbackAPIApi();
$connectionNotification = ; // ConnectionNotification | 

try {
    $result = $api_instance->feedDisconnectPost($connectionNotification);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DataFeedCallbackAPIApi->feedDisconnectPost: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::DataFeedCallbackAPIApi;
# Configure HTTP basic authorization: BasicAuth
$WWW::OPenAPIClient::Configuration::username = 'YOUR_USERNAME';
$WWW::OPenAPIClient::Configuration::password = 'YOUR_PASSWORD';

# Configure API key authorization: ApiKeyAuth
$WWW::OPenAPIClient::Configuration::api_key->{'X-API-Key'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'X-API-Key'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DataFeedCallbackAPIApi->new();
my $connectionNotification = WWW::OPenAPIClient::Object::ConnectionNotification->new(); # ConnectionNotification | 

eval {
    my $result = $api_instance->feedDisconnectPost(connectionNotification => $connectionNotification);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DataFeedCallbackAPIApi->feedDisconnectPost: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint
# Configure HTTP basic authorization: BasicAuth
openapi_client.configuration.username = 'YOUR_USERNAME'
openapi_client.configuration.password = 'YOUR_PASSWORD'

# Configure API key authorization: ApiKeyAuth
openapi_client.configuration.api_key['X-API-Key'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['X-API-Key'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.DataFeedCallbackAPIApi()
connectionNotification =  # ConnectionNotification | 

try:
    # Notify the third party platform that a device has disconnected from the vending machine
    api_response = api_instance.feed_disconnect_post(connectionNotification)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DataFeedCallbackAPIApi->feedDisconnectPost: %s\n" % e)

extern crate DataFeedCallbackAPIApi;

pub fn main() {
    let connectionNotification = ; // ConnectionNotification

    let mut context = DataFeedCallbackAPIApi::Context::default();
    let result = client.feedDisconnectPost(connectionNotification, &context).wait();

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

Scopes

Parameters

Body parameters

Name	Description
connectionNotification *

Responses

Schema

feedRefillsPost

Notify the third party platform that vending machine has been refilled

/feed/refills

Usage and SDK Samples

curl -X POST \
 -H "Authorization: Basic [[basicHash]]" \
-H "X-API-Key: [[apiKey]]" \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "https://3rdparty.connectivityPlatformIntegration.com/feed/refills" \
 -d '{
  "planogram" : [ {
    "restock_count" : 3,
    "code" : 2,
    "current_stock" : 2,
    "price" : 7,
    "name" : "name",
    "formatted_code" : "formatted_code",
    "placeholder" : true,
    "capacity" : 9
  }, {
    "restock_count" : 3,
    "code" : 2,
    "current_stock" : 2,
    "price" : 7,
    "name" : "name",
    "formatted_code" : "formatted_code",
    "placeholder" : true,
    "capacity" : 9
  } ],
  "vm_id" : "vm_id",
  "time" : 0,
  "refill_detail" : [ {
    "code" : 1,
    "refill_quantity" : 6
  }, {
    "code" : 1,
    "refill_quantity" : 6
  } ]
}'

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DataFeedCallbackAPIApi;

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

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

        // Configure API key authorization: ApiKeyAuth
        ApiKeyAuth ApiKeyAuth = (ApiKeyAuth) defaultClient.getAuthentication("ApiKeyAuth");
        ApiKeyAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //ApiKeyAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        DataFeedCallbackAPIApi apiInstance = new DataFeedCallbackAPIApi();
        RefillNotification refillNotification = ; // RefillNotification | 

        try {
            CallbackResponse result = apiInstance.feedRefillsPost(refillNotification);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DataFeedCallbackAPIApi#feedRefillsPost");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final RefillNotification refillNotification = new RefillNotification(); // RefillNotification | 

try {
    final result = await api_instance.feedRefillsPost(refillNotification);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->feedRefillsPost: $e\n');
}

import org.openapitools.client.api.DataFeedCallbackAPIApi;

public class DataFeedCallbackAPIApiExample {
    public static void main(String[] args) {
        DataFeedCallbackAPIApi apiInstance = new DataFeedCallbackAPIApi();
        RefillNotification refillNotification = ; // RefillNotification | 

        try {
            CallbackResponse result = apiInstance.feedRefillsPost(refillNotification);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DataFeedCallbackAPIApi#feedRefillsPost");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: BasicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];
// Configure API key authorization: (authentication scheme: ApiKeyAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"X-API-Key"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"X-API-Key"];


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

// Notify the third party platform that vending machine has been refilled
[apiInstance feedRefillsPostWith:refillNotification
              completionHandler: ^(CallbackResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var VendingMachineApiDocumentCallBackConnectivityPlatformVendingOnTrack = require('vending_machine_api_document__call_back_connectivity_platform_vending_on_track');
var defaultClient = VendingMachineApiDocumentCallBackConnectivityPlatformVendingOnTrack.ApiClient.instance;

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

// Configure API key authorization: ApiKeyAuth
var ApiKeyAuth = defaultClient.authentications['ApiKeyAuth'];
ApiKeyAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//ApiKeyAuth.apiKeyPrefix['X-API-Key'] = "Token";

// Create an instance of the API class
var api = new VendingMachineApiDocumentCallBackConnectivityPlatformVendingOnTrack.DataFeedCallbackAPIApi()
var refillNotification = ; // {RefillNotification} 

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

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

namespace Example
{
    public class feedRefillsPostExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: BasicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";
            // Configure API key authorization: ApiKeyAuth
            Configuration.Default.ApiKey.Add("X-API-Key", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("X-API-Key", "Bearer");

            // Create an instance of the API class
            var apiInstance = new DataFeedCallbackAPIApi();
            var refillNotification = new RefillNotification(); // RefillNotification | 

            try {
                // Notify the third party platform that vending machine has been refilled
                CallbackResponse result = apiInstance.feedRefillsPost(refillNotification);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DataFeedCallbackAPIApi.feedRefillsPost: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');
// Configure HTTP basic authorization: BasicAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

// Configure API key authorization: ApiKeyAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('X-API-Key', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('X-API-Key', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DataFeedCallbackAPIApi();
$refillNotification = ; // RefillNotification | 

try {
    $result = $api_instance->feedRefillsPost($refillNotification);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DataFeedCallbackAPIApi->feedRefillsPost: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::DataFeedCallbackAPIApi;
# Configure HTTP basic authorization: BasicAuth
$WWW::OPenAPIClient::Configuration::username = 'YOUR_USERNAME';
$WWW::OPenAPIClient::Configuration::password = 'YOUR_PASSWORD';

# Configure API key authorization: ApiKeyAuth
$WWW::OPenAPIClient::Configuration::api_key->{'X-API-Key'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'X-API-Key'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DataFeedCallbackAPIApi->new();
my $refillNotification = WWW::OPenAPIClient::Object::RefillNotification->new(); # RefillNotification | 

eval {
    my $result = $api_instance->feedRefillsPost(refillNotification => $refillNotification);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DataFeedCallbackAPIApi->feedRefillsPost: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint
# Configure HTTP basic authorization: BasicAuth
openapi_client.configuration.username = 'YOUR_USERNAME'
openapi_client.configuration.password = 'YOUR_PASSWORD'

# Configure API key authorization: ApiKeyAuth
openapi_client.configuration.api_key['X-API-Key'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['X-API-Key'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.DataFeedCallbackAPIApi()
refillNotification =  # RefillNotification | 

try:
    # Notify the third party platform that vending machine has been refilled
    api_response = api_instance.feed_refills_post(refillNotification)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DataFeedCallbackAPIApi->feedRefillsPost: %s\n" % e)

extern crate DataFeedCallbackAPIApi;

pub fn main() {
    let refillNotification = ; // RefillNotification

    let mut context = DataFeedCallbackAPIApi::Context::default();
    let result = client.feedRefillsPost(refillNotification, &context).wait();

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

Scopes

Parameters

Body parameters

Name	Description
refillNotification *

Responses

Schema

feedTransactionsPost

Notify the third party platform that vending machine has dispensed products, this also includes transactions approved by 3rd party integration via payment API.

/feed/transactions

Usage and SDK Samples

curl -X POST \
 -H "Authorization: Basic [[basicHash]]" \
-H "X-API-Key: [[apiKey]]" \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "https://3rdparty.connectivityPlatformIntegration.com/feed/transactions" \
 -d '{
  "planogram" : [ {
    "restock_count" : 3,
    "code" : 2,
    "current_stock" : 2,
    "price" : 7,
    "name" : "name",
    "formatted_code" : "formatted_code",
    "placeholder" : true,
    "capacity" : 9
  }, {
    "restock_count" : 3,
    "code" : 2,
    "current_stock" : 2,
    "price" : 7,
    "name" : "name",
    "formatted_code" : "formatted_code",
    "placeholder" : true,
    "capacity" : 9
  } ],
  "vm_id" : "vm_id",
  "code" : 5,
  "cashless_value" : 5,
  "cash_value" : 1,
  "time" : 6,
  "dispense_quantity" : 0
}'

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.DataFeedCallbackAPIApi;

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

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

        // Configure API key authorization: ApiKeyAuth
        ApiKeyAuth ApiKeyAuth = (ApiKeyAuth) defaultClient.getAuthentication("ApiKeyAuth");
        ApiKeyAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //ApiKeyAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        DataFeedCallbackAPIApi apiInstance = new DataFeedCallbackAPIApi();
        TransactionNotification transactionNotification = ; // TransactionNotification | 

        try {
            CallbackResponse result = apiInstance.feedTransactionsPost(transactionNotification);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DataFeedCallbackAPIApi#feedTransactionsPost");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final TransactionNotification transactionNotification = new TransactionNotification(); // TransactionNotification | 

try {
    final result = await api_instance.feedTransactionsPost(transactionNotification);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->feedTransactionsPost: $e\n');
}

import org.openapitools.client.api.DataFeedCallbackAPIApi;

public class DataFeedCallbackAPIApiExample {
    public static void main(String[] args) {
        DataFeedCallbackAPIApi apiInstance = new DataFeedCallbackAPIApi();
        TransactionNotification transactionNotification = ; // TransactionNotification | 

        try {
            CallbackResponse result = apiInstance.feedTransactionsPost(transactionNotification);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DataFeedCallbackAPIApi#feedTransactionsPost");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: BasicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];
// Configure API key authorization: (authentication scheme: ApiKeyAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"X-API-Key"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"X-API-Key"];


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

// Notify the third party platform that vending machine has dispensed products, this also includes transactions approved by 3rd party integration via payment API.
[apiInstance feedTransactionsPostWith:transactionNotification
              completionHandler: ^(CallbackResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var VendingMachineApiDocumentCallBackConnectivityPlatformVendingOnTrack = require('vending_machine_api_document__call_back_connectivity_platform_vending_on_track');
var defaultClient = VendingMachineApiDocumentCallBackConnectivityPlatformVendingOnTrack.ApiClient.instance;

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

// Configure API key authorization: ApiKeyAuth
var ApiKeyAuth = defaultClient.authentications['ApiKeyAuth'];
ApiKeyAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//ApiKeyAuth.apiKeyPrefix['X-API-Key'] = "Token";

// Create an instance of the API class
var api = new VendingMachineApiDocumentCallBackConnectivityPlatformVendingOnTrack.DataFeedCallbackAPIApi()
var transactionNotification = ; // {TransactionNotification} 

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

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

namespace Example
{
    public class feedTransactionsPostExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: BasicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";
            // Configure API key authorization: ApiKeyAuth
            Configuration.Default.ApiKey.Add("X-API-Key", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("X-API-Key", "Bearer");

            // Create an instance of the API class
            var apiInstance = new DataFeedCallbackAPIApi();
            var transactionNotification = new TransactionNotification(); // TransactionNotification | 

            try {
                // Notify the third party platform that vending machine has dispensed products, this also includes transactions approved by 3rd party integration via payment API.
                CallbackResponse result = apiInstance.feedTransactionsPost(transactionNotification);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DataFeedCallbackAPIApi.feedTransactionsPost: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');
// Configure HTTP basic authorization: BasicAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

// Configure API key authorization: ApiKeyAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('X-API-Key', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('X-API-Key', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\DataFeedCallbackAPIApi();
$transactionNotification = ; // TransactionNotification | 

try {
    $result = $api_instance->feedTransactionsPost($transactionNotification);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling DataFeedCallbackAPIApi->feedTransactionsPost: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::DataFeedCallbackAPIApi;
# Configure HTTP basic authorization: BasicAuth
$WWW::OPenAPIClient::Configuration::username = 'YOUR_USERNAME';
$WWW::OPenAPIClient::Configuration::password = 'YOUR_PASSWORD';

# Configure API key authorization: ApiKeyAuth
$WWW::OPenAPIClient::Configuration::api_key->{'X-API-Key'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'X-API-Key'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::DataFeedCallbackAPIApi->new();
my $transactionNotification = WWW::OPenAPIClient::Object::TransactionNotification->new(); # TransactionNotification | 

eval {
    my $result = $api_instance->feedTransactionsPost(transactionNotification => $transactionNotification);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DataFeedCallbackAPIApi->feedTransactionsPost: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint
# Configure HTTP basic authorization: BasicAuth
openapi_client.configuration.username = 'YOUR_USERNAME'
openapi_client.configuration.password = 'YOUR_PASSWORD'

# Configure API key authorization: ApiKeyAuth
openapi_client.configuration.api_key['X-API-Key'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['X-API-Key'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.DataFeedCallbackAPIApi()
transactionNotification =  # TransactionNotification | 

try:
    # Notify the third party platform that vending machine has dispensed products, this also includes transactions approved by 3rd party integration via payment API.
    api_response = api_instance.feed_transactions_post(transactionNotification)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DataFeedCallbackAPIApi->feedTransactionsPost: %s\n" % e)

extern crate DataFeedCallbackAPIApi;

pub fn main() {
    let transactionNotification = ; // TransactionNotification

    let mut context = DataFeedCallbackAPIApi::Context::default();
    let result = client.feedTransactionsPost(transactionNotification, &context).wait();

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

Scopes

Parameters

Body parameters

Name	Description
transactionNotification *

Responses

Schema

PaymentCallbackAPI

txnRequestPost

Notify payment integration that the customer has made a selection

/txn/request

Usage and SDK Samples

curl -X POST \
 -H "Authorization: Basic [[basicHash]]" \
-H "X-API-Key: [[apiKey]]" \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "https://3rdparty.connectivityPlatformIntegration.com/txn/request" \
 -d '{
  "selection" : "selection",
  "cents" : 0,
  "txn_ref" : "txn_ref",
  "new_txn_ref" : "new_txn_ref"
}'

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.PaymentCallbackAPIApi;

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

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

        // Configure API key authorization: ApiKeyAuth
        ApiKeyAuth ApiKeyAuth = (ApiKeyAuth) defaultClient.getAuthentication("ApiKeyAuth");
        ApiKeyAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //ApiKeyAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        PaymentCallbackAPIApi apiInstance = new PaymentCallbackAPIApi();
        SelectionNotification selectionNotification = ; // SelectionNotification | 

        try {
            CallbackResponse result = apiInstance.txnRequestPost(selectionNotification);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling PaymentCallbackAPIApi#txnRequestPost");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final SelectionNotification selectionNotification = new SelectionNotification(); // SelectionNotification | 

try {
    final result = await api_instance.txnRequestPost(selectionNotification);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->txnRequestPost: $e\n');
}

import org.openapitools.client.api.PaymentCallbackAPIApi;

public class PaymentCallbackAPIApiExample {
    public static void main(String[] args) {
        PaymentCallbackAPIApi apiInstance = new PaymentCallbackAPIApi();
        SelectionNotification selectionNotification = ; // SelectionNotification | 

        try {
            CallbackResponse result = apiInstance.txnRequestPost(selectionNotification);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling PaymentCallbackAPIApi#txnRequestPost");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: BasicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];
// Configure API key authorization: (authentication scheme: ApiKeyAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"X-API-Key"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"X-API-Key"];


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

// Notify payment integration that the customer has made a selection
[apiInstance txnRequestPostWith:selectionNotification
              completionHandler: ^(CallbackResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var VendingMachineApiDocumentCallBackConnectivityPlatformVendingOnTrack = require('vending_machine_api_document__call_back_connectivity_platform_vending_on_track');
var defaultClient = VendingMachineApiDocumentCallBackConnectivityPlatformVendingOnTrack.ApiClient.instance;

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

// Configure API key authorization: ApiKeyAuth
var ApiKeyAuth = defaultClient.authentications['ApiKeyAuth'];
ApiKeyAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//ApiKeyAuth.apiKeyPrefix['X-API-Key'] = "Token";

// Create an instance of the API class
var api = new VendingMachineApiDocumentCallBackConnectivityPlatformVendingOnTrack.PaymentCallbackAPIApi()
var selectionNotification = ; // {SelectionNotification} 

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

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

namespace Example
{
    public class txnRequestPostExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: BasicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";
            // Configure API key authorization: ApiKeyAuth
            Configuration.Default.ApiKey.Add("X-API-Key", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("X-API-Key", "Bearer");

            // Create an instance of the API class
            var apiInstance = new PaymentCallbackAPIApi();
            var selectionNotification = new SelectionNotification(); // SelectionNotification | 

            try {
                // Notify payment integration that the customer has made a selection
                CallbackResponse result = apiInstance.txnRequestPost(selectionNotification);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling PaymentCallbackAPIApi.txnRequestPost: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');
// Configure HTTP basic authorization: BasicAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

// Configure API key authorization: ApiKeyAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('X-API-Key', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('X-API-Key', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\PaymentCallbackAPIApi();
$selectionNotification = ; // SelectionNotification | 

try {
    $result = $api_instance->txnRequestPost($selectionNotification);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling PaymentCallbackAPIApi->txnRequestPost: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::PaymentCallbackAPIApi;
# Configure HTTP basic authorization: BasicAuth
$WWW::OPenAPIClient::Configuration::username = 'YOUR_USERNAME';
$WWW::OPenAPIClient::Configuration::password = 'YOUR_PASSWORD';

# Configure API key authorization: ApiKeyAuth
$WWW::OPenAPIClient::Configuration::api_key->{'X-API-Key'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'X-API-Key'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::PaymentCallbackAPIApi->new();
my $selectionNotification = WWW::OPenAPIClient::Object::SelectionNotification->new(); # SelectionNotification | 

eval {
    my $result = $api_instance->txnRequestPost(selectionNotification => $selectionNotification);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling PaymentCallbackAPIApi->txnRequestPost: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint
# Configure HTTP basic authorization: BasicAuth
openapi_client.configuration.username = 'YOUR_USERNAME'
openapi_client.configuration.password = 'YOUR_PASSWORD'

# Configure API key authorization: ApiKeyAuth
openapi_client.configuration.api_key['X-API-Key'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['X-API-Key'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.PaymentCallbackAPIApi()
selectionNotification =  # SelectionNotification | 

try:
    # Notify payment integration that the customer has made a selection
    api_response = api_instance.txn_request_post(selectionNotification)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling PaymentCallbackAPIApi->txnRequestPost: %s\n" % e)

extern crate PaymentCallbackAPIApi;

pub fn main() {
    let selectionNotification = ; // SelectionNotification

    let mut context = PaymentCallbackAPIApi::Context::default();
    let result = client.txnRequestPost(selectionNotification, &context).wait();

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

Scopes

Parameters

Body parameters

Name	Description
selectionNotification *

Responses

Schema

txnUnlockPost

Vending machine decides unlock/abort the transaction. This is used when a transaction was terminated during a transaction.

/txn/unlock

Usage and SDK Samples

curl -X POST \
 -H "Authorization: Basic [[basicHash]]" \
-H "X-API-Key: [[apiKey]]" \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "https://3rdparty.connectivityPlatformIntegration.com/txn/unlock" \
 -d '{
  "code" : "code",
  "txn_ref" : "txn_ref"
}'

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.PaymentCallbackAPIApi;

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

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

        // Configure API key authorization: ApiKeyAuth
        ApiKeyAuth ApiKeyAuth = (ApiKeyAuth) defaultClient.getAuthentication("ApiKeyAuth");
        ApiKeyAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //ApiKeyAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        PaymentCallbackAPIApi apiInstance = new PaymentCallbackAPIApi();
        UnlockNotification unlockNotification = ; // UnlockNotification | 

        try {
            CallbackResponse result = apiInstance.txnUnlockPost(unlockNotification);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling PaymentCallbackAPIApi#txnUnlockPost");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final UnlockNotification unlockNotification = new UnlockNotification(); // UnlockNotification | 

try {
    final result = await api_instance.txnUnlockPost(unlockNotification);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->txnUnlockPost: $e\n');
}

import org.openapitools.client.api.PaymentCallbackAPIApi;

public class PaymentCallbackAPIApiExample {
    public static void main(String[] args) {
        PaymentCallbackAPIApi apiInstance = new PaymentCallbackAPIApi();
        UnlockNotification unlockNotification = ; // UnlockNotification | 

        try {
            CallbackResponse result = apiInstance.txnUnlockPost(unlockNotification);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling PaymentCallbackAPIApi#txnUnlockPost");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: BasicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];
// Configure API key authorization: (authentication scheme: ApiKeyAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"X-API-Key"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"X-API-Key"];


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

// Vending machine decides unlock/abort the transaction. This is used when a transaction was terminated during a transaction.
[apiInstance txnUnlockPostWith:unlockNotification
              completionHandler: ^(CallbackResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var VendingMachineApiDocumentCallBackConnectivityPlatformVendingOnTrack = require('vending_machine_api_document__call_back_connectivity_platform_vending_on_track');
var defaultClient = VendingMachineApiDocumentCallBackConnectivityPlatformVendingOnTrack.ApiClient.instance;

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

// Configure API key authorization: ApiKeyAuth
var ApiKeyAuth = defaultClient.authentications['ApiKeyAuth'];
ApiKeyAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//ApiKeyAuth.apiKeyPrefix['X-API-Key'] = "Token";

// Create an instance of the API class
var api = new VendingMachineApiDocumentCallBackConnectivityPlatformVendingOnTrack.PaymentCallbackAPIApi()
var unlockNotification = ; // {UnlockNotification} 

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

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

namespace Example
{
    public class txnUnlockPostExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: BasicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";
            // Configure API key authorization: ApiKeyAuth
            Configuration.Default.ApiKey.Add("X-API-Key", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("X-API-Key", "Bearer");

            // Create an instance of the API class
            var apiInstance = new PaymentCallbackAPIApi();
            var unlockNotification = new UnlockNotification(); // UnlockNotification | 

            try {
                // Vending machine decides unlock/abort the transaction. This is used when a transaction was terminated during a transaction.
                CallbackResponse result = apiInstance.txnUnlockPost(unlockNotification);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling PaymentCallbackAPIApi.txnUnlockPost: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');
// Configure HTTP basic authorization: BasicAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

// Configure API key authorization: ApiKeyAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('X-API-Key', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('X-API-Key', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\PaymentCallbackAPIApi();
$unlockNotification = ; // UnlockNotification | 

try {
    $result = $api_instance->txnUnlockPost($unlockNotification);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling PaymentCallbackAPIApi->txnUnlockPost: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::PaymentCallbackAPIApi;
# Configure HTTP basic authorization: BasicAuth
$WWW::OPenAPIClient::Configuration::username = 'YOUR_USERNAME';
$WWW::OPenAPIClient::Configuration::password = 'YOUR_PASSWORD';

# Configure API key authorization: ApiKeyAuth
$WWW::OPenAPIClient::Configuration::api_key->{'X-API-Key'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'X-API-Key'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::PaymentCallbackAPIApi->new();
my $unlockNotification = WWW::OPenAPIClient::Object::UnlockNotification->new(); # UnlockNotification | 

eval {
    my $result = $api_instance->txnUnlockPost(unlockNotification => $unlockNotification);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling PaymentCallbackAPIApi->txnUnlockPost: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint
# Configure HTTP basic authorization: BasicAuth
openapi_client.configuration.username = 'YOUR_USERNAME'
openapi_client.configuration.password = 'YOUR_PASSWORD'

# Configure API key authorization: ApiKeyAuth
openapi_client.configuration.api_key['X-API-Key'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['X-API-Key'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.PaymentCallbackAPIApi()
unlockNotification =  # UnlockNotification | 

try:
    # Vending machine decides unlock/abort the transaction. This is used when a transaction was terminated during a transaction.
    api_response = api_instance.txn_unlock_post(unlockNotification)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling PaymentCallbackAPIApi->txnUnlockPost: %s\n" % e)

extern crate PaymentCallbackAPIApi;

pub fn main() {
    let unlockNotification = ; // UnlockNotification

    let mut context = PaymentCallbackAPIApi::Context::default();
    let result = client.txnUnlockPost(unlockNotification, &context).wait();

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

Scopes

Parameters

Body parameters

Name	Description
unlockNotification *

Responses

Schema

txnVendPost

Notify payment integration the result of a vend/transaction

/txn/vend

Usage and SDK Samples

curl -X POST \
 -H "Authorization: Basic [[basicHash]]" \
-H "X-API-Key: [[apiKey]]" \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "https://3rdparty.connectivityPlatformIntegration.com/txn/vend" \
 -d '{
  "code" : "code",
  "success" : true,
  "txn_ref" : "txn_ref"
}'

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.PaymentCallbackAPIApi;

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

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

        // Configure API key authorization: ApiKeyAuth
        ApiKeyAuth ApiKeyAuth = (ApiKeyAuth) defaultClient.getAuthentication("ApiKeyAuth");
        ApiKeyAuth.setApiKey("YOUR API KEY");
        // Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
        //ApiKeyAuth.setApiKeyPrefix("Token");

        // Create an instance of the API class
        PaymentCallbackAPIApi apiInstance = new PaymentCallbackAPIApi();
        VendResultNotification vendResultNotification = ; // VendResultNotification | 

        try {
            CallbackResponse result = apiInstance.txnVendPost(vendResultNotification);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling PaymentCallbackAPIApi#txnVendPost");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final VendResultNotification vendResultNotification = new VendResultNotification(); // VendResultNotification | 

try {
    final result = await api_instance.txnVendPost(vendResultNotification);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->txnVendPost: $e\n');
}

import org.openapitools.client.api.PaymentCallbackAPIApi;

public class PaymentCallbackAPIApiExample {
    public static void main(String[] args) {
        PaymentCallbackAPIApi apiInstance = new PaymentCallbackAPIApi();
        VendResultNotification vendResultNotification = ; // VendResultNotification | 

        try {
            CallbackResponse result = apiInstance.txnVendPost(vendResultNotification);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling PaymentCallbackAPIApi#txnVendPost");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];
// Configure HTTP basic authorization (authentication scheme: BasicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];
// Configure API key authorization: (authentication scheme: ApiKeyAuth)
[apiConfig setApiKey:@"YOUR_API_KEY" forApiKeyIdentifier:@"X-API-Key"];
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
//[apiConfig setApiKeyPrefix:@"Bearer" forApiKeyIdentifier:@"X-API-Key"];


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

// Notify payment integration the result of a vend/transaction
[apiInstance txnVendPostWith:vendResultNotification
              completionHandler: ^(CallbackResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var VendingMachineApiDocumentCallBackConnectivityPlatformVendingOnTrack = require('vending_machine_api_document__call_back_connectivity_platform_vending_on_track');
var defaultClient = VendingMachineApiDocumentCallBackConnectivityPlatformVendingOnTrack.ApiClient.instance;

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

// Configure API key authorization: ApiKeyAuth
var ApiKeyAuth = defaultClient.authentications['ApiKeyAuth'];
ApiKeyAuth.apiKey = "YOUR API KEY";
// Uncomment the following line to set a prefix for the API key, e.g. "Token" (defaults to null)
//ApiKeyAuth.apiKeyPrefix['X-API-Key'] = "Token";

// Create an instance of the API class
var api = new VendingMachineApiDocumentCallBackConnectivityPlatformVendingOnTrack.PaymentCallbackAPIApi()
var vendResultNotification = ; // {VendResultNotification} 

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

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

namespace Example
{
    public class txnVendPostExample
    {
        public void main()
        {
            // Configure HTTP basic authorization: BasicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";
            // Configure API key authorization: ApiKeyAuth
            Configuration.Default.ApiKey.Add("X-API-Key", "YOUR_API_KEY");
            // Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
            // Configuration.Default.ApiKeyPrefix.Add("X-API-Key", "Bearer");

            // Create an instance of the API class
            var apiInstance = new PaymentCallbackAPIApi();
            var vendResultNotification = new VendResultNotification(); // VendResultNotification | 

            try {
                // Notify payment integration the result of a vend/transaction
                CallbackResponse result = apiInstance.txnVendPost(vendResultNotification);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling PaymentCallbackAPIApi.txnVendPost: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');
// Configure HTTP basic authorization: BasicAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

// Configure API key authorization: ApiKeyAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKey('X-API-Key', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// OpenAPITools\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('X-API-Key', 'Bearer');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\PaymentCallbackAPIApi();
$vendResultNotification = ; // VendResultNotification | 

try {
    $result = $api_instance->txnVendPost($vendResultNotification);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling PaymentCallbackAPIApi->txnVendPost: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::PaymentCallbackAPIApi;
# Configure HTTP basic authorization: BasicAuth
$WWW::OPenAPIClient::Configuration::username = 'YOUR_USERNAME';
$WWW::OPenAPIClient::Configuration::password = 'YOUR_PASSWORD';

# Configure API key authorization: ApiKeyAuth
$WWW::OPenAPIClient::Configuration::api_key->{'X-API-Key'} = 'YOUR_API_KEY';
# uncomment below to setup prefix (e.g. Bearer) for API key, if needed
#$WWW::OPenAPIClient::Configuration::api_key_prefix->{'X-API-Key'} = "Bearer";

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::PaymentCallbackAPIApi->new();
my $vendResultNotification = WWW::OPenAPIClient::Object::VendResultNotification->new(); # VendResultNotification | 

eval {
    my $result = $api_instance->txnVendPost(vendResultNotification => $vendResultNotification);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling PaymentCallbackAPIApi->txnVendPost: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint
# Configure HTTP basic authorization: BasicAuth
openapi_client.configuration.username = 'YOUR_USERNAME'
openapi_client.configuration.password = 'YOUR_PASSWORD'

# Configure API key authorization: ApiKeyAuth
openapi_client.configuration.api_key['X-API-Key'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# openapi_client.configuration.api_key_prefix['X-API-Key'] = 'Bearer'

# Create an instance of the API class
api_instance = openapi_client.PaymentCallbackAPIApi()
vendResultNotification =  # VendResultNotification | 

try:
    # Notify payment integration the result of a vend/transaction
    api_response = api_instance.txn_vend_post(vendResultNotification)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling PaymentCallbackAPIApi->txnVendPost: %s\n" % e)

extern crate PaymentCallbackAPIApi;

pub fn main() {
    let vendResultNotification = ; // VendResultNotification

    let mut context = PaymentCallbackAPIApi::Context::default();
    let result = client.txnVendPost(vendResultNotification, &context).wait();

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

Scopes

Parameters

Body parameters

Name	Description
vendResultNotification *

Responses

Schema

Vending Machine API Document (Call back) - Connectivity Platform - Vending on Track

API and SDK Documentation

DataFeedCallbackAPI

feedAlertsPost

Usage and SDK Samples

Scopes

Parameters

Responses

feedButtonActionsPost

Usage and SDK Samples

Scopes

Parameters

Responses

feedConnectPost

Usage and SDK Samples

Scopes

Parameters

Responses

feedDisconnectPost

Usage and SDK Samples

Scopes

Parameters

Responses

feedRefillsPost

Usage and SDK Samples

Scopes

Parameters

Responses

feedTransactionsPost

Usage and SDK Samples

Scopes

Parameters

Responses

PaymentCallbackAPI

txnRequestPost

Usage and SDK Samples

Scopes

Parameters

Responses

txnUnlockPost

Usage and SDK Samples

Scopes

Parameters

Responses

txnVendPost

Usage and SDK Samples

Scopes

Parameters

Responses