Vending Machine API Document - Connectivity Platform - Vending on Track

PaymentEndpoint

apiLockPost

Start a transaction by locking a vending machine.

/api/lock

Usage and SDK Samples

curl -X POST\
-H "X-API-Key: [[apiKey]]"\
 -H "Authorization: Basic [[basicHash]]"\
-H "Accept: application/json"\
-H "Content-Type: application/json"\
"https://api.connectivity.REGION.vendingontrack.com/connectivity-platform/api/lock"

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.PaymentEndpointApi;

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

public class PaymentEndpointApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // 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");
        // Configure HTTP basic authorization: BasicAuth
        HttpBasicAuth BasicAuth = (HttpBasicAuth) defaultClient.getAuthentication("BasicAuth");
        BasicAuth.setUsername("YOUR USERNAME");
        BasicAuth.setPassword("YOUR PASSWORD");

        PaymentEndpointApi apiInstance = new PaymentEndpointApi();
        LockRequest body = ; // LockRequest | 
        try {
            LockResponse result = apiInstance.apiLockPost(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling PaymentEndpointApi#apiLockPost");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.PaymentEndpointApi;

public class PaymentEndpointApiExample {

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

Configuration *apiConfig = [Configuration sharedConfig];
// 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"];
// Configure HTTP basic authorization (authentication scheme: BasicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];
LockRequest *body = ; // 

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

// Start a transaction by locking a vending machine.
[apiInstance apiLockPostWith:body
              completionHandler: ^(LockResponse output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var VendingMachineApiDocumentConnectivityPlatformVendingOnTrack = require('vending_machine_api_document___connectivity_platform___vending_on_track');
var defaultClient = VendingMachineApiDocumentConnectivityPlatformVendingOnTrack.ApiClient.instance;

// 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"
// Configure HTTP basic authorization: BasicAuth
var BasicAuth = defaultClient.authentications['BasicAuth'];
BasicAuth.username = 'YOUR USERNAME'
BasicAuth.password = 'YOUR PASSWORD'

var api = new VendingMachineApiDocumentConnectivityPlatformVendingOnTrack.PaymentEndpointApi()
var body = ; // {{LockRequest}} 

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

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            // 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");            // Configure HTTP basic authorization: BasicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new PaymentEndpointApi();
            var body = new LockRequest(); // LockRequest | 

            try
            {
                // Start a transaction by locking a vending machine.
                LockResponse result = apiInstance.apiLockPost(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling PaymentEndpointApi.apiLockPost: " + e.Message );
            }
        }
    }
}

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

// Configure API key authorization: ApiKeyAuth
Swagger\Client\Configuration::getDefaultConfiguration()->setApiKey('X-API-Key', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// Swagger\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('X-API-Key', 'Bearer');// Configure HTTP basic authorization: BasicAuth
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\ApiPaymentEndpointApi();
$body = ; // LockRequest | 

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

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::PaymentEndpointApi;

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

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

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

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: ApiKeyAuth
swagger_client.configuration.api_key['X-API-Key'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# swagger_client.configuration.api_key_prefix['X-API-Key'] = 'Bearer'# Configure HTTP basic authorization: BasicAuth
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

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

try: 
    # Start a transaction by locking a vending machine.
    api_response = api_instance.api_lock_post(body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling PaymentEndpointApi->apiLockPost: %s\n" % e)

Parameters

Body parameters

Name	Description
body *

Responses

Status: 200 - OK

Schema

apiPaidPost

Mark an ongoing transaction as paid. The transaction must be authorized by caller.

/api/paid

Usage and SDK Samples

curl -X POST\
-H "X-API-Key: [[apiKey]]"\
 -H "Authorization: Basic [[basicHash]]"\
-H "Accept: application/json"\
-H "Content-Type: application/json"\
"https://api.connectivity.REGION.vendingontrack.com/connectivity-platform/api/paid"

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.PaymentEndpointApi;

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

public class PaymentEndpointApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // 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");
        // Configure HTTP basic authorization: BasicAuth
        HttpBasicAuth BasicAuth = (HttpBasicAuth) defaultClient.getAuthentication("BasicAuth");
        BasicAuth.setUsername("YOUR USERNAME");
        BasicAuth.setPassword("YOUR PASSWORD");

        PaymentEndpointApi apiInstance = new PaymentEndpointApi();
        TransactionPaidRequest body = ; // TransactionPaidRequest | 
        try {
            TransactionPaidResponse result = apiInstance.apiPaidPost(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling PaymentEndpointApi#apiPaidPost");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.PaymentEndpointApi;

public class PaymentEndpointApiExample {

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

Configuration *apiConfig = [Configuration sharedConfig];
// 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"];
// Configure HTTP basic authorization (authentication scheme: BasicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];
TransactionPaidRequest *body = ; // 

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

// Mark an ongoing transaction as paid. The transaction must be authorized by caller.
[apiInstance apiPaidPostWith:body
              completionHandler: ^(TransactionPaidResponse output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var VendingMachineApiDocumentConnectivityPlatformVendingOnTrack = require('vending_machine_api_document___connectivity_platform___vending_on_track');
var defaultClient = VendingMachineApiDocumentConnectivityPlatformVendingOnTrack.ApiClient.instance;

// 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"
// Configure HTTP basic authorization: BasicAuth
var BasicAuth = defaultClient.authentications['BasicAuth'];
BasicAuth.username = 'YOUR USERNAME'
BasicAuth.password = 'YOUR PASSWORD'

var api = new VendingMachineApiDocumentConnectivityPlatformVendingOnTrack.PaymentEndpointApi()
var body = ; // {{TransactionPaidRequest}} 

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

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            // 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");            // Configure HTTP basic authorization: BasicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new PaymentEndpointApi();
            var body = new TransactionPaidRequest(); // TransactionPaidRequest | 

            try
            {
                // Mark an ongoing transaction as paid. The transaction must be authorized by caller.
                TransactionPaidResponse result = apiInstance.apiPaidPost(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling PaymentEndpointApi.apiPaidPost: " + e.Message );
            }
        }
    }
}

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

// Configure API key authorization: ApiKeyAuth
Swagger\Client\Configuration::getDefaultConfiguration()->setApiKey('X-API-Key', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// Swagger\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('X-API-Key', 'Bearer');// Configure HTTP basic authorization: BasicAuth
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\ApiPaymentEndpointApi();
$body = ; // TransactionPaidRequest | 

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

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::PaymentEndpointApi;

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

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

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

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: ApiKeyAuth
swagger_client.configuration.api_key['X-API-Key'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# swagger_client.configuration.api_key_prefix['X-API-Key'] = 'Bearer'# Configure HTTP basic authorization: BasicAuth
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

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

try: 
    # Mark an ongoing transaction as paid. The transaction must be authorized by caller.
    api_response = api_instance.api_paid_post(body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling PaymentEndpointApi->apiPaidPost: %s\n" % e)

Parameters

Body parameters

Name	Description
body *

Responses

Status: 200 - OK

Schema

apiUnlockPost

Cancel an ongoing transaction before authorizing payment. No side effect if called after payment for the transaction has been made (/api/paid).

/api/unlock

Usage and SDK Samples

curl -X POST\
-H "X-API-Key: [[apiKey]]"\
 -H "Authorization: Basic [[basicHash]]"\
-H "Accept: application/json"\
-H "Content-Type: application/json"\
"https://api.connectivity.REGION.vendingontrack.com/connectivity-platform/api/unlock"

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.PaymentEndpointApi;

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

public class PaymentEndpointApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // 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");
        // Configure HTTP basic authorization: BasicAuth
        HttpBasicAuth BasicAuth = (HttpBasicAuth) defaultClient.getAuthentication("BasicAuth");
        BasicAuth.setUsername("YOUR USERNAME");
        BasicAuth.setPassword("YOUR PASSWORD");

        PaymentEndpointApi apiInstance = new PaymentEndpointApi();
        CancelRequest body = ; // CancelRequest | 
        try {
            CancelResponse result = apiInstance.apiUnlockPost(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling PaymentEndpointApi#apiUnlockPost");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.PaymentEndpointApi;

public class PaymentEndpointApiExample {

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

Configuration *apiConfig = [Configuration sharedConfig];
// 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"];
// Configure HTTP basic authorization (authentication scheme: BasicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];
CancelRequest *body = ; // 

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

// Cancel an ongoing transaction before authorizing payment. No side effect if called after payment for the transaction has been made (/api/paid).
[apiInstance apiUnlockPostWith:body
              completionHandler: ^(CancelResponse output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var VendingMachineApiDocumentConnectivityPlatformVendingOnTrack = require('vending_machine_api_document___connectivity_platform___vending_on_track');
var defaultClient = VendingMachineApiDocumentConnectivityPlatformVendingOnTrack.ApiClient.instance;

// 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"
// Configure HTTP basic authorization: BasicAuth
var BasicAuth = defaultClient.authentications['BasicAuth'];
BasicAuth.username = 'YOUR USERNAME'
BasicAuth.password = 'YOUR PASSWORD'

var api = new VendingMachineApiDocumentConnectivityPlatformVendingOnTrack.PaymentEndpointApi()
var body = ; // {{CancelRequest}} 

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

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            // 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");            // Configure HTTP basic authorization: BasicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new PaymentEndpointApi();
            var body = new CancelRequest(); // CancelRequest | 

            try
            {
                // Cancel an ongoing transaction before authorizing payment. No side effect if called after payment for the transaction has been made (/api/paid).
                CancelResponse result = apiInstance.apiUnlockPost(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling PaymentEndpointApi.apiUnlockPost: " + e.Message );
            }
        }
    }
}

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

// Configure API key authorization: ApiKeyAuth
Swagger\Client\Configuration::getDefaultConfiguration()->setApiKey('X-API-Key', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// Swagger\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('X-API-Key', 'Bearer');// Configure HTTP basic authorization: BasicAuth
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\ApiPaymentEndpointApi();
$body = ; // CancelRequest | 

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

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::PaymentEndpointApi;

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

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

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

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: ApiKeyAuth
swagger_client.configuration.api_key['X-API-Key'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# swagger_client.configuration.api_key_prefix['X-API-Key'] = 'Bearer'# Configure HTTP basic authorization: BasicAuth
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

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

try: 
    # Cancel an ongoing transaction before authorizing payment. No side effect if called after payment for the transaction has been made (/api/paid).
    api_response = api_instance.api_unlock_post(body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling PaymentEndpointApi->apiUnlockPost: %s\n" % e)

Parameters

Body parameters

Name	Description
body *

Responses

Status: 200 - OK

Schema

apiVmcBulkSearchPost

Obtain detailed information(vending machine status, operator information and virtual keypad configuration) for multiple vending machines.

/api/vmc_bulk_search

Usage and SDK Samples

curl -X POST\
-H "X-API-Key: [[apiKey]]"\
 -H "Authorization: Basic [[basicHash]]"\
-H "Accept: application/json"\
-H "Content-Type: application/json"\
"https://api.connectivity.REGION.vendingontrack.com/connectivity-platform/api/vmc_bulk_search"

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.PaymentEndpointApi;

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

public class PaymentEndpointApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // 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");
        // Configure HTTP basic authorization: BasicAuth
        HttpBasicAuth BasicAuth = (HttpBasicAuth) defaultClient.getAuthentication("BasicAuth");
        BasicAuth.setUsername("YOUR USERNAME");
        BasicAuth.setPassword("YOUR PASSWORD");

        PaymentEndpointApi apiInstance = new PaymentEndpointApi();
        BulkSearchRequest body = ; // BulkSearchRequest | 
        try {
            BulkSearchResponse result = apiInstance.apiVmcBulkSearchPost(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling PaymentEndpointApi#apiVmcBulkSearchPost");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.PaymentEndpointApi;

public class PaymentEndpointApiExample {

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

Configuration *apiConfig = [Configuration sharedConfig];
// 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"];
// Configure HTTP basic authorization (authentication scheme: BasicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];
BulkSearchRequest *body = ; // 

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

// Obtain detailed information(vending machine status, operator information and virtual keypad configuration) for multiple vending machines.
[apiInstance apiVmcBulkSearchPostWith:body
              completionHandler: ^(BulkSearchResponse output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var VendingMachineApiDocumentConnectivityPlatformVendingOnTrack = require('vending_machine_api_document___connectivity_platform___vending_on_track');
var defaultClient = VendingMachineApiDocumentConnectivityPlatformVendingOnTrack.ApiClient.instance;

// 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"
// Configure HTTP basic authorization: BasicAuth
var BasicAuth = defaultClient.authentications['BasicAuth'];
BasicAuth.username = 'YOUR USERNAME'
BasicAuth.password = 'YOUR PASSWORD'

var api = new VendingMachineApiDocumentConnectivityPlatformVendingOnTrack.PaymentEndpointApi()
var body = ; // {{BulkSearchRequest}} 

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

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            // 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");            // Configure HTTP basic authorization: BasicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new PaymentEndpointApi();
            var body = new BulkSearchRequest(); // BulkSearchRequest | 

            try
            {
                // Obtain detailed information(vending machine status, operator information and virtual keypad configuration) for multiple vending machines.
                BulkSearchResponse result = apiInstance.apiVmcBulkSearchPost(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling PaymentEndpointApi.apiVmcBulkSearchPost: " + e.Message );
            }
        }
    }
}

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

// Configure API key authorization: ApiKeyAuth
Swagger\Client\Configuration::getDefaultConfiguration()->setApiKey('X-API-Key', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// Swagger\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('X-API-Key', 'Bearer');// Configure HTTP basic authorization: BasicAuth
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\ApiPaymentEndpointApi();
$body = ; // BulkSearchRequest | 

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

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::PaymentEndpointApi;

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

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

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

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: ApiKeyAuth
swagger_client.configuration.api_key['X-API-Key'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# swagger_client.configuration.api_key_prefix['X-API-Key'] = 'Bearer'# Configure HTTP basic authorization: BasicAuth
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

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

try: 
    # Obtain detailed information(vending machine status, operator information and virtual keypad configuration) for multiple vending machines.
    api_response = api_instance.api_vmc_bulk_search_post(body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling PaymentEndpointApi->apiVmcBulkSearchPost: %s\n" % e)

Parameters

Body parameters

Name	Description
body *

Responses

Status: 200 - OK

Schema

apiVmcSearchPost

Obtain detailed information(vending machine status, company info and virtual keypad configuration) for a single vending machine.

/api/vmc_search

Usage and SDK Samples

curl -X POST\
-H "X-API-Key: [[apiKey]]"\
 -H "Authorization: Basic [[basicHash]]"\
-H "Accept: application/json"\
-H "Content-Type: application/json"\
"https://api.connectivity.REGION.vendingontrack.com/connectivity-platform/api/vmc_search"

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.PaymentEndpointApi;

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

public class PaymentEndpointApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // 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");
        // Configure HTTP basic authorization: BasicAuth
        HttpBasicAuth BasicAuth = (HttpBasicAuth) defaultClient.getAuthentication("BasicAuth");
        BasicAuth.setUsername("YOUR USERNAME");
        BasicAuth.setPassword("YOUR PASSWORD");

        PaymentEndpointApi apiInstance = new PaymentEndpointApi();
        SearchRequest body = ; // SearchRequest | 
        try {
            SearchResponse result = apiInstance.apiVmcSearchPost(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling PaymentEndpointApi#apiVmcSearchPost");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.PaymentEndpointApi;

public class PaymentEndpointApiExample {

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

Configuration *apiConfig = [Configuration sharedConfig];
// 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"];
// Configure HTTP basic authorization (authentication scheme: BasicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];
SearchRequest *body = ; // 

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

// Obtain detailed information(vending machine status, company info and virtual keypad configuration) for a single vending machine.
[apiInstance apiVmcSearchPostWith:body
              completionHandler: ^(SearchResponse output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var VendingMachineApiDocumentConnectivityPlatformVendingOnTrack = require('vending_machine_api_document___connectivity_platform___vending_on_track');
var defaultClient = VendingMachineApiDocumentConnectivityPlatformVendingOnTrack.ApiClient.instance;

// 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"
// Configure HTTP basic authorization: BasicAuth
var BasicAuth = defaultClient.authentications['BasicAuth'];
BasicAuth.username = 'YOUR USERNAME'
BasicAuth.password = 'YOUR PASSWORD'

var api = new VendingMachineApiDocumentConnectivityPlatformVendingOnTrack.PaymentEndpointApi()
var body = ; // {{SearchRequest}} 

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

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            // 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");            // Configure HTTP basic authorization: BasicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new PaymentEndpointApi();
            var body = new SearchRequest(); // SearchRequest | 

            try
            {
                // Obtain detailed information(vending machine status, company info and virtual keypad configuration) for a single vending machine.
                SearchResponse result = apiInstance.apiVmcSearchPost(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling PaymentEndpointApi.apiVmcSearchPost: " + e.Message );
            }
        }
    }
}

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

// Configure API key authorization: ApiKeyAuth
Swagger\Client\Configuration::getDefaultConfiguration()->setApiKey('X-API-Key', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// Swagger\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('X-API-Key', 'Bearer');// Configure HTTP basic authorization: BasicAuth
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\ApiPaymentEndpointApi();
$body = ; // SearchRequest | 

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

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::PaymentEndpointApi;

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

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

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

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: ApiKeyAuth
swagger_client.configuration.api_key['X-API-Key'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# swagger_client.configuration.api_key_prefix['X-API-Key'] = 'Bearer'# Configure HTTP basic authorization: BasicAuth
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

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

try: 
    # Obtain detailed information(vending machine status, company info and virtual keypad configuration) for a single vending machine.
    api_response = api_instance.api_vmc_search_post(body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling PaymentEndpointApi->apiVmcSearchPost: %s\n" % e)

Parameters

Body parameters

Name	Description
body *

Responses

Status: 200 - OK

Schema

apiVmcUserKeysPost

After customer made selection on virtual keypad, notify vending machine about the inputs.

/api/vmc_user_keys

Usage and SDK Samples

curl -X POST\
-H "X-API-Key: [[apiKey]]"\
 -H "Authorization: Basic [[basicHash]]"\
-H "Accept: application/json"\
-H "Content-Type: application/json"\
"https://api.connectivity.REGION.vendingontrack.com/connectivity-platform/api/vmc_user_keys"

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.PaymentEndpointApi;

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

public class PaymentEndpointApiExample {

    public static void main(String[] args) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // 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");
        // Configure HTTP basic authorization: BasicAuth
        HttpBasicAuth BasicAuth = (HttpBasicAuth) defaultClient.getAuthentication("BasicAuth");
        BasicAuth.setUsername("YOUR USERNAME");
        BasicAuth.setPassword("YOUR PASSWORD");

        PaymentEndpointApi apiInstance = new PaymentEndpointApi();
        UserKeysRequest body = ; // UserKeysRequest | 
        try {
            UserKeysResponse result = apiInstance.apiVmcUserKeysPost(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling PaymentEndpointApi#apiVmcUserKeysPost");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.PaymentEndpointApi;

public class PaymentEndpointApiExample {

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

Configuration *apiConfig = [Configuration sharedConfig];
// 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"];
// Configure HTTP basic authorization (authentication scheme: BasicAuth)
[apiConfig setUsername:@"YOUR_USERNAME"];
[apiConfig setPassword:@"YOUR_PASSWORD"];
UserKeysRequest *body = ; // 

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

// After customer made selection on virtual keypad, notify vending machine about the inputs.
[apiInstance apiVmcUserKeysPostWith:body
              completionHandler: ^(UserKeysResponse output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var VendingMachineApiDocumentConnectivityPlatformVendingOnTrack = require('vending_machine_api_document___connectivity_platform___vending_on_track');
var defaultClient = VendingMachineApiDocumentConnectivityPlatformVendingOnTrack.ApiClient.instance;

// 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"
// Configure HTTP basic authorization: BasicAuth
var BasicAuth = defaultClient.authentications['BasicAuth'];
BasicAuth.username = 'YOUR USERNAME'
BasicAuth.password = 'YOUR PASSWORD'

var api = new VendingMachineApiDocumentConnectivityPlatformVendingOnTrack.PaymentEndpointApi()
var body = ; // {{UserKeysRequest}} 

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

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

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

            // 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");            // Configure HTTP basic authorization: BasicAuth
            Configuration.Default.Username = "YOUR_USERNAME";
            Configuration.Default.Password = "YOUR_PASSWORD";

            var apiInstance = new PaymentEndpointApi();
            var body = new UserKeysRequest(); // UserKeysRequest | 

            try
            {
                // After customer made selection on virtual keypad, notify vending machine about the inputs.
                UserKeysResponse result = apiInstance.apiVmcUserKeysPost(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling PaymentEndpointApi.apiVmcUserKeysPost: " + e.Message );
            }
        }
    }
}

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

// Configure API key authorization: ApiKeyAuth
Swagger\Client\Configuration::getDefaultConfiguration()->setApiKey('X-API-Key', 'YOUR_API_KEY');
// Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
// Swagger\Client\Configuration::getDefaultConfiguration()->setApiKeyPrefix('X-API-Key', 'Bearer');// Configure HTTP basic authorization: BasicAuth
Swagger\Client\Configuration::getDefaultConfiguration()->setUsername('YOUR_USERNAME');
Swagger\Client\Configuration::getDefaultConfiguration()->setPassword('YOUR_PASSWORD');

$api_instance = new Swagger\Client\ApiPaymentEndpointApi();
$body = ; // UserKeysRequest | 

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

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::PaymentEndpointApi;

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

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

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

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# Configure API key authorization: ApiKeyAuth
swagger_client.configuration.api_key['X-API-Key'] = 'YOUR_API_KEY'
# Uncomment below to setup prefix (e.g. Bearer) for API key, if needed
# swagger_client.configuration.api_key_prefix['X-API-Key'] = 'Bearer'# Configure HTTP basic authorization: BasicAuth
swagger_client.configuration.username = 'YOUR_USERNAME'
swagger_client.configuration.password = 'YOUR_PASSWORD'

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

try: 
    # After customer made selection on virtual keypad, notify vending machine about the inputs.
    api_response = api_instance.api_vmc_user_keys_post(body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling PaymentEndpointApi->apiVmcUserKeysPost: %s\n" % e)

Parameters

Body parameters

Name	Description
body *

Responses

Status: 200 - OK

Schema

Vending Machine API Document - Connectivity Platform - Vending on Track

API and SDK Documentation

PaymentEndpoint

apiLockPost

Usage and SDK Samples

Parameters

Responses

Status: 200 - OK

apiPaidPost

Usage and SDK Samples

Parameters

Responses

Status: 200 - OK

apiUnlockPost

Usage and SDK Samples

Parameters

Responses

Status: 200 - OK

apiVmcBulkSearchPost

Usage and SDK Samples

Parameters

Responses

Status: 200 - OK

apiVmcSearchPost

Usage and SDK Samples

Parameters

Responses

Status: 200 - OK

apiVmcUserKeysPost

Usage and SDK Samples

Parameters

Responses

Status: 200 - OK