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 "Authorization: Basic [[basicHash]]" \
-H "X-API-Key: [[apiKey]]" \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "https://api.connectivity.REGION.vendingontrack.com/connectivity-platform/api/lock" \
 -d '{
  "vm_id" : "vm_id",
  "balance" : 0,
  "txnRef" : "txnRef",
  "id" : "id"
}'

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

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

public class PaymentEndpointApiExample {
    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
        PaymentEndpointApi apiInstance = new PaymentEndpointApi();
        LockRequest lockRequest = ; // LockRequest | 

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final LockRequest lockRequest = new LockRequest(); // LockRequest | 

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

import org.openapitools.client.api.PaymentEndpointApi;

public class PaymentEndpointApiExample {
    public static void main(String[] args) {
        PaymentEndpointApi apiInstance = new PaymentEndpointApi();
        LockRequest lockRequest = ; // LockRequest | 

        try {
            LockResponse result = apiInstance.apiLockPost(lockRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling PaymentEndpointApi#apiLockPost");
            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
PaymentEndpointApi *apiInstance = [[PaymentEndpointApi alloc] init];
LockRequest *lockRequest = ; // 

// Start a transaction by locking a vending machine.
[apiInstance apiLockPostWith:lockRequest
              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 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 VendingMachineApiDocumentConnectivityPlatformVendingOnTrack.PaymentEndpointApi()
var lockRequest = ; // {LockRequest} 

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

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

namespace Example
{
    public class apiLockPostExample
    {
        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 PaymentEndpointApi();
            var lockRequest = new LockRequest(); // LockRequest | 

            try {
                // Start a transaction by locking a vending machine.
                LockResponse result = apiInstance.apiLockPost(lockRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling PaymentEndpointApi.apiLockPost: " + 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\PaymentEndpointApi();
$lockRequest = ; // LockRequest | 

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

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::PaymentEndpointApi;
# 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::PaymentEndpointApi->new();
my $lockRequest = WWW::OPenAPIClient::Object::LockRequest->new(); # LockRequest | 

eval {
    my $result = $api_instance->apiLockPost(lockRequest => $lockRequest);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling PaymentEndpointApi->apiLockPost: $@\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.PaymentEndpointApi()
lockRequest =  # LockRequest | 

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

extern crate PaymentEndpointApi;

pub fn main() {
    let lockRequest = ; // LockRequest

    let mut context = PaymentEndpointApi::Context::default();
    let result = client.apiLockPost(lockRequest, &context).wait();

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

Scopes

Parameters

Body parameters

Name	Description
lockRequest *

Responses

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 "Authorization: Basic [[basicHash]]" \
-H "X-API-Key: [[apiKey]]" \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "https://api.connectivity.REGION.vendingontrack.com/connectivity-platform/api/paid" \
 -d '{
  "surcharge" : 1,
  "price" : 6,
  "discount" : 0,
  "txnRef" : "txnRef"
}'

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

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

public class PaymentEndpointApiExample {
    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
        PaymentEndpointApi apiInstance = new PaymentEndpointApi();
        TransactionPaidRequest paidRequest = ; // TransactionPaidRequest | 

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final TransactionPaidRequest paidRequest = new TransactionPaidRequest(); // TransactionPaidRequest | 

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

import org.openapitools.client.api.PaymentEndpointApi;

public class PaymentEndpointApiExample {
    public static void main(String[] args) {
        PaymentEndpointApi apiInstance = new PaymentEndpointApi();
        TransactionPaidRequest paidRequest = ; // TransactionPaidRequest | 

        try {
            TransactionPaidResponse result = apiInstance.apiPaidPost(paidRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling PaymentEndpointApi#apiPaidPost");
            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
PaymentEndpointApi *apiInstance = [[PaymentEndpointApi alloc] init];
TransactionPaidRequest *paidRequest = ; // 

// Mark an ongoing transaction as paid. The transaction must be authorized by caller.
[apiInstance apiPaidPostWith:paidRequest
              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 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 VendingMachineApiDocumentConnectivityPlatformVendingOnTrack.PaymentEndpointApi()
var paidRequest = ; // {TransactionPaidRequest} 

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

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

namespace Example
{
    public class apiPaidPostExample
    {
        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 PaymentEndpointApi();
            var paidRequest = new TransactionPaidRequest(); // TransactionPaidRequest | 

            try {
                // Mark an ongoing transaction as paid. The transaction must be authorized by caller.
                TransactionPaidResponse result = apiInstance.apiPaidPost(paidRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling PaymentEndpointApi.apiPaidPost: " + 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\PaymentEndpointApi();
$paidRequest = ; // TransactionPaidRequest | 

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

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::PaymentEndpointApi;
# 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::PaymentEndpointApi->new();
my $paidRequest = WWW::OPenAPIClient::Object::TransactionPaidRequest->new(); # TransactionPaidRequest | 

eval {
    my $result = $api_instance->apiPaidPost(paidRequest => $paidRequest);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling PaymentEndpointApi->apiPaidPost: $@\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.PaymentEndpointApi()
paidRequest =  # TransactionPaidRequest | 

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

extern crate PaymentEndpointApi;

pub fn main() {
    let paidRequest = ; // TransactionPaidRequest

    let mut context = PaymentEndpointApi::Context::default();
    let result = client.apiPaidPost(paidRequest, &context).wait();

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

Scopes

Parameters

Body parameters

Name	Description
paidRequest *

Responses

Schema

apiUnlockPost

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

/api/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://api.connectivity.REGION.vendingontrack.com/connectivity-platform/api/unlock" \
 -d '{
  "vm_id" : "vm_id",
  "txnRef" : "txnRef",
  "id" : "id"
}'

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

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

public class PaymentEndpointApiExample {
    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
        PaymentEndpointApi apiInstance = new PaymentEndpointApi();
        CancelRequest unlockRequest = ; // CancelRequest | 

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final CancelRequest unlockRequest = new CancelRequest(); // CancelRequest | 

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

import org.openapitools.client.api.PaymentEndpointApi;

public class PaymentEndpointApiExample {
    public static void main(String[] args) {
        PaymentEndpointApi apiInstance = new PaymentEndpointApi();
        CancelRequest unlockRequest = ; // CancelRequest | 

        try {
            CancelResponse result = apiInstance.apiUnlockPost(unlockRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling PaymentEndpointApi#apiUnlockPost");
            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
PaymentEndpointApi *apiInstance = [[PaymentEndpointApi alloc] init];
CancelRequest *unlockRequest = ; // 

// Cancel an ongoing transaction before authorizing payment. Has no side effect if called after payment for the transaction has already been made (/api/paid).
[apiInstance apiUnlockPostWith:unlockRequest
              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 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 VendingMachineApiDocumentConnectivityPlatformVendingOnTrack.PaymentEndpointApi()
var unlockRequest = ; // {CancelRequest} 

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

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

namespace Example
{
    public class apiUnlockPostExample
    {
        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 PaymentEndpointApi();
            var unlockRequest = new CancelRequest(); // CancelRequest | 

            try {
                // Cancel an ongoing transaction before authorizing payment. Has no side effect if called after payment for the transaction has already been made (/api/paid).
                CancelResponse result = apiInstance.apiUnlockPost(unlockRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling PaymentEndpointApi.apiUnlockPost: " + 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\PaymentEndpointApi();
$unlockRequest = ; // CancelRequest | 

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

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::PaymentEndpointApi;
# 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::PaymentEndpointApi->new();
my $unlockRequest = WWW::OPenAPIClient::Object::CancelRequest->new(); # CancelRequest | 

eval {
    my $result = $api_instance->apiUnlockPost(unlockRequest => $unlockRequest);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling PaymentEndpointApi->apiUnlockPost: $@\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.PaymentEndpointApi()
unlockRequest =  # CancelRequest | 

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

extern crate PaymentEndpointApi;

pub fn main() {
    let unlockRequest = ; // CancelRequest

    let mut context = PaymentEndpointApi::Context::default();
    let result = client.apiUnlockPost(unlockRequest, &context).wait();

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

Scopes

Parameters

Body parameters

Name	Description
unlockRequest *

Responses

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 "Authorization: Basic [[basicHash]]" \
-H "X-API-Key: [[apiKey]]" \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "https://api.connectivity.REGION.vendingontrack.com/connectivity-platform/api/vmc_bulk_search" \
 -d '{
  "vms" : [ "vms", "vms" ]
}'

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

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

public class PaymentEndpointApiExample {
    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
        PaymentEndpointApi apiInstance = new PaymentEndpointApi();
        BulkSearchRequest bulkSearchRequest = ; // BulkSearchRequest | 

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final BulkSearchRequest bulkSearchRequest = new BulkSearchRequest(); // BulkSearchRequest | 

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

import org.openapitools.client.api.PaymentEndpointApi;

public class PaymentEndpointApiExample {
    public static void main(String[] args) {
        PaymentEndpointApi apiInstance = new PaymentEndpointApi();
        BulkSearchRequest bulkSearchRequest = ; // BulkSearchRequest | 

        try {
            BulkSearchResponse result = apiInstance.apiVmcBulkSearchPost(bulkSearchRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling PaymentEndpointApi#apiVmcBulkSearchPost");
            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
PaymentEndpointApi *apiInstance = [[PaymentEndpointApi alloc] init];
BulkSearchRequest *bulkSearchRequest = ; // 

// Obtain detailed information (vending machine status, operator information, and virtual keypad configuration) for multiple vending machines.
[apiInstance apiVmcBulkSearchPostWith:bulkSearchRequest
              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 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 VendingMachineApiDocumentConnectivityPlatformVendingOnTrack.PaymentEndpointApi()
var bulkSearchRequest = ; // {BulkSearchRequest} 

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

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

namespace Example
{
    public class apiVmcBulkSearchPostExample
    {
        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 PaymentEndpointApi();
            var bulkSearchRequest = new BulkSearchRequest(); // BulkSearchRequest | 

            try {
                // Obtain detailed information (vending machine status, operator information, and virtual keypad configuration) for multiple vending machines.
                BulkSearchResponse result = apiInstance.apiVmcBulkSearchPost(bulkSearchRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling PaymentEndpointApi.apiVmcBulkSearchPost: " + 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\PaymentEndpointApi();
$bulkSearchRequest = ; // BulkSearchRequest | 

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

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::PaymentEndpointApi;
# 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::PaymentEndpointApi->new();
my $bulkSearchRequest = WWW::OPenAPIClient::Object::BulkSearchRequest->new(); # BulkSearchRequest | 

eval {
    my $result = $api_instance->apiVmcBulkSearchPost(bulkSearchRequest => $bulkSearchRequest);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling PaymentEndpointApi->apiVmcBulkSearchPost: $@\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.PaymentEndpointApi()
bulkSearchRequest =  # 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(bulkSearchRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling PaymentEndpointApi->apiVmcBulkSearchPost: %s\n" % e)

extern crate PaymentEndpointApi;

pub fn main() {
    let bulkSearchRequest = ; // BulkSearchRequest

    let mut context = PaymentEndpointApi::Context::default();
    let result = client.apiVmcBulkSearchPost(bulkSearchRequest, &context).wait();

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

Scopes

Parameters

Body parameters

Name	Description
bulkSearchRequest *

Responses

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 "Authorization: Basic [[basicHash]]" \
-H "X-API-Key: [[apiKey]]" \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "https://api.connectivity.REGION.vendingontrack.com/connectivity-platform/api/vmc_search" \
 -d '{
  "vm_id" : "vm_id"
}'

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

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

public class PaymentEndpointApiExample {
    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
        PaymentEndpointApi apiInstance = new PaymentEndpointApi();
        SearchRequest vmcSearchRequest = ; // SearchRequest | 

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final SearchRequest vmcSearchRequest = new SearchRequest(); // SearchRequest | 

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

import org.openapitools.client.api.PaymentEndpointApi;

public class PaymentEndpointApiExample {
    public static void main(String[] args) {
        PaymentEndpointApi apiInstance = new PaymentEndpointApi();
        SearchRequest vmcSearchRequest = ; // SearchRequest | 

        try {
            SearchResponse result = apiInstance.apiVmcSearchPost(vmcSearchRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling PaymentEndpointApi#apiVmcSearchPost");
            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
PaymentEndpointApi *apiInstance = [[PaymentEndpointApi alloc] init];
SearchRequest *vmcSearchRequest = ; // 

// Obtain detailed information (vending machine status, company info, and virtual keypad configuration) for a single vending machine.
[apiInstance apiVmcSearchPostWith:vmcSearchRequest
              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 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 VendingMachineApiDocumentConnectivityPlatformVendingOnTrack.PaymentEndpointApi()
var vmcSearchRequest = ; // {SearchRequest} 

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

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

namespace Example
{
    public class apiVmcSearchPostExample
    {
        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 PaymentEndpointApi();
            var vmcSearchRequest = 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(vmcSearchRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling PaymentEndpointApi.apiVmcSearchPost: " + 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\PaymentEndpointApi();
$vmcSearchRequest = ; // SearchRequest | 

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

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::PaymentEndpointApi;
# 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::PaymentEndpointApi->new();
my $vmcSearchRequest = WWW::OPenAPIClient::Object::SearchRequest->new(); # SearchRequest | 

eval {
    my $result = $api_instance->apiVmcSearchPost(vmcSearchRequest => $vmcSearchRequest);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling PaymentEndpointApi->apiVmcSearchPost: $@\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.PaymentEndpointApi()
vmcSearchRequest =  # 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(vmcSearchRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling PaymentEndpointApi->apiVmcSearchPost: %s\n" % e)

extern crate PaymentEndpointApi;

pub fn main() {
    let vmcSearchRequest = ; // SearchRequest

    let mut context = PaymentEndpointApi::Context::default();
    let result = client.apiVmcSearchPost(vmcSearchRequest, &context).wait();

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

Scopes

Parameters

Body parameters

Name	Description
vmcSearchRequest *

Responses

Schema

apiVmcUserKeysPost

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

/api/vmc_user_keys

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://api.connectivity.REGION.vendingontrack.com/connectivity-platform/api/vmc_user_keys" \
 -d '{
  "vm_id" : "vm_id",
  "keys" : [ 0, 0 ],
  "txnRef" : "txnRef"
}'

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

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

public class PaymentEndpointApiExample {
    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
        PaymentEndpointApi apiInstance = new PaymentEndpointApi();
        UserKeysRequest userKeysRequest = ; // UserKeysRequest | 

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final UserKeysRequest userKeysRequest = new UserKeysRequest(); // UserKeysRequest | 

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

import org.openapitools.client.api.PaymentEndpointApi;

public class PaymentEndpointApiExample {
    public static void main(String[] args) {
        PaymentEndpointApi apiInstance = new PaymentEndpointApi();
        UserKeysRequest userKeysRequest = ; // UserKeysRequest | 

        try {
            UserKeysResponse result = apiInstance.apiVmcUserKeysPost(userKeysRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling PaymentEndpointApi#apiVmcUserKeysPost");
            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
PaymentEndpointApi *apiInstance = [[PaymentEndpointApi alloc] init];
UserKeysRequest *userKeysRequest = ; // 

// After the customer makes a selection on the virtual keypad, notify the vending machine about the inputs.
[apiInstance apiVmcUserKeysPostWith:userKeysRequest
              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 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 VendingMachineApiDocumentConnectivityPlatformVendingOnTrack.PaymentEndpointApi()
var userKeysRequest = ; // {UserKeysRequest} 

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

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

namespace Example
{
    public class apiVmcUserKeysPostExample
    {
        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 PaymentEndpointApi();
            var userKeysRequest = new UserKeysRequest(); // UserKeysRequest | 

            try {
                // After the customer makes a selection on the virtual keypad, notify the vending machine about the inputs.
                UserKeysResponse result = apiInstance.apiVmcUserKeysPost(userKeysRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling PaymentEndpointApi.apiVmcUserKeysPost: " + 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\PaymentEndpointApi();
$userKeysRequest = ; // UserKeysRequest | 

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

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::PaymentEndpointApi;
# 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::PaymentEndpointApi->new();
my $userKeysRequest = WWW::OPenAPIClient::Object::UserKeysRequest->new(); # UserKeysRequest | 

eval {
    my $result = $api_instance->apiVmcUserKeysPost(userKeysRequest => $userKeysRequest);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling PaymentEndpointApi->apiVmcUserKeysPost: $@\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.PaymentEndpointApi()
userKeysRequest =  # UserKeysRequest | 

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

extern crate PaymentEndpointApi;

pub fn main() {
    let userKeysRequest = ; // UserKeysRequest

    let mut context = PaymentEndpointApi::Context::default();
    let result = client.apiVmcUserKeysPost(userKeysRequest, &context).wait();

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

Scopes

Parameters

Body parameters

Name	Description
userKeysRequest *

Responses

Schema

Vending Machine API Document - Connectivity Platform - Vending on Track

API and SDK Documentation

PaymentEndpoint

apiLockPost

Usage and SDK Samples

Scopes

Parameters

Responses

apiPaidPost

Usage and SDK Samples

Scopes

Parameters

Responses

apiUnlockPost

Usage and SDK Samples

Scopes

Parameters

Responses

apiVmcBulkSearchPost

Usage and SDK Samples

Scopes

Parameters

Responses

apiVmcSearchPost

Usage and SDK Samples

Scopes

Parameters

Responses

apiVmcUserKeysPost

Usage and SDK Samples

Scopes

Parameters

Responses