GoPOS Backend API

Auth

authGoogleCallbackGet

Google OAuth callback

Handles the Google OAuth callback. Exchanges the authorization code for tokens, creates/updates the user, and returns JWT tokens. 


/auth/google/callback

Usage and SDK Samples

curl -X GET\
-H "Accept: application/json"\
"http://localhost:8180/auth/google/callback?code=&error="
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.AuthApi;

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

public class AuthApiExample {

    public static void main(String[] args) {
        
        AuthApi apiInstance = new AuthApi();
        String code = code_example; // String | Authorization code from Google
        String error = error_example; // String | Error code if OAuth failed
        try {
            AuthResponse result = apiInstance.authGoogleCallbackGet(code, error);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AuthApi#authGoogleCallbackGet");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.AuthApi;

public class AuthApiExample {

    public static void main(String[] args) {
        AuthApi apiInstance = new AuthApi();
        String code = code_example; // String | Authorization code from Google
        String error = error_example; // String | Error code if OAuth failed
        try {
            AuthResponse result = apiInstance.authGoogleCallbackGet(code, error);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AuthApi#authGoogleCallbackGet");
            e.printStackTrace();
        }
    }
}
String *code = code_example; // Authorization code from Google
String *error = error_example; // Error code if OAuth failed (optional)

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

// Google OAuth callback
[apiInstance authGoogleCallbackGetWith:code
    error:error
              completionHandler: ^(AuthResponse output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var GoPosBackendApi = require('go_pos_backend_api');

var api = new GoPosBackendApi.AuthApi()
var code = code_example; // {{String}} Authorization code from Google
var opts = { 
  'error': error_example // {{String}} Error code if OAuth failed
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.authGoogleCallbackGet(code, opts, callback);

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

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

            var apiInstance = new AuthApi();
            var code = code_example;  // String | Authorization code from Google
            var error = error_example;  // String | Error code if OAuth failed (optional) 

            try
            {
                // Google OAuth callback
                AuthResponse result = apiInstance.authGoogleCallbackGet(code, error);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AuthApi.authGoogleCallbackGet: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiAuthApi();
$code = code_example; // String | Authorization code from Google
$error = error_example; // String | Error code if OAuth failed

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

my $api_instance = WWW::SwaggerClient::AuthApi->new();
my $code = code_example; # String | Authorization code from Google
my $error = error_example; # String | Error code if OAuth failed

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

# create an instance of the API class
api_instance = swagger_client.AuthApi()
code = code_example # String | Authorization code from Google
error = error_example # String | Error code if OAuth failed (optional)

try: 
    # Google OAuth callback
    api_response = api_instance.auth_google_callback_get(code, error=error)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AuthApi->authGoogleCallbackGet: %s\n" % e)

Parameters

Query parameters
Name Description
code*
String
Authorization code from Google
Required
error
String
Error code if OAuth failed

Responses

Status: 200 - Authentication successful (JSON mode)

Status: 302 - Redirect to frontend with tokens (redirect mode)

Status: 400 - Invalid request

Status: 401 - Authentication failed

authGoogleStartPost

Get Google OAuth URL

Returns the Google OAuth authorization URL to start the login flow


/auth/google/start

Usage and SDK Samples

curl -X POST\
-H "Accept: application/json"\
"http://localhost:8180/auth/google/start"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.AuthApi;

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

public class AuthApiExample {

    public static void main(String[] args) {
        
        AuthApi apiInstance = new AuthApi();
        try {
            ApiResponse result = apiInstance.authGoogleStartPost();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AuthApi#authGoogleStartPost");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.AuthApi;

public class AuthApiExample {

    public static void main(String[] args) {
        AuthApi apiInstance = new AuthApi();
        try {
            ApiResponse result = apiInstance.authGoogleStartPost();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AuthApi#authGoogleStartPost");
            e.printStackTrace();
        }
    }
}

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

// Get Google OAuth URL
[apiInstance authGoogleStartPostWithCompletionHandler: 
              ^(ApiResponse output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var GoPosBackendApi = require('go_pos_backend_api');

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

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

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

            var apiInstance = new AuthApi();

            try
            {
                // Get Google OAuth URL
                ApiResponse result = apiInstance.authGoogleStartPost();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AuthApi.authGoogleStartPost: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiAuthApi();

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

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

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

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

try: 
    # Get Google OAuth URL
    api_response = api_instance.auth_google_start_post()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AuthApi->authGoogleStartPost: %s\n" % e)

Parameters

Responses

Status: 200 - OAuth URL generated

authLogoutPost

Logout

Revoke the refresh token


/auth/logout

Usage and SDK Samples

curl -X POST\
-H "Content-Type: application/json"\
"http://localhost:8180/auth/logout"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.AuthApi;

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

public class AuthApiExample {

    public static void main(String[] args) {
        
        AuthApi apiInstance = new AuthApi();
        Object body = ; // Object | 
        try {
            apiInstance.authLogoutPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling AuthApi#authLogoutPost");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.AuthApi;

public class AuthApiExample {

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

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

// Logout
[apiInstance authLogoutPostWith:body
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var GoPosBackendApi = require('go_pos_backend_api');

var api = new GoPosBackendApi.AuthApi()
var body = ; // {{Object}} 

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

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

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

            var apiInstance = new AuthApi();
            var body = new Object(); // Object | 

            try
            {
                // Logout
                apiInstance.authLogoutPost(body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AuthApi.authLogoutPost: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiAuthApi();
$body = ; // Object | 

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

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

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

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

try: 
    # Logout
    api_instance.auth_logout_post(body)
except ApiException as e:
    print("Exception when calling AuthApi->authLogoutPost: %s\n" % e)

Parameters

Body parameters
Name Description
body *

Responses

Status: 200 - Logged out successfully

authRefreshPost

Refresh tokens

Exchange a refresh token for a new access/refresh token pair


/auth/refresh

Usage and SDK Samples

curl -X POST\
-H "Accept: application/json"\
-H "Content-Type: application/json"\
"http://localhost:8180/auth/refresh"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.AuthApi;

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

public class AuthApiExample {

    public static void main(String[] args) {
        
        AuthApi apiInstance = new AuthApi();
        Object body = ; // Object | 
        try {
            TokenPair result = apiInstance.authRefreshPost(body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AuthApi#authRefreshPost");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.AuthApi;

public class AuthApiExample {

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

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

// Refresh tokens
[apiInstance authRefreshPostWith:body
              completionHandler: ^(TokenPair output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var GoPosBackendApi = require('go_pos_backend_api');

var api = new GoPosBackendApi.AuthApi()
var body = ; // {{Object}} 

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

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

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

            var apiInstance = new AuthApi();
            var body = new Object(); // Object | 

            try
            {
                // Refresh tokens
                TokenPair result = apiInstance.authRefreshPost(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling AuthApi.authRefreshPost: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiAuthApi();
$body = ; // Object | 

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

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

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

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

try: 
    # Refresh tokens
    api_response = api_instance.auth_refresh_post(body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AuthApi->authRefreshPost: %s\n" % e)

Parameters

Body parameters
Name Description
body *

Responses

Status: 200 - Tokens refreshed

Status: 401 - Invalid or expired refresh token

Health

healthGet

Health check


/health

Usage and SDK Samples

curl -X GET\
-H "Accept: application/json"\
"http://localhost:8180/health"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.HealthApi;

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

public class HealthApiExample {

    public static void main(String[] args) {
        
        HealthApi apiInstance = new HealthApi();
        try {
            Object result = apiInstance.healthGet();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling HealthApi#healthGet");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.HealthApi;

public class HealthApiExample {

    public static void main(String[] args) {
        HealthApi apiInstance = new HealthApi();
        try {
            Object result = apiInstance.healthGet();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling HealthApi#healthGet");
            e.printStackTrace();
        }
    }
}

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

// Health check
[apiInstance healthGetWithCompletionHandler: 
              ^(Object output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var GoPosBackendApi = require('go_pos_backend_api');

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

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

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

            var apiInstance = new HealthApi();

            try
            {
                // Health check
                Object result = apiInstance.healthGet();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling HealthApi.healthGet: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiHealthApi();

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

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

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

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

try: 
    # Health check
    api_response = api_instance.health_get()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling HealthApi->healthGet: %s\n" % e)

Parameters

Responses

Status: 200 - Service is healthy

Orders

ordersGet

List orders (scaffold)

Returns 501 Not Implemented - scaffold for future POS sync


/orders

Usage and SDK Samples

curl -X GET\
 -H "Authorization: Bearer [[accessToken]]"\
"http://localhost:8180/orders"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.OrdersApi;

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

public class OrdersApiExample {

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


        OrdersApi apiInstance = new OrdersApi();
        UUID xMerchantId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | Merchant context for the request
        try {
            apiInstance.ordersGet(xMerchantId);
        } catch (ApiException e) {
            System.err.println("Exception when calling OrdersApi#ordersGet");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.OrdersApi;

public class OrdersApiExample {

    public static void main(String[] args) {
        OrdersApi apiInstance = new OrdersApi();
        UUID xMerchantId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | Merchant context for the request
        try {
            apiInstance.ordersGet(xMerchantId);
        } catch (ApiException e) {
            System.err.println("Exception when calling OrdersApi#ordersGet");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];
UUID *xMerchantId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // Merchant context for the request

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

// List orders (scaffold)
[apiInstance ordersGetWith:xMerchantId
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var GoPosBackendApi = require('go_pos_backend_api');
var defaultClient = GoPosBackendApi.ApiClient.instance;


var api = new GoPosBackendApi.OrdersApi()
var xMerchantId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {{UUID}} Merchant context for the request

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.ordersGet(xMerchantId, callback);

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

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


            var apiInstance = new OrdersApi();
            var xMerchantId = new UUID(); // UUID | Merchant context for the request

            try
            {
                // List orders (scaffold)
                apiInstance.ordersGet(xMerchantId);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling OrdersApi.ordersGet: " + e.Message );
            }
        }
    }
}

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


$api_instance = new Swagger\Client\ApiOrdersApi();
$xMerchantId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | Merchant context for the request

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


my $api_instance = WWW::SwaggerClient::OrdersApi->new();
my $xMerchantId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | Merchant context for the request

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


# create an instance of the API class
api_instance = swagger_client.OrdersApi()
xMerchantId = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID | Merchant context for the request

try: 
    # List orders (scaffold)
    api_instance.orders_get(xMerchantId)
except ApiException as e:
    print("Exception when calling OrdersApi->ordersGet: %s\n" % e)

Parameters

Header parameters
Name Description
X-Merchant-Id*
UUID (uuid)
Merchant context for the request
Required

Responses

Status: 501 - Not implemented

ordersIdGet

Get order by ID (scaffold)

Returns 501 Not Implemented - scaffold for future POS sync


/orders/{id}

Usage and SDK Samples

curl -X GET\
 -H "Authorization: Bearer [[accessToken]]"\
"http://localhost:8180/orders/{id}"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.OrdersApi;

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

public class OrdersApiExample {

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


        OrdersApi apiInstance = new OrdersApi();
        UUID xMerchantId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | Merchant context for the request
        UUID id = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        try {
            apiInstance.ordersIdGet(xMerchantId, id);
        } catch (ApiException e) {
            System.err.println("Exception when calling OrdersApi#ordersIdGet");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.OrdersApi;

public class OrdersApiExample {

    public static void main(String[] args) {
        OrdersApi apiInstance = new OrdersApi();
        UUID xMerchantId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | Merchant context for the request
        UUID id = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 
        try {
            apiInstance.ordersIdGet(xMerchantId, id);
        } catch (ApiException e) {
            System.err.println("Exception when calling OrdersApi#ordersIdGet");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];
UUID *xMerchantId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // Merchant context for the request
UUID *id = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // 

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

// Get order by ID (scaffold)
[apiInstance ordersIdGetWith:xMerchantId
    id:id
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var GoPosBackendApi = require('go_pos_backend_api');
var defaultClient = GoPosBackendApi.ApiClient.instance;


var api = new GoPosBackendApi.OrdersApi()
var xMerchantId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {{UUID}} Merchant context for the request
var id = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {{UUID}} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.ordersIdGet(xMerchantId, id, callback);

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

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


            var apiInstance = new OrdersApi();
            var xMerchantId = new UUID(); // UUID | Merchant context for the request
            var id = new UUID(); // UUID | 

            try
            {
                // Get order by ID (scaffold)
                apiInstance.ordersIdGet(xMerchantId, id);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling OrdersApi.ordersIdGet: " + e.Message );
            }
        }
    }
}

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


$api_instance = new Swagger\Client\ApiOrdersApi();
$xMerchantId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | Merchant context for the request
$id = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | 

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


my $api_instance = WWW::SwaggerClient::OrdersApi->new();
my $xMerchantId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | Merchant context for the request
my $id = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | 

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


# create an instance of the API class
api_instance = swagger_client.OrdersApi()
xMerchantId = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID | Merchant context for the request
id = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID | 

try: 
    # Get order by ID (scaffold)
    api_instance.orders_id_get(xMerchantId, id)
except ApiException as e:
    print("Exception when calling OrdersApi->ordersIdGet: %s\n" % e)

Parameters

Path parameters
Name Description
id*
UUID (uuid)
Required
Header parameters
Name Description
X-Merchant-Id*
UUID (uuid)
Merchant context for the request
Required

Responses

Status: 501 - Not implemented

ordersPost

Create order (scaffold)

Returns 501 Not Implemented - scaffold for future POS sync


/orders

Usage and SDK Samples

curl -X POST\
 -H "Authorization: Bearer [[accessToken]]"\
-H "Content-Type: application/json"\
"http://localhost:8180/orders"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.OrdersApi;

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

public class OrdersApiExample {

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


        OrdersApi apiInstance = new OrdersApi();
        CreateOrderRequest body = ; // CreateOrderRequest | 
        UUID xMerchantId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | Merchant context for the request
        try {
            apiInstance.ordersPost(body, xMerchantId);
        } catch (ApiException e) {
            System.err.println("Exception when calling OrdersApi#ordersPost");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.OrdersApi;

public class OrdersApiExample {

    public static void main(String[] args) {
        OrdersApi apiInstance = new OrdersApi();
        CreateOrderRequest body = ; // CreateOrderRequest | 
        UUID xMerchantId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | Merchant context for the request
        try {
            apiInstance.ordersPost(body, xMerchantId);
        } catch (ApiException e) {
            System.err.println("Exception when calling OrdersApi#ordersPost");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];
CreateOrderRequest *body = ; // 
UUID *xMerchantId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // Merchant context for the request

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

// Create order (scaffold)
[apiInstance ordersPostWith:body
    xMerchantId:xMerchantId
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var GoPosBackendApi = require('go_pos_backend_api');
var defaultClient = GoPosBackendApi.ApiClient.instance;


var api = new GoPosBackendApi.OrdersApi()
var body = ; // {{CreateOrderRequest}} 
var xMerchantId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {{UUID}} Merchant context for the request

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.ordersPost(bodyxMerchantId, callback);

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

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


            var apiInstance = new OrdersApi();
            var body = new CreateOrderRequest(); // CreateOrderRequest | 
            var xMerchantId = new UUID(); // UUID | Merchant context for the request

            try
            {
                // Create order (scaffold)
                apiInstance.ordersPost(body, xMerchantId);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling OrdersApi.ordersPost: " + e.Message );
            }
        }
    }
}

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


$api_instance = new Swagger\Client\ApiOrdersApi();
$body = ; // CreateOrderRequest | 
$xMerchantId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | Merchant context for the request

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


my $api_instance = WWW::SwaggerClient::OrdersApi->new();
my $body = WWW::SwaggerClient::Object::CreateOrderRequest->new(); # CreateOrderRequest | 
my $xMerchantId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | Merchant context for the request

eval { 
    $api_instance->ordersPost(body => $body, xMerchantId => $xMerchantId);
};
if ($@) {
    warn "Exception when calling OrdersApi->ordersPost: $@\n";
}
from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint


# create an instance of the API class
api_instance = swagger_client.OrdersApi()
body =  # CreateOrderRequest | 
xMerchantId = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID | Merchant context for the request

try: 
    # Create order (scaffold)
    api_instance.orders_post(body, xMerchantId)
except ApiException as e:
    print("Exception when calling OrdersApi->ordersPost: %s\n" % e)

Parameters

Header parameters
Name Description
X-Merchant-Id*
UUID (uuid)
Merchant context for the request
Required
Body parameters
Name Description
body *

Responses

Status: 501 - Not implemented

Profile

meGet

Get current user profile

Returns the current user's profile and merchant memberships


/me

Usage and SDK Samples

curl -X GET\
 -H "Authorization: Bearer [[accessToken]]"\
-H "Accept: application/json"\
"http://localhost:8180/me"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ProfileApi;

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

public class ProfileApiExample {

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


        ProfileApi apiInstance = new ProfileApi();
        try {
            ProfileResponse result = apiInstance.meGet();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProfileApi#meGet");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.ProfileApi;

public class ProfileApiExample {

    public static void main(String[] args) {
        ProfileApi apiInstance = new ProfileApi();
        try {
            ProfileResponse result = apiInstance.meGet();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProfileApi#meGet");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];

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

// Get current user profile
[apiInstance meGetWithCompletionHandler: 
              ^(ProfileResponse output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var GoPosBackendApi = require('go_pos_backend_api');
var defaultClient = GoPosBackendApi.ApiClient.instance;


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

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

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


            var apiInstance = new ProfileApi();

            try
            {
                // Get current user profile
                ProfileResponse result = apiInstance.meGet();
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ProfileApi.meGet: " + e.Message );
            }
        }
    }
}

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


$api_instance = new Swagger\Client\ApiProfileApi();

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


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

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


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

try: 
    # Get current user profile
    api_response = api_instance.me_get()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ProfileApi->meGet: %s\n" % e)

Parameters

Responses

Status: 200 - User profile

Status: 401 - Unauthorized

meMerchantPost

Create a merchant

Create a new merchant. The current user becomes the owner. Users can only create one merchant. 


/me/merchant

Usage and SDK Samples

curl -X POST\
 -H "Authorization: Bearer [[accessToken]]"\
-H "Accept: application/json"\
-H "Content-Type: application/json"\
"http://localhost:8180/me/merchant"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ProfileApi;

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

public class ProfileApiExample {

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


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

public class ProfileApiExample {

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

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

// Create a merchant
[apiInstance meMerchantPostWith:body
              completionHandler: ^(MerchantResponse output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var GoPosBackendApi = require('go_pos_backend_api');
var defaultClient = GoPosBackendApi.ApiClient.instance;


var api = new GoPosBackendApi.ProfileApi()
var body = ; // {{Object}} 

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

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

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


            var apiInstance = new ProfileApi();
            var body = new Object(); // Object | 

            try
            {
                // Create a merchant
                MerchantResponse result = apiInstance.meMerchantPost(body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ProfileApi.meMerchantPost: " + e.Message );
            }
        }
    }
}

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


$api_instance = new Swagger\Client\ApiProfileApi();
$body = ; // Object | 

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


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

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


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

try: 
    # Create a merchant
    api_response = api_instance.me_merchant_post(body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ProfileApi->meMerchantPost: %s\n" % e)

Parameters

Body parameters
Name Description
body *

Responses

Status: 201 - Merchant created

Status: 401 - Unauthorized

Status: 409 - User already owns a merchant

StripeConnect

stripeConnectDisconnectPost

Disconnect Stripe account

Unlinks the Stripe Connect account from the merchant. Note: This does not delete the Stripe account. 


/stripe/connect/disconnect

Usage and SDK Samples

curl -X POST\
 -H "Authorization: Bearer [[accessToken]]"\
"http://localhost:8180/stripe/connect/disconnect"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.StripeConnectApi;

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

public class StripeConnectApiExample {

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


        StripeConnectApi apiInstance = new StripeConnectApi();
        UUID xMerchantId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | Merchant context for the request
        try {
            apiInstance.stripeConnectDisconnectPost(xMerchantId);
        } catch (ApiException e) {
            System.err.println("Exception when calling StripeConnectApi#stripeConnectDisconnectPost");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.StripeConnectApi;

public class StripeConnectApiExample {

    public static void main(String[] args) {
        StripeConnectApi apiInstance = new StripeConnectApi();
        UUID xMerchantId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | Merchant context for the request
        try {
            apiInstance.stripeConnectDisconnectPost(xMerchantId);
        } catch (ApiException e) {
            System.err.println("Exception when calling StripeConnectApi#stripeConnectDisconnectPost");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];
UUID *xMerchantId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // Merchant context for the request

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

// Disconnect Stripe account
[apiInstance stripeConnectDisconnectPostWith:xMerchantId
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var GoPosBackendApi = require('go_pos_backend_api');
var defaultClient = GoPosBackendApi.ApiClient.instance;


var api = new GoPosBackendApi.StripeConnectApi()
var xMerchantId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {{UUID}} Merchant context for the request

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.stripeConnectDisconnectPost(xMerchantId, callback);

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

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


            var apiInstance = new StripeConnectApi();
            var xMerchantId = new UUID(); // UUID | Merchant context for the request

            try
            {
                // Disconnect Stripe account
                apiInstance.stripeConnectDisconnectPost(xMerchantId);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling StripeConnectApi.stripeConnectDisconnectPost: " + e.Message );
            }
        }
    }
}

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


$api_instance = new Swagger\Client\ApiStripeConnectApi();
$xMerchantId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | Merchant context for the request

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


my $api_instance = WWW::SwaggerClient::StripeConnectApi->new();
my $xMerchantId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | Merchant context for the request

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


# create an instance of the API class
api_instance = swagger_client.StripeConnectApi()
xMerchantId = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID | Merchant context for the request

try: 
    # Disconnect Stripe account
    api_instance.stripe_connect_disconnect_post(xMerchantId)
except ApiException as e:
    print("Exception when calling StripeConnectApi->stripeConnectDisconnectPost: %s\n" % e)

Parameters

Header parameters
Name Description
X-Merchant-Id*
UUID (uuid)
Merchant context for the request
Required

Responses

Status: 200 - Account disconnected

Status: 401 - Unauthorized

Status: 403 - Only merchant owner can disconnect

stripeConnectStartPost

Start Stripe Connect onboarding

Creates a Stripe Connect account (if not exists) and returns the onboarding URL. Only merchant owners can call this endpoint. 


/stripe/connect/start

Usage and SDK Samples

curl -X POST\
 -H "Authorization: Bearer [[accessToken]]"\
-H "Accept: application/json"\
-H "Content-Type: application/json"\
"http://localhost:8180/stripe/connect/start"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.StripeConnectApi;

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

public class StripeConnectApiExample {

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


        StripeConnectApi apiInstance = new StripeConnectApi();
        UUID xMerchantId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | Merchant context for the request
        Object body = ; // Object | 
        try {
            Object result = apiInstance.stripeConnectStartPost(xMerchantId, body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling StripeConnectApi#stripeConnectStartPost");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.StripeConnectApi;

public class StripeConnectApiExample {

    public static void main(String[] args) {
        StripeConnectApi apiInstance = new StripeConnectApi();
        UUID xMerchantId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | Merchant context for the request
        Object body = ; // Object | 
        try {
            Object result = apiInstance.stripeConnectStartPost(xMerchantId, body);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling StripeConnectApi#stripeConnectStartPost");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];
UUID *xMerchantId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // Merchant context for the request
Object *body = ; //  (optional)

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

// Start Stripe Connect onboarding
[apiInstance stripeConnectStartPostWith:xMerchantId
    body:body
              completionHandler: ^(Object output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var GoPosBackendApi = require('go_pos_backend_api');
var defaultClient = GoPosBackendApi.ApiClient.instance;


var api = new GoPosBackendApi.StripeConnectApi()
var xMerchantId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {{UUID}} Merchant context for the request
var opts = { 
  'body':  // {{Object}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.stripeConnectStartPost(xMerchantId, opts, callback);

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

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


            var apiInstance = new StripeConnectApi();
            var xMerchantId = new UUID(); // UUID | Merchant context for the request
            var body = new Object(); // Object |  (optional) 

            try
            {
                // Start Stripe Connect onboarding
                Object result = apiInstance.stripeConnectStartPost(xMerchantId, body);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling StripeConnectApi.stripeConnectStartPost: " + e.Message );
            }
        }
    }
}

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


$api_instance = new Swagger\Client\ApiStripeConnectApi();
$xMerchantId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | Merchant context for the request
$body = ; // Object | 

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


my $api_instance = WWW::SwaggerClient::StripeConnectApi->new();
my $xMerchantId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | Merchant context for the request
my $body = WWW::SwaggerClient::Object::Object->new(); # Object | 

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


# create an instance of the API class
api_instance = swagger_client.StripeConnectApi()
xMerchantId = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID | Merchant context for the request
body =  # Object |  (optional)

try: 
    # Start Stripe Connect onboarding
    api_response = api_instance.stripe_connect_start_post(xMerchantId, body=body)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling StripeConnectApi->stripeConnectStartPost: %s\n" % e)

Parameters

Header parameters
Name Description
X-Merchant-Id*
UUID (uuid)
Merchant context for the request
Required
Body parameters
Name Description
body

Responses

Status: 200 - Onboarding URL generated

Status: 401 - Unauthorized

Status: 403 - Only merchant owner can start Connect onboarding

stripeConnectStatusGet

Get Stripe Connect status

Returns the current Stripe Connect status for the merchant


/stripe/connect/status

Usage and SDK Samples

curl -X GET\
 -H "Authorization: Bearer [[accessToken]]"\
-H "Accept: application/json"\
"http://localhost:8180/stripe/connect/status"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.StripeConnectApi;

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

public class StripeConnectApiExample {

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


        StripeConnectApi apiInstance = new StripeConnectApi();
        UUID xMerchantId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | Merchant context for the request
        try {
            StripeConnectStatus result = apiInstance.stripeConnectStatusGet(xMerchantId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling StripeConnectApi#stripeConnectStatusGet");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.StripeConnectApi;

public class StripeConnectApiExample {

    public static void main(String[] args) {
        StripeConnectApi apiInstance = new StripeConnectApi();
        UUID xMerchantId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | Merchant context for the request
        try {
            StripeConnectStatus result = apiInstance.stripeConnectStatusGet(xMerchantId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling StripeConnectApi#stripeConnectStatusGet");
            e.printStackTrace();
        }
    }
}
Configuration *apiConfig = [Configuration sharedConfig];
UUID *xMerchantId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // Merchant context for the request

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

// Get Stripe Connect status
[apiInstance stripeConnectStatusGetWith:xMerchantId
              completionHandler: ^(StripeConnectStatus output, NSError* error) {
                            if (output) {
                                NSLog(@"%@", output);
                            }
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var GoPosBackendApi = require('go_pos_backend_api');
var defaultClient = GoPosBackendApi.ApiClient.instance;


var api = new GoPosBackendApi.StripeConnectApi()
var xMerchantId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // {{UUID}} Merchant context for the request

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

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

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


            var apiInstance = new StripeConnectApi();
            var xMerchantId = new UUID(); // UUID | Merchant context for the request

            try
            {
                // Get Stripe Connect status
                StripeConnectStatus result = apiInstance.stripeConnectStatusGet(xMerchantId);
                Debug.WriteLine(result);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling StripeConnectApi.stripeConnectStatusGet: " + e.Message );
            }
        }
    }
}

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


$api_instance = new Swagger\Client\ApiStripeConnectApi();
$xMerchantId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; // UUID | Merchant context for the request

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


my $api_instance = WWW::SwaggerClient::StripeConnectApi->new();
my $xMerchantId = 38400000-8cf0-11bd-b23e-10b96e4ef00d; # UUID | Merchant context for the request

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


# create an instance of the API class
api_instance = swagger_client.StripeConnectApi()
xMerchantId = 38400000-8cf0-11bd-b23e-10b96e4ef00d # UUID | Merchant context for the request

try: 
    # Get Stripe Connect status
    api_response = api_instance.stripe_connect_status_get(xMerchantId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling StripeConnectApi->stripeConnectStatusGet: %s\n" % e)

Parameters

Header parameters
Name Description
X-Merchant-Id*
UUID (uuid)
Merchant context for the request
Required

Responses

Status: 200 - Stripe Connect status

Status: 401 - Unauthorized

stripeWebhookPost

Stripe webhook endpoint

Receives Stripe webhook events. Verifies signature and processes account.updated events. 


/stripe/webhook

Usage and SDK Samples

curl -X POST\
-H "Content-Type: application/json"\
"http://localhost:8180/stripe/webhook"
import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.StripeConnectApi;

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

public class StripeConnectApiExample {

    public static void main(String[] args) {
        
        StripeConnectApi apiInstance = new StripeConnectApi();
        Object body = ; // Object | 
        try {
            apiInstance.stripeWebhookPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling StripeConnectApi#stripeWebhookPost");
            e.printStackTrace();
        }
    }
}
import io.swagger.client.api.StripeConnectApi;

public class StripeConnectApiExample {

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

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

// Stripe webhook endpoint
[apiInstance stripeWebhookPostWith:body
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var GoPosBackendApi = require('go_pos_backend_api');

var api = new GoPosBackendApi.StripeConnectApi()
var body = ; // {{Object}} 

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

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

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

            var apiInstance = new StripeConnectApi();
            var body = new Object(); // Object | 

            try
            {
                // Stripe webhook endpoint
                apiInstance.stripeWebhookPost(body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling StripeConnectApi.stripeWebhookPost: " + e.Message );
            }
        }
    }
}

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

$api_instance = new Swagger\Client\ApiStripeConnectApi();
$body = ; // Object | 

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

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

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

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

try: 
    # Stripe webhook endpoint
    api_instance.stripe_webhook_post(body)
except ApiException as e:
    print("Exception when calling StripeConnectApi->stripeWebhookPost: %s\n" % e)

Parameters

Body parameters
Name Description
body *

Responses

Status: 200 - Webhook processed

Status: 400 - Invalid signature