OpenAPI definition

AdminRestController

getKpis

Get KPIs statistics

/api/v1/admin/stats/kpis

Usage and SDK Samples

curl -X GET \
 -H "Accept: */*" \
 "https://localhost:8443/api/v1/admin/stats/kpis"

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

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

public class AdminRestControllerApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        AdminRestControllerApi apiInstance = new AdminRestControllerApi();

        try {
            KpiDTO result = apiInstance.getKpis();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AdminRestControllerApi#getKpis");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();


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

import org.openapitools.client.api.AdminRestControllerApi;

public class AdminRestControllerApiExample {
    public static void main(String[] args) {
        AdminRestControllerApi apiInstance = new AdminRestControllerApi();

        try {
            KpiDTO result = apiInstance.getKpis();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AdminRestControllerApi#getKpis");
            e.printStackTrace();
        }
    }
}



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

// Get KPIs statistics
[apiInstance getKpisWithCompletionHandler: 
              ^(KpiDTO output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenApiDefinition = require('open_api_definition');

// Create an instance of the API class
var api = new OpenApiDefinition.AdminRestControllerApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getKpis(callback);

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

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

            // Create an instance of the API class
            var apiInstance = new AdminRestControllerApi();

            try {
                // Get KPIs statistics
                KpiDTO result = apiInstance.getKpis();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling AdminRestControllerApi.getKpis: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\AdminRestControllerApi();

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

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::AdminRestControllerApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::AdminRestControllerApi->new();

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

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

# Create an instance of the API class
api_instance = openapi_client.AdminRestControllerApi()

try:
    # Get KPIs statistics
    api_response = api_instance.get_kpis()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AdminRestControllerApi->getKpis: %s\n" % e)

extern crate AdminRestControllerApi;

pub fn main() {

    let mut context = AdminRestControllerApi::Context::default();
    let result = client.getKpis(&context).wait();

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

Scopes

Parameters

Responses

Schema

getProductsStates

Get product state distribution

/api/v1/admin/stats/product-states

Usage and SDK Samples

curl -X GET \
 -H "Accept: */*" \
 "https://localhost:8443/api/v1/admin/stats/product-states"

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

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

public class AdminRestControllerApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        AdminRestControllerApi apiInstance = new AdminRestControllerApi();

        try {
            DataGraphicDTO result = apiInstance.getProductsStates();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AdminRestControllerApi#getProductsStates");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();


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

import org.openapitools.client.api.AdminRestControllerApi;

public class AdminRestControllerApiExample {
    public static void main(String[] args) {
        AdminRestControllerApi apiInstance = new AdminRestControllerApi();

        try {
            DataGraphicDTO result = apiInstance.getProductsStates();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AdminRestControllerApi#getProductsStates");
            e.printStackTrace();
        }
    }
}



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

// Get product state distribution
[apiInstance getProductsStatesWithCompletionHandler: 
              ^(DataGraphicDTO output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenApiDefinition = require('open_api_definition');

// Create an instance of the API class
var api = new OpenApiDefinition.AdminRestControllerApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getProductsStates(callback);

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

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

            // Create an instance of the API class
            var apiInstance = new AdminRestControllerApi();

            try {
                // Get product state distribution
                DataGraphicDTO result = apiInstance.getProductsStates();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling AdminRestControllerApi.getProductsStates: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\AdminRestControllerApi();

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

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::AdminRestControllerApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::AdminRestControllerApi->new();

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

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

# Create an instance of the API class
api_instance = openapi_client.AdminRestControllerApi()

try:
    # Get product state distribution
    api_response = api_instance.get_products_states()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AdminRestControllerApi->getProductsStates: %s\n" % e)

extern crate AdminRestControllerApi;

pub fn main() {

    let mut context = AdminRestControllerApi::Context::default();
    let result = client.getProductsStates(&context).wait();

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

Scopes

Parameters

Responses

Schema

getTopProductsGraphic

Get top selling products for graphic

/api/v1/admin/stats/top-products

Usage and SDK Samples

curl -X GET \
 -H "Accept: */*" \
 "https://localhost:8443/api/v1/admin/stats/top-products"

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

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

public class AdminRestControllerApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        AdminRestControllerApi apiInstance = new AdminRestControllerApi();

        try {
            DataGraphicDTO result = apiInstance.getTopProductsGraphic();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AdminRestControllerApi#getTopProductsGraphic");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();


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

import org.openapitools.client.api.AdminRestControllerApi;

public class AdminRestControllerApiExample {
    public static void main(String[] args) {
        AdminRestControllerApi apiInstance = new AdminRestControllerApi();

        try {
            DataGraphicDTO result = apiInstance.getTopProductsGraphic();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AdminRestControllerApi#getTopProductsGraphic");
            e.printStackTrace();
        }
    }
}



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

// Get top selling products for graphic
[apiInstance getTopProductsGraphicWithCompletionHandler: 
              ^(DataGraphicDTO output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenApiDefinition = require('open_api_definition');

// Create an instance of the API class
var api = new OpenApiDefinition.AdminRestControllerApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getTopProductsGraphic(callback);

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

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

            // Create an instance of the API class
            var apiInstance = new AdminRestControllerApi();

            try {
                // Get top selling products for graphic
                DataGraphicDTO result = apiInstance.getTopProductsGraphic();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling AdminRestControllerApi.getTopProductsGraphic: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\AdminRestControllerApi();

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

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::AdminRestControllerApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::AdminRestControllerApi->new();

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

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

# Create an instance of the API class
api_instance = openapi_client.AdminRestControllerApi()

try:
    # Get top selling products for graphic
    api_response = api_instance.get_top_products_graphic()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AdminRestControllerApi->getTopProductsGraphic: %s\n" % e)

extern crate AdminRestControllerApi;

pub fn main() {

    let mut context = AdminRestControllerApi::Context::default();
    let result = client.getTopProductsGraphic(&context).wait();

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

Scopes

Parameters

Responses

Schema

ImageRestController

getImage

Get image details

/api/v1/images/{id}

Usage and SDK Samples

curl -X GET \
 -H "Accept: */*" \
 "https://localhost:8443/api/v1/images/{id}"

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

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

public class ImageRestControllerApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        ImageRestControllerApi apiInstance = new ImageRestControllerApi();
        Long id = 789; // Long | 

        try {
            ImageDTO result = apiInstance.getImage(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ImageRestControllerApi#getImage");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final Long id = new Long(); // Long | 

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

import org.openapitools.client.api.ImageRestControllerApi;

public class ImageRestControllerApiExample {
    public static void main(String[] args) {
        ImageRestControllerApi apiInstance = new ImageRestControllerApi();
        Long id = 789; // Long | 

        try {
            ImageDTO result = apiInstance.getImage(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ImageRestControllerApi#getImage");
            e.printStackTrace();
        }
    }
}



// Create an instance of the API class
ImageRestControllerApi *apiInstance = [[ImageRestControllerApi alloc] init];
Long *id = 789; //  (default to null)

// Get image details
[apiInstance getImageWith:id
              completionHandler: ^(ImageDTO output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenApiDefinition = require('open_api_definition');

// Create an instance of the API class
var api = new OpenApiDefinition.ImageRestControllerApi()
var id = 789; // {Long} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new ImageRestControllerApi();
            var id = 789;  // Long |  (default to null)

            try {
                // Get image details
                ImageDTO result = apiInstance.getImage(id);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ImageRestControllerApi.getImage: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ImageRestControllerApi();
$id = 789; // Long | 

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

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::ImageRestControllerApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ImageRestControllerApi->new();
my $id = 789; # Long | 

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

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

# Create an instance of the API class
api_instance = openapi_client.ImageRestControllerApi()
id = 789 # Long |  (default to null)

try:
    # Get image details
    api_response = api_instance.get_image(id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ImageRestControllerApi->getImage: %s\n" % e)

extern crate ImageRestControllerApi;

pub fn main() {
    let id = 789; // Long

    let mut context = ImageRestControllerApi::Context::default();
    let result = client.getImage(id, &context).wait();

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

Scopes

Parameters

Path parameters

Name	Description
id*	Long (int64) Required

Responses

Schema

Schema

getImageFile

Get image file content

/api/v1/images/{id}/media

Usage and SDK Samples

curl -X GET \
 -H "Accept: */*" \
 "https://localhost:8443/api/v1/images/{id}/media"

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

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

public class ImageRestControllerApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        ImageRestControllerApi apiInstance = new ImageRestControllerApi();
        Long id = 789; // Long | 

        try {
            Object result = apiInstance.getImageFile(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ImageRestControllerApi#getImageFile");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final Long id = new Long(); // Long | 

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

import org.openapitools.client.api.ImageRestControllerApi;

public class ImageRestControllerApiExample {
    public static void main(String[] args) {
        ImageRestControllerApi apiInstance = new ImageRestControllerApi();
        Long id = 789; // Long | 

        try {
            Object result = apiInstance.getImageFile(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ImageRestControllerApi#getImageFile");
            e.printStackTrace();
        }
    }
}



// Create an instance of the API class
ImageRestControllerApi *apiInstance = [[ImageRestControllerApi alloc] init];
Long *id = 789; //  (default to null)

// Get image file content
[apiInstance getImageFileWith:id
              completionHandler: ^(Object output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenApiDefinition = require('open_api_definition');

// Create an instance of the API class
var api = new OpenApiDefinition.ImageRestControllerApi()
var id = 789; // {Long} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new ImageRestControllerApi();
            var id = 789;  // Long |  (default to null)

            try {
                // Get image file content
                Object result = apiInstance.getImageFile(id);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ImageRestControllerApi.getImageFile: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ImageRestControllerApi();
$id = 789; // Long | 

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

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::ImageRestControllerApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ImageRestControllerApi->new();
my $id = 789; # Long | 

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

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

# Create an instance of the API class
api_instance = openapi_client.ImageRestControllerApi()
id = 789 # Long |  (default to null)

try:
    # Get image file content
    api_response = api_instance.get_image_file(id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ImageRestControllerApi->getImageFile: %s\n" % e)

extern crate ImageRestControllerApi;

pub fn main() {
    let id = 789; // Long

    let mut context = ImageRestControllerApi::Context::default();
    let result = client.getImageFile(id, &context).wait();

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

Scopes

Parameters

Path parameters

Name	Description
id*	Long (int64) Required

Responses

Schema

Schema

replaceImageFile

Replace image file content

/api/v1/images/{id}/media

Usage and SDK Samples

curl -X PUT \
 -H "Accept: */*" \
 -H "Content-Type: application/json" \
 "https://localhost:8443/api/v1/images/{id}/media" \
 -d ''

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

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

public class ImageRestControllerApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        ImageRestControllerApi apiInstance = new ImageRestControllerApi();
        Long id = 789; // Long | 
        ReplaceImageFileRequest replaceImageFileRequest = ; // ReplaceImageFileRequest | 

        try {
            Object result = apiInstance.replaceImageFile(id, replaceImageFileRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ImageRestControllerApi#replaceImageFile");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final Long id = new Long(); // Long | 
final ReplaceImageFileRequest replaceImageFileRequest = new ReplaceImageFileRequest(); // ReplaceImageFileRequest | 

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

import org.openapitools.client.api.ImageRestControllerApi;

public class ImageRestControllerApiExample {
    public static void main(String[] args) {
        ImageRestControllerApi apiInstance = new ImageRestControllerApi();
        Long id = 789; // Long | 
        ReplaceImageFileRequest replaceImageFileRequest = ; // ReplaceImageFileRequest | 

        try {
            Object result = apiInstance.replaceImageFile(id, replaceImageFileRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ImageRestControllerApi#replaceImageFile");
            e.printStackTrace();
        }
    }
}



// Create an instance of the API class
ImageRestControllerApi *apiInstance = [[ImageRestControllerApi alloc] init];
Long *id = 789; //  (default to null)
ReplaceImageFileRequest *replaceImageFileRequest = ; //  (optional)

// Replace image file content
[apiInstance replaceImageFileWith:id
    replaceImageFileRequest:replaceImageFileRequest
              completionHandler: ^(Object output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenApiDefinition = require('open_api_definition');

// Create an instance of the API class
var api = new OpenApiDefinition.ImageRestControllerApi()
var id = 789; // {Long} 
var opts = {
  'replaceImageFileRequest':  // {ReplaceImageFileRequest} 
};

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

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

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

            // Create an instance of the API class
            var apiInstance = new ImageRestControllerApi();
            var id = 789;  // Long |  (default to null)
            var replaceImageFileRequest = new ReplaceImageFileRequest(); // ReplaceImageFileRequest |  (optional) 

            try {
                // Replace image file content
                Object result = apiInstance.replaceImageFile(id, replaceImageFileRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ImageRestControllerApi.replaceImageFile: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ImageRestControllerApi();
$id = 789; // Long | 
$replaceImageFileRequest = ; // ReplaceImageFileRequest | 

try {
    $result = $api_instance->replaceImageFile($id, $replaceImageFileRequest);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ImageRestControllerApi->replaceImageFile: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::ImageRestControllerApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ImageRestControllerApi->new();
my $id = 789; # Long | 
my $replaceImageFileRequest = WWW::OPenAPIClient::Object::ReplaceImageFileRequest->new(); # ReplaceImageFileRequest | 

eval {
    my $result = $api_instance->replaceImageFile(id => $id, replaceImageFileRequest => $replaceImageFileRequest);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ImageRestControllerApi->replaceImageFile: $@\n";
}

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

# Create an instance of the API class
api_instance = openapi_client.ImageRestControllerApi()
id = 789 # Long |  (default to null)
replaceImageFileRequest =  # ReplaceImageFileRequest |  (optional)

try:
    # Replace image file content
    api_response = api_instance.replace_image_file(id, replaceImageFileRequest=replaceImageFileRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ImageRestControllerApi->replaceImageFile: %s\n" % e)

extern crate ImageRestControllerApi;

pub fn main() {
    let id = 789; // Long
    let replaceImageFileRequest = ; // ReplaceImageFileRequest

    let mut context = ImageRestControllerApi::Context::default();
    let result = client.replaceImageFile(id, replaceImageFileRequest, &context).wait();

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

Scopes

Parameters

Path parameters

Name	Description
id*	Long (int64) Required

Body parameters

Name	Description
replaceImageFileRequest

Responses

Schema

Schema

Schema

LoginController

logOut

Logout user

/api/v1/auth/logout

Usage and SDK Samples

curl -X POST \
 -H "Accept: */*" \
 "https://localhost:8443/api/v1/auth/logout"

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

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

public class LoginControllerApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        LoginControllerApi apiInstance = new LoginControllerApi();

        try {
            AuthResponse result = apiInstance.logOut();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling LoginControllerApi#logOut");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();


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

import org.openapitools.client.api.LoginControllerApi;

public class LoginControllerApiExample {
    public static void main(String[] args) {
        LoginControllerApi apiInstance = new LoginControllerApi();

        try {
            AuthResponse result = apiInstance.logOut();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling LoginControllerApi#logOut");
            e.printStackTrace();
        }
    }
}



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

// Logout user
[apiInstance logOutWithCompletionHandler: 
              ^(AuthResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenApiDefinition = require('open_api_definition');

// Create an instance of the API class
var api = new OpenApiDefinition.LoginControllerApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.logOut(callback);

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

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

            // Create an instance of the API class
            var apiInstance = new LoginControllerApi();

            try {
                // Logout user
                AuthResponse result = apiInstance.logOut();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling LoginControllerApi.logOut: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\LoginControllerApi();

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

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::LoginControllerApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::LoginControllerApi->new();

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

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

# Create an instance of the API class
api_instance = openapi_client.LoginControllerApi()

try:
    # Logout user
    api_response = api_instance.log_out()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling LoginControllerApi->logOut: %s\n" % e)

extern crate LoginControllerApi;

pub fn main() {

    let mut context = LoginControllerApi::Context::default();
    let result = client.logOut(&context).wait();

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

Scopes

Parameters

Responses

Schema

login

/api/v1/auth/login

Usage and SDK Samples

curl -X POST \
 -H "Accept: */*" \
 -H "Content-Type: application/json" \
 "https://localhost:8443/api/v1/auth/login" \
 -d '{
  "password" : "password",
  "username" : "username"
}'

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

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

public class LoginControllerApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        LoginControllerApi apiInstance = new LoginControllerApi();
        LoginRequest loginRequest = ; // LoginRequest | 

        try {
            AuthResponse result = apiInstance.login(loginRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling LoginControllerApi#login");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final LoginRequest loginRequest = new LoginRequest(); // LoginRequest | 

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

import org.openapitools.client.api.LoginControllerApi;

public class LoginControllerApiExample {
    public static void main(String[] args) {
        LoginControllerApi apiInstance = new LoginControllerApi();
        LoginRequest loginRequest = ; // LoginRequest | 

        try {
            AuthResponse result = apiInstance.login(loginRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling LoginControllerApi#login");
            e.printStackTrace();
        }
    }
}



// Create an instance of the API class
LoginControllerApi *apiInstance = [[LoginControllerApi alloc] init];
LoginRequest *loginRequest = ; // 

// Login user
[apiInstance loginWith:loginRequest
              completionHandler: ^(AuthResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenApiDefinition = require('open_api_definition');

// Create an instance of the API class
var api = new OpenApiDefinition.LoginControllerApi()
var loginRequest = ; // {LoginRequest} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new LoginControllerApi();
            var loginRequest = new LoginRequest(); // LoginRequest | 

            try {
                // Login user
                AuthResponse result = apiInstance.login(loginRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling LoginControllerApi.login: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\LoginControllerApi();
$loginRequest = ; // LoginRequest | 

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

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::LoginControllerApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::LoginControllerApi->new();
my $loginRequest = WWW::OPenAPIClient::Object::LoginRequest->new(); # LoginRequest | 

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

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

# Create an instance of the API class
api_instance = openapi_client.LoginControllerApi()
loginRequest =  # LoginRequest | 

try:
    # Login user
    api_response = api_instance.login(loginRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling LoginControllerApi->login: %s\n" % e)

extern crate LoginControllerApi;

pub fn main() {
    let loginRequest = ; // LoginRequest

    let mut context = LoginControllerApi::Context::default();
    let result = client.login(loginRequest, &context).wait();

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

Scopes

Parameters

Body parameters

Name	Description
loginRequest *

Responses

refreshToken

Refresh authentication token

/api/v1/auth/refresh

Usage and SDK Samples

curl -X POST \
 -H "Accept: */*" \
 "https://localhost:8443/api/v1/auth/refresh"

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

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

public class LoginControllerApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        LoginControllerApi apiInstance = new LoginControllerApi();
        String refreshToken = refreshToken_example; // String | 

        try {
            AuthResponse result = apiInstance.refreshToken(refreshToken);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling LoginControllerApi#refreshToken");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String refreshToken = new String(); // String | 

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

import org.openapitools.client.api.LoginControllerApi;

public class LoginControllerApiExample {
    public static void main(String[] args) {
        LoginControllerApi apiInstance = new LoginControllerApi();
        String refreshToken = refreshToken_example; // String | 

        try {
            AuthResponse result = apiInstance.refreshToken(refreshToken);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling LoginControllerApi#refreshToken");
            e.printStackTrace();
        }
    }
}



// Create an instance of the API class
LoginControllerApi *apiInstance = [[LoginControllerApi alloc] init];
String *refreshToken = refreshToken_example; //  (optional) (default to null)

// Refresh authentication token
[apiInstance refreshTokenWith:refreshToken
              completionHandler: ^(AuthResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenApiDefinition = require('open_api_definition');

// Create an instance of the API class
var api = new OpenApiDefinition.LoginControllerApi()
var opts = {
  'refreshToken': refreshToken_example // {String} 
};

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

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

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

            // Create an instance of the API class
            var apiInstance = new LoginControllerApi();
            var refreshToken = refreshToken_example;  // String |  (optional)  (default to null)

            try {
                // Refresh authentication token
                AuthResponse result = apiInstance.refreshToken(refreshToken);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling LoginControllerApi.refreshToken: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\LoginControllerApi();
$refreshToken = refreshToken_example; // String | 

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

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::LoginControllerApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::LoginControllerApi->new();
my $refreshToken = refreshToken_example; # String | 

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

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

# Create an instance of the API class
api_instance = openapi_client.LoginControllerApi()
refreshToken = refreshToken_example # String |  (optional) (default to null)

try:
    # Refresh authentication token
    api_response = api_instance.refresh_token(refreshToken=refreshToken)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling LoginControllerApi->refreshToken: %s\n" % e)

extern crate LoginControllerApi;

pub fn main() {
    let refreshToken = refreshToken_example; // String

    let mut context = LoginControllerApi::Context::default();
    let result = client.refreshToken(refreshToken, &context).wait();

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

Scopes

Parameters

Responses

Schema

Schema

OrderRestController

acceptOrder

Accept an order (Admin)

/api/v1/orders/{orderId}

Usage and SDK Samples

curl -X PUT \
 -H "Accept: */*" \
 -H "Content-Type: application/json" \
 "https://localhost:8443/api/v1/orders/{orderId}" \
 -d ''

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

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

public class OrderRestControllerApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        OrderRestControllerApi apiInstance = new OrderRestControllerApi();
        Long orderId = 789; // Long | 
        map[String, Boolean] requestBody = Object; // map[String, Boolean] | 

        try {
            OrderDTO result = apiInstance.acceptOrder(orderId, requestBody);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling OrderRestControllerApi#acceptOrder");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final Long orderId = new Long(); // Long | 
final map[String, Boolean] requestBody = new map[String, Boolean](); // map[String, Boolean] | 

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

import org.openapitools.client.api.OrderRestControllerApi;

public class OrderRestControllerApiExample {
    public static void main(String[] args) {
        OrderRestControllerApi apiInstance = new OrderRestControllerApi();
        Long orderId = 789; // Long | 
        map[String, Boolean] requestBody = Object; // map[String, Boolean] | 

        try {
            OrderDTO result = apiInstance.acceptOrder(orderId, requestBody);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling OrderRestControllerApi#acceptOrder");
            e.printStackTrace();
        }
    }
}



// Create an instance of the API class
OrderRestControllerApi *apiInstance = [[OrderRestControllerApi alloc] init];
Long *orderId = 789; //  (default to null)
map[String, Boolean] *requestBody = Object; // 

// Accept an order (Admin)
[apiInstance acceptOrderWith:orderId
    requestBody:requestBody
              completionHandler: ^(OrderDTO output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenApiDefinition = require('open_api_definition');

// Create an instance of the API class
var api = new OpenApiDefinition.OrderRestControllerApi()
var orderId = 789; // {Long} 
var requestBody = Object; // {map[String, Boolean]} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new OrderRestControllerApi();
            var orderId = 789;  // Long |  (default to null)
            var requestBody = new map[String, Boolean](); // map[String, Boolean] | 

            try {
                // Accept an order (Admin)
                OrderDTO result = apiInstance.acceptOrder(orderId, requestBody);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling OrderRestControllerApi.acceptOrder: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\OrderRestControllerApi();
$orderId = 789; // Long | 
$requestBody = Object; // map[String, Boolean] | 

try {
    $result = $api_instance->acceptOrder($orderId, $requestBody);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling OrderRestControllerApi->acceptOrder: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::OrderRestControllerApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::OrderRestControllerApi->new();
my $orderId = 789; # Long | 
my $requestBody = WWW::OPenAPIClient::Object::map[String, Boolean]->new(); # map[String, Boolean] | 

eval {
    my $result = $api_instance->acceptOrder(orderId => $orderId, requestBody => $requestBody);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling OrderRestControllerApi->acceptOrder: $@\n";
}

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

# Create an instance of the API class
api_instance = openapi_client.OrderRestControllerApi()
orderId = 789 # Long |  (default to null)
requestBody = Object # map[String, Boolean] | 

try:
    # Accept an order (Admin)
    api_response = api_instance.accept_order(orderId, requestBody)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling OrderRestControllerApi->acceptOrder: %s\n" % e)

extern crate OrderRestControllerApi;

pub fn main() {
    let orderId = 789; // Long
    let requestBody = Object; // map[String, Boolean]

    let mut context = OrderRestControllerApi::Context::default();
    let result = client.acceptOrder(orderId, requestBody, &context).wait();

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

Scopes

Parameters

Path parameters

Name	Description
orderId*	Long (int64) Required

Body parameters

Name	Description
requestBody *

Responses

Schema

Schema

Schema

Schema

getAllOrderPdf

Get PDF for all orders

/api/v1/orders/all/bill

Usage and SDK Samples

curl -X GET \
 -H "Accept: */*" \
 "https://localhost:8443/api/v1/orders/all/bill"

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

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

public class OrderRestControllerApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        OrderRestControllerApi apiInstance = new OrderRestControllerApi();

        try {
            byte[] result = apiInstance.getAllOrderPdf();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling OrderRestControllerApi#getAllOrderPdf");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();


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

import org.openapitools.client.api.OrderRestControllerApi;

public class OrderRestControllerApiExample {
    public static void main(String[] args) {
        OrderRestControllerApi apiInstance = new OrderRestControllerApi();

        try {
            byte[] result = apiInstance.getAllOrderPdf();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling OrderRestControllerApi#getAllOrderPdf");
            e.printStackTrace();
        }
    }
}



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

// Get PDF for all orders
[apiInstance getAllOrderPdfWithCompletionHandler: 
              ^(byte[] output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenApiDefinition = require('open_api_definition');

// Create an instance of the API class
var api = new OpenApiDefinition.OrderRestControllerApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getAllOrderPdf(callback);

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

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

            // Create an instance of the API class
            var apiInstance = new OrderRestControllerApi();

            try {
                // Get PDF for all orders
                byte[] result = apiInstance.getAllOrderPdf();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling OrderRestControllerApi.getAllOrderPdf: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\OrderRestControllerApi();

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

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::OrderRestControllerApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::OrderRestControllerApi->new();

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

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

# Create an instance of the API class
api_instance = openapi_client.OrderRestControllerApi()

try:
    # Get PDF for all orders
    api_response = api_instance.get_all_order_pdf()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling OrderRestControllerApi->getAllOrderPdf: %s\n" % e)

extern crate OrderRestControllerApi;

pub fn main() {

    let mut context = OrderRestControllerApi::Context::default();
    let result = client.getAllOrderPdf(&context).wait();

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

Scopes

Parameters

Responses

Schema

getAllOrders

Get all orders (Admin)

/api/v1/orders

Usage and SDK Samples

curl -X GET \
 -H "Accept: */*" \
 "https://localhost:8443/api/v1/orders"

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

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

public class OrderRestControllerApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        OrderRestControllerApi apiInstance = new OrderRestControllerApi();

        try {
            array[OrderDTO] result = apiInstance.getAllOrders();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling OrderRestControllerApi#getAllOrders");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();


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

import org.openapitools.client.api.OrderRestControllerApi;

public class OrderRestControllerApiExample {
    public static void main(String[] args) {
        OrderRestControllerApi apiInstance = new OrderRestControllerApi();

        try {
            array[OrderDTO] result = apiInstance.getAllOrders();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling OrderRestControllerApi#getAllOrders");
            e.printStackTrace();
        }
    }
}



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

// Get all orders (Admin)
[apiInstance getAllOrdersWithCompletionHandler: 
              ^(array[OrderDTO] output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenApiDefinition = require('open_api_definition');

// Create an instance of the API class
var api = new OpenApiDefinition.OrderRestControllerApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getAllOrders(callback);

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

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

            // Create an instance of the API class
            var apiInstance = new OrderRestControllerApi();

            try {
                // Get all orders (Admin)
                array[OrderDTO] result = apiInstance.getAllOrders();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling OrderRestControllerApi.getAllOrders: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\OrderRestControllerApi();

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

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::OrderRestControllerApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::OrderRestControllerApi->new();

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

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

# Create an instance of the API class
api_instance = openapi_client.OrderRestControllerApi()

try:
    # Get all orders (Admin)
    api_response = api_instance.get_all_orders()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling OrderRestControllerApi->getAllOrders: %s\n" % e)

extern crate OrderRestControllerApi;

pub fn main() {

    let mut context = OrderRestControllerApi::Context::default();
    let result = client.getAllOrders(&context).wait();

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

Scopes

Parameters

Responses

Schema

Schema

getAllUserOrders

Get current user orders

/api/v1/orders/me

Usage and SDK Samples

curl -X GET \
 -H "Accept: */*" \
 "https://localhost:8443/api/v1/orders/me"

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

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

public class OrderRestControllerApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        OrderRestControllerApi apiInstance = new OrderRestControllerApi();

        try {
            array[OrderDTO] result = apiInstance.getAllUserOrders();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling OrderRestControllerApi#getAllUserOrders");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();


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

import org.openapitools.client.api.OrderRestControllerApi;

public class OrderRestControllerApiExample {
    public static void main(String[] args) {
        OrderRestControllerApi apiInstance = new OrderRestControllerApi();

        try {
            array[OrderDTO] result = apiInstance.getAllUserOrders();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling OrderRestControllerApi#getAllUserOrders");
            e.printStackTrace();
        }
    }
}



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

// Get current user orders
[apiInstance getAllUserOrdersWithCompletionHandler: 
              ^(array[OrderDTO] output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenApiDefinition = require('open_api_definition');

// Create an instance of the API class
var api = new OpenApiDefinition.OrderRestControllerApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getAllUserOrders(callback);

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

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

            // Create an instance of the API class
            var apiInstance = new OrderRestControllerApi();

            try {
                // Get current user orders
                array[OrderDTO] result = apiInstance.getAllUserOrders();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling OrderRestControllerApi.getAllUserOrders: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\OrderRestControllerApi();

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

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::OrderRestControllerApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::OrderRestControllerApi->new();

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

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

# Create an instance of the API class
api_instance = openapi_client.OrderRestControllerApi()

try:
    # Get current user orders
    api_response = api_instance.get_all_user_orders()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling OrderRestControllerApi->getAllUserOrders: %s\n" % e)

extern crate OrderRestControllerApi;

pub fn main() {

    let mut context = OrderRestControllerApi::Context::default();
    let result = client.getAllUserOrders(&context).wait();

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

Scopes

Parameters

Responses

Schema

Schema

getOrderPdf

Get PDF for a specific order

/api/v1/orders/{orderId}/bill

Usage and SDK Samples

curl -X GET \
 -H "Accept: */*" \
 "https://localhost:8443/api/v1/orders/{orderId}/bill"

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

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

public class OrderRestControllerApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        OrderRestControllerApi apiInstance = new OrderRestControllerApi();
        Long orderId = 789; // Long | 

        try {
            byte[] result = apiInstance.getOrderPdf(orderId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling OrderRestControllerApi#getOrderPdf");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final Long orderId = new Long(); // Long | 

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

import org.openapitools.client.api.OrderRestControllerApi;

public class OrderRestControllerApiExample {
    public static void main(String[] args) {
        OrderRestControllerApi apiInstance = new OrderRestControllerApi();
        Long orderId = 789; // Long | 

        try {
            byte[] result = apiInstance.getOrderPdf(orderId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling OrderRestControllerApi#getOrderPdf");
            e.printStackTrace();
        }
    }
}



// Create an instance of the API class
OrderRestControllerApi *apiInstance = [[OrderRestControllerApi alloc] init];
Long *orderId = 789; //  (default to null)

// Get PDF for a specific order
[apiInstance getOrderPdfWith:orderId
              completionHandler: ^(byte[] output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenApiDefinition = require('open_api_definition');

// Create an instance of the API class
var api = new OpenApiDefinition.OrderRestControllerApi()
var orderId = 789; // {Long} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new OrderRestControllerApi();
            var orderId = 789;  // Long |  (default to null)

            try {
                // Get PDF for a specific order
                byte[] result = apiInstance.getOrderPdf(orderId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling OrderRestControllerApi.getOrderPdf: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\OrderRestControllerApi();
$orderId = 789; // Long | 

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

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::OrderRestControllerApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::OrderRestControllerApi->new();
my $orderId = 789; # Long | 

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

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

# Create an instance of the API class
api_instance = openapi_client.OrderRestControllerApi()
orderId = 789 # Long |  (default to null)

try:
    # Get PDF for a specific order
    api_response = api_instance.get_order_pdf(orderId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling OrderRestControllerApi->getOrderPdf: %s\n" % e)

extern crate OrderRestControllerApi;

pub fn main() {
    let orderId = 789; // Long

    let mut context = OrderRestControllerApi::Context::default();
    let result = client.getOrderPdf(orderId, &context).wait();

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

Scopes

Parameters

Path parameters

Name	Description
orderId*	Long (int64) Required

Responses

Schema

Schema

Schema

shoppingCartToOrder

Create order from shopping cart

/api/v1/orders

Usage and SDK Samples

curl -X POST \
 -H "Accept: */*" \
 "https://localhost:8443/api/v1/orders"

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

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

public class OrderRestControllerApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        OrderRestControllerApi apiInstance = new OrderRestControllerApi();

        try {
            OrderDTO result = apiInstance.shoppingCartToOrder();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling OrderRestControllerApi#shoppingCartToOrder");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();


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

import org.openapitools.client.api.OrderRestControllerApi;

public class OrderRestControllerApiExample {
    public static void main(String[] args) {
        OrderRestControllerApi apiInstance = new OrderRestControllerApi();

        try {
            OrderDTO result = apiInstance.shoppingCartToOrder();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling OrderRestControllerApi#shoppingCartToOrder");
            e.printStackTrace();
        }
    }
}



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

// Create order from shopping cart
[apiInstance shoppingCartToOrderWithCompletionHandler: 
              ^(OrderDTO output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenApiDefinition = require('open_api_definition');

// Create an instance of the API class
var api = new OpenApiDefinition.OrderRestControllerApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.shoppingCartToOrder(callback);

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

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

            // Create an instance of the API class
            var apiInstance = new OrderRestControllerApi();

            try {
                // Create order from shopping cart
                OrderDTO result = apiInstance.shoppingCartToOrder();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling OrderRestControllerApi.shoppingCartToOrder: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\OrderRestControllerApi();

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

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::OrderRestControllerApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::OrderRestControllerApi->new();

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

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

# Create an instance of the API class
api_instance = openapi_client.OrderRestControllerApi()

try:
    # Create order from shopping cart
    api_response = api_instance.shopping_cart_to_order()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling OrderRestControllerApi->shoppingCartToOrder: %s\n" % e)

extern crate OrderRestControllerApi;

pub fn main() {

    let mut context = OrderRestControllerApi::Context::default();
    let result = client.shoppingCartToOrder(&context).wait();

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

Scopes

Parameters

Responses

Schema

Schema

Schema

ProductRestController

createProduct

Create a new product

/api/v1/products/

Usage and SDK Samples

curl -X POST \
 -H "Accept: */*" \
 -H "Content-Type: application/json" \
 "https://localhost:8443/api/v1/products/" \
 -d '{
  "reviewCount" : 5,
  "price" : 6.027456183070403,
  "averageRating" : 5.962133916683182,
  "description" : "description",
  "id" : 0,
  "state" : 1,
  "productName" : "productName"
}'

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

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

public class ProductRestControllerApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        ProductRestControllerApi apiInstance = new ProductRestControllerApi();
        ProductBasicDTO productBasicDTO = ; // ProductBasicDTO | 

        try {
            ProductBasicDTO result = apiInstance.createProduct(productBasicDTO);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProductRestControllerApi#createProduct");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final ProductBasicDTO productBasicDTO = new ProductBasicDTO(); // ProductBasicDTO | 

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

import org.openapitools.client.api.ProductRestControllerApi;

public class ProductRestControllerApiExample {
    public static void main(String[] args) {
        ProductRestControllerApi apiInstance = new ProductRestControllerApi();
        ProductBasicDTO productBasicDTO = ; // ProductBasicDTO | 

        try {
            ProductBasicDTO result = apiInstance.createProduct(productBasicDTO);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProductRestControllerApi#createProduct");
            e.printStackTrace();
        }
    }
}



// Create an instance of the API class
ProductRestControllerApi *apiInstance = [[ProductRestControllerApi alloc] init];
ProductBasicDTO *productBasicDTO = ; // 

// Create a new product
[apiInstance createProductWith:productBasicDTO
              completionHandler: ^(ProductBasicDTO output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenApiDefinition = require('open_api_definition');

// Create an instance of the API class
var api = new OpenApiDefinition.ProductRestControllerApi()
var productBasicDTO = ; // {ProductBasicDTO} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new ProductRestControllerApi();
            var productBasicDTO = new ProductBasicDTO(); // ProductBasicDTO | 

            try {
                // Create a new product
                ProductBasicDTO result = apiInstance.createProduct(productBasicDTO);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ProductRestControllerApi.createProduct: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ProductRestControllerApi();
$productBasicDTO = ; // ProductBasicDTO | 

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

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::ProductRestControllerApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ProductRestControllerApi->new();
my $productBasicDTO = WWW::OPenAPIClient::Object::ProductBasicDTO->new(); # ProductBasicDTO | 

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

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

# Create an instance of the API class
api_instance = openapi_client.ProductRestControllerApi()
productBasicDTO =  # ProductBasicDTO | 

try:
    # Create a new product
    api_response = api_instance.create_product(productBasicDTO)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ProductRestControllerApi->createProduct: %s\n" % e)

extern crate ProductRestControllerApi;

pub fn main() {
    let productBasicDTO = ; // ProductBasicDTO

    let mut context = ProductRestControllerApi::Context::default();
    let result = client.createProduct(productBasicDTO, &context).wait();

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

Scopes

Parameters

Body parameters

Name	Description
productBasicDTO *

Responses

Schema

Schema

Schema

createProductImage

Upload product image

/api/v1/products/{id}/images/

Usage and SDK Samples

curl -X POST \
 -H "Accept: */*" \
 -H "Content-Type: application/json" \
 "https://localhost:8443/api/v1/products/{id}/images/" \
 -d ''

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

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

public class ProductRestControllerApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        ProductRestControllerApi apiInstance = new ProductRestControllerApi();
        Long id = 789; // Long | 
        ReplaceImageFileRequest replaceImageFileRequest = ; // ReplaceImageFileRequest | 

        try {
            ImageDTO result = apiInstance.createProductImage(id, replaceImageFileRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProductRestControllerApi#createProductImage");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final Long id = new Long(); // Long | 
final ReplaceImageFileRequest replaceImageFileRequest = new ReplaceImageFileRequest(); // ReplaceImageFileRequest | 

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

import org.openapitools.client.api.ProductRestControllerApi;

public class ProductRestControllerApiExample {
    public static void main(String[] args) {
        ProductRestControllerApi apiInstance = new ProductRestControllerApi();
        Long id = 789; // Long | 
        ReplaceImageFileRequest replaceImageFileRequest = ; // ReplaceImageFileRequest | 

        try {
            ImageDTO result = apiInstance.createProductImage(id, replaceImageFileRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProductRestControllerApi#createProductImage");
            e.printStackTrace();
        }
    }
}



// Create an instance of the API class
ProductRestControllerApi *apiInstance = [[ProductRestControllerApi alloc] init];
Long *id = 789; //  (default to null)
ReplaceImageFileRequest *replaceImageFileRequest = ; //  (optional)

// Upload product image
[apiInstance createProductImageWith:id
    replaceImageFileRequest:replaceImageFileRequest
              completionHandler: ^(ImageDTO output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenApiDefinition = require('open_api_definition');

// Create an instance of the API class
var api = new OpenApiDefinition.ProductRestControllerApi()
var id = 789; // {Long} 
var opts = {
  'replaceImageFileRequest':  // {ReplaceImageFileRequest} 
};

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

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

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

            // Create an instance of the API class
            var apiInstance = new ProductRestControllerApi();
            var id = 789;  // Long |  (default to null)
            var replaceImageFileRequest = new ReplaceImageFileRequest(); // ReplaceImageFileRequest |  (optional) 

            try {
                // Upload product image
                ImageDTO result = apiInstance.createProductImage(id, replaceImageFileRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ProductRestControllerApi.createProductImage: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ProductRestControllerApi();
$id = 789; // Long | 
$replaceImageFileRequest = ; // ReplaceImageFileRequest | 

try {
    $result = $api_instance->createProductImage($id, $replaceImageFileRequest);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ProductRestControllerApi->createProductImage: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::ProductRestControllerApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ProductRestControllerApi->new();
my $id = 789; # Long | 
my $replaceImageFileRequest = WWW::OPenAPIClient::Object::ReplaceImageFileRequest->new(); # ReplaceImageFileRequest | 

eval {
    my $result = $api_instance->createProductImage(id => $id, replaceImageFileRequest => $replaceImageFileRequest);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ProductRestControllerApi->createProductImage: $@\n";
}

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

# Create an instance of the API class
api_instance = openapi_client.ProductRestControllerApi()
id = 789 # Long |  (default to null)
replaceImageFileRequest =  # ReplaceImageFileRequest |  (optional)

try:
    # Upload product image
    api_response = api_instance.create_product_image(id, replaceImageFileRequest=replaceImageFileRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ProductRestControllerApi->createProductImage: %s\n" % e)

extern crate ProductRestControllerApi;

pub fn main() {
    let id = 789; // Long
    let replaceImageFileRequest = ; // ReplaceImageFileRequest

    let mut context = ProductRestControllerApi::Context::default();
    let result = client.createProductImage(id, replaceImageFileRequest, &context).wait();

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

Scopes

Parameters

Path parameters

Name	Description
id*	Long (int64) Required

Body parameters

Name	Description
replaceImageFileRequest

Responses

Schema

Schema

Schema

Schema

deleteProduct

Delete a product

/api/v1/products/{id}

Usage and SDK Samples

curl -X DELETE \
 -H "Accept: */*" \
 "https://localhost:8443/api/v1/products/{id}"

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

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

public class ProductRestControllerApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        ProductRestControllerApi apiInstance = new ProductRestControllerApi();
        Long id = 789; // Long | 

        try {
            ProductBasicDTO result = apiInstance.deleteProduct(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProductRestControllerApi#deleteProduct");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final Long id = new Long(); // Long | 

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

import org.openapitools.client.api.ProductRestControllerApi;

public class ProductRestControllerApiExample {
    public static void main(String[] args) {
        ProductRestControllerApi apiInstance = new ProductRestControllerApi();
        Long id = 789; // Long | 

        try {
            ProductBasicDTO result = apiInstance.deleteProduct(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProductRestControllerApi#deleteProduct");
            e.printStackTrace();
        }
    }
}



// Create an instance of the API class
ProductRestControllerApi *apiInstance = [[ProductRestControllerApi alloc] init];
Long *id = 789; //  (default to null)

// Delete a product
[apiInstance deleteProductWith:id
              completionHandler: ^(ProductBasicDTO output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenApiDefinition = require('open_api_definition');

// Create an instance of the API class
var api = new OpenApiDefinition.ProductRestControllerApi()
var id = 789; // {Long} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new ProductRestControllerApi();
            var id = 789;  // Long |  (default to null)

            try {
                // Delete a product
                ProductBasicDTO result = apiInstance.deleteProduct(id);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ProductRestControllerApi.deleteProduct: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ProductRestControllerApi();
$id = 789; // Long | 

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

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::ProductRestControllerApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ProductRestControllerApi->new();
my $id = 789; # Long | 

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

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

# Create an instance of the API class
api_instance = openapi_client.ProductRestControllerApi()
id = 789 # Long |  (default to null)

try:
    # Delete a product
    api_response = api_instance.delete_product(id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ProductRestControllerApi->deleteProduct: %s\n" % e)

extern crate ProductRestControllerApi;

pub fn main() {
    let id = 789; // Long

    let mut context = ProductRestControllerApi::Context::default();
    let result = client.deleteProduct(id, &context).wait();

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

Scopes

Parameters

Path parameters

Name	Description
id*	Long (int64) Required

Responses

Schema

Schema

Schema

deleteProductImage

Delete product image

/api/v1/products/{productId}/images/{imageId}

Usage and SDK Samples

curl -X DELETE \
 -H "Accept: */*" \
 "https://localhost:8443/api/v1/products/{productId}/images/{imageId}"

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

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

public class ProductRestControllerApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        ProductRestControllerApi apiInstance = new ProductRestControllerApi();
        Long productId = 789; // Long | 
        Long imageId = 789; // Long | 

        try {
            ImageDTO result = apiInstance.deleteProductImage(productId, imageId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProductRestControllerApi#deleteProductImage");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final Long productId = new Long(); // Long | 
final Long imageId = new Long(); // Long | 

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

import org.openapitools.client.api.ProductRestControllerApi;

public class ProductRestControllerApiExample {
    public static void main(String[] args) {
        ProductRestControllerApi apiInstance = new ProductRestControllerApi();
        Long productId = 789; // Long | 
        Long imageId = 789; // Long | 

        try {
            ImageDTO result = apiInstance.deleteProductImage(productId, imageId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProductRestControllerApi#deleteProductImage");
            e.printStackTrace();
        }
    }
}



// Create an instance of the API class
ProductRestControllerApi *apiInstance = [[ProductRestControllerApi alloc] init];
Long *productId = 789; //  (default to null)
Long *imageId = 789; //  (default to null)

// Delete product image
[apiInstance deleteProductImageWith:productId
    imageId:imageId
              completionHandler: ^(ImageDTO output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenApiDefinition = require('open_api_definition');

// Create an instance of the API class
var api = new OpenApiDefinition.ProductRestControllerApi()
var productId = 789; // {Long} 
var imageId = 789; // {Long} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new ProductRestControllerApi();
            var productId = 789;  // Long |  (default to null)
            var imageId = 789;  // Long |  (default to null)

            try {
                // Delete product image
                ImageDTO result = apiInstance.deleteProductImage(productId, imageId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ProductRestControllerApi.deleteProductImage: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ProductRestControllerApi();
$productId = 789; // Long | 
$imageId = 789; // Long | 

try {
    $result = $api_instance->deleteProductImage($productId, $imageId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ProductRestControllerApi->deleteProductImage: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::ProductRestControllerApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ProductRestControllerApi->new();
my $productId = 789; # Long | 
my $imageId = 789; # Long | 

eval {
    my $result = $api_instance->deleteProductImage(productId => $productId, imageId => $imageId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ProductRestControllerApi->deleteProductImage: $@\n";
}

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

# Create an instance of the API class
api_instance = openapi_client.ProductRestControllerApi()
productId = 789 # Long |  (default to null)
imageId = 789 # Long |  (default to null)

try:
    # Delete product image
    api_response = api_instance.delete_product_image(productId, imageId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ProductRestControllerApi->deleteProductImage: %s\n" % e)

extern crate ProductRestControllerApi;

pub fn main() {
    let productId = 789; // Long
    let imageId = 789; // Long

    let mut context = ProductRestControllerApi::Context::default();
    let result = client.deleteProductImage(productId, imageId, &context).wait();

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

Scopes

Parameters

Path parameters

Name	Description
productId*	Long (int64) Required
imageId*	Long (int64) Required

Responses

Schema

Schema

Schema

getProductById

Get product by ID

/api/v1/products/{id}

Usage and SDK Samples

curl -X GET \
 -H "Accept: */*" \
 "https://localhost:8443/api/v1/products/{id}"

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

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

public class ProductRestControllerApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        ProductRestControllerApi apiInstance = new ProductRestControllerApi();
        Long id = 789; // Long | 

        try {
            ProductDTO result = apiInstance.getProductById(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProductRestControllerApi#getProductById");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final Long id = new Long(); // Long | 

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

import org.openapitools.client.api.ProductRestControllerApi;

public class ProductRestControllerApiExample {
    public static void main(String[] args) {
        ProductRestControllerApi apiInstance = new ProductRestControllerApi();
        Long id = 789; // Long | 

        try {
            ProductDTO result = apiInstance.getProductById(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProductRestControllerApi#getProductById");
            e.printStackTrace();
        }
    }
}



// Create an instance of the API class
ProductRestControllerApi *apiInstance = [[ProductRestControllerApi alloc] init];
Long *id = 789; //  (default to null)

// Get product by ID
[apiInstance getProductByIdWith:id
              completionHandler: ^(ProductDTO output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenApiDefinition = require('open_api_definition');

// Create an instance of the API class
var api = new OpenApiDefinition.ProductRestControllerApi()
var id = 789; // {Long} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new ProductRestControllerApi();
            var id = 789;  // Long |  (default to null)

            try {
                // Get product by ID
                ProductDTO result = apiInstance.getProductById(id);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ProductRestControllerApi.getProductById: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ProductRestControllerApi();
$id = 789; // Long | 

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

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::ProductRestControllerApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ProductRestControllerApi->new();
my $id = 789; # Long | 

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

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

# Create an instance of the API class
api_instance = openapi_client.ProductRestControllerApi()
id = 789 # Long |  (default to null)

try:
    # Get product by ID
    api_response = api_instance.get_product_by_id(id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ProductRestControllerApi->getProductById: %s\n" % e)

extern crate ProductRestControllerApi;

pub fn main() {
    let id = 789; // Long

    let mut context = ProductRestControllerApi::Context::default();
    let result = client.getProductById(id, &context).wait();

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

Scopes

Parameters

Path parameters

Name	Description
id*	Long (int64) Required

Responses

Schema

Schema

getProducts

Get all products

/api/v1/products/

Usage and SDK Samples

curl -X GET \
 -H "Accept: */*" \
 "https://localhost:8443/api/v1/products/?pageable="

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

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

public class ProductRestControllerApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        ProductRestControllerApi apiInstance = new ProductRestControllerApi();
        Pageable pageable = ; // Pageable | 

        try {
            PagedModelProductBasicDTO result = apiInstance.getProducts(pageable);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProductRestControllerApi#getProducts");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final Pageable pageable = new Pageable(); // Pageable | 

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

import org.openapitools.client.api.ProductRestControllerApi;

public class ProductRestControllerApiExample {
    public static void main(String[] args) {
        ProductRestControllerApi apiInstance = new ProductRestControllerApi();
        Pageable pageable = ; // Pageable | 

        try {
            PagedModelProductBasicDTO result = apiInstance.getProducts(pageable);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProductRestControllerApi#getProducts");
            e.printStackTrace();
        }
    }
}



// Create an instance of the API class
ProductRestControllerApi *apiInstance = [[ProductRestControllerApi alloc] init];
Pageable *pageable = ; //  (default to null)

// Get all products
[apiInstance getProductsWith:pageable
              completionHandler: ^(PagedModelProductBasicDTO output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenApiDefinition = require('open_api_definition');

// Create an instance of the API class
var api = new OpenApiDefinition.ProductRestControllerApi()
var pageable = ; // {Pageable} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new ProductRestControllerApi();
            var pageable = new Pageable(); // Pageable |  (default to null)

            try {
                // Get all products
                PagedModelProductBasicDTO result = apiInstance.getProducts(pageable);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ProductRestControllerApi.getProducts: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ProductRestControllerApi();
$pageable = ; // Pageable | 

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

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::ProductRestControllerApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ProductRestControllerApi->new();
my $pageable = ; # Pageable | 

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

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

# Create an instance of the API class
api_instance = openapi_client.ProductRestControllerApi()
pageable =  # Pageable |  (default to null)

try:
    # Get all products
    api_response = api_instance.get_products(pageable)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ProductRestControllerApi->getProducts: %s\n" % e)

extern crate ProductRestControllerApi;

pub fn main() {
    let pageable = ; // Pageable

    let mut context = ProductRestControllerApi::Context::default();
    let result = client.getProducts(pageable, &context).wait();

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

Scopes

Parameters

Query parameters

Name	Description
pageable*	Pageable Required

Responses

Schema

updateProduct

Update a product

/api/v1/products/{id}

Usage and SDK Samples

curl -X PUT \
 -H "Accept: */*" \
 -H "Content-Type: application/json" \
 "https://localhost:8443/api/v1/products/{id}" \
 -d '{
  "reviewCount" : 5,
  "price" : 6.027456183070403,
  "averageRating" : 5.962133916683182,
  "description" : "description",
  "id" : 0,
  "state" : 1,
  "productName" : "productName"
}'

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

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

public class ProductRestControllerApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        ProductRestControllerApi apiInstance = new ProductRestControllerApi();
        Long id = 789; // Long | 
        ProductBasicDTO productBasicDTO = ; // ProductBasicDTO | 

        try {
            ProductBasicDTO result = apiInstance.updateProduct(id, productBasicDTO);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProductRestControllerApi#updateProduct");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final Long id = new Long(); // Long | 
final ProductBasicDTO productBasicDTO = new ProductBasicDTO(); // ProductBasicDTO | 

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

import org.openapitools.client.api.ProductRestControllerApi;

public class ProductRestControllerApiExample {
    public static void main(String[] args) {
        ProductRestControllerApi apiInstance = new ProductRestControllerApi();
        Long id = 789; // Long | 
        ProductBasicDTO productBasicDTO = ; // ProductBasicDTO | 

        try {
            ProductBasicDTO result = apiInstance.updateProduct(id, productBasicDTO);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProductRestControllerApi#updateProduct");
            e.printStackTrace();
        }
    }
}



// Create an instance of the API class
ProductRestControllerApi *apiInstance = [[ProductRestControllerApi alloc] init];
Long *id = 789; //  (default to null)
ProductBasicDTO *productBasicDTO = ; // 

// Update a product
[apiInstance updateProductWith:id
    productBasicDTO:productBasicDTO
              completionHandler: ^(ProductBasicDTO output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenApiDefinition = require('open_api_definition');

// Create an instance of the API class
var api = new OpenApiDefinition.ProductRestControllerApi()
var id = 789; // {Long} 
var productBasicDTO = ; // {ProductBasicDTO} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new ProductRestControllerApi();
            var id = 789;  // Long |  (default to null)
            var productBasicDTO = new ProductBasicDTO(); // ProductBasicDTO | 

            try {
                // Update a product
                ProductBasicDTO result = apiInstance.updateProduct(id, productBasicDTO);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ProductRestControllerApi.updateProduct: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ProductRestControllerApi();
$id = 789; // Long | 
$productBasicDTO = ; // ProductBasicDTO | 

try {
    $result = $api_instance->updateProduct($id, $productBasicDTO);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ProductRestControllerApi->updateProduct: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::ProductRestControllerApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ProductRestControllerApi->new();
my $id = 789; # Long | 
my $productBasicDTO = WWW::OPenAPIClient::Object::ProductBasicDTO->new(); # ProductBasicDTO | 

eval {
    my $result = $api_instance->updateProduct(id => $id, productBasicDTO => $productBasicDTO);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ProductRestControllerApi->updateProduct: $@\n";
}

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

# Create an instance of the API class
api_instance = openapi_client.ProductRestControllerApi()
id = 789 # Long |  (default to null)
productBasicDTO =  # ProductBasicDTO | 

try:
    # Update a product
    api_response = api_instance.update_product(id, productBasicDTO)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ProductRestControllerApi->updateProduct: %s\n" % e)

extern crate ProductRestControllerApi;

pub fn main() {
    let id = 789; // Long
    let productBasicDTO = ; // ProductBasicDTO

    let mut context = ProductRestControllerApi::Context::default();
    let result = client.updateProduct(id, productBasicDTO, &context).wait();

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

Scopes

Parameters

Path parameters

Name	Description
id*	Long (int64) Required

Body parameters

Name	Description
productBasicDTO *

Responses

Schema

Schema

Schema

Schema

ReviewRestController

createReview

Create review for a product

/api/v1/products/{productId}/reviews/

Usage and SDK Samples

curl -X POST \
 -H "Accept: */*" \
 -H "Content-Type: application/json" \
 "https://localhost:8443/api/v1/products/{productId}/reviews/" \
 -d '{
  "stars" : 0,
  "title" : "title",
  "body" : "body"
}'

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

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

public class ReviewRestControllerApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        ReviewRestControllerApi apiInstance = new ReviewRestControllerApi();
        Long productId = 789; // Long | 
        ReviewPostDTO reviewPostDTO = ; // ReviewPostDTO | 

        try {
            ReviewDTO result = apiInstance.createReview(productId, reviewPostDTO);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ReviewRestControllerApi#createReview");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final Long productId = new Long(); // Long | 
final ReviewPostDTO reviewPostDTO = new ReviewPostDTO(); // ReviewPostDTO | 

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

import org.openapitools.client.api.ReviewRestControllerApi;

public class ReviewRestControllerApiExample {
    public static void main(String[] args) {
        ReviewRestControllerApi apiInstance = new ReviewRestControllerApi();
        Long productId = 789; // Long | 
        ReviewPostDTO reviewPostDTO = ; // ReviewPostDTO | 

        try {
            ReviewDTO result = apiInstance.createReview(productId, reviewPostDTO);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ReviewRestControllerApi#createReview");
            e.printStackTrace();
        }
    }
}



// Create an instance of the API class
ReviewRestControllerApi *apiInstance = [[ReviewRestControllerApi alloc] init];
Long *productId = 789; //  (default to null)
ReviewPostDTO *reviewPostDTO = ; // 

// Create review for a product
[apiInstance createReviewWith:productId
    reviewPostDTO:reviewPostDTO
              completionHandler: ^(ReviewDTO output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenApiDefinition = require('open_api_definition');

// Create an instance of the API class
var api = new OpenApiDefinition.ReviewRestControllerApi()
var productId = 789; // {Long} 
var reviewPostDTO = ; // {ReviewPostDTO} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new ReviewRestControllerApi();
            var productId = 789;  // Long |  (default to null)
            var reviewPostDTO = new ReviewPostDTO(); // ReviewPostDTO | 

            try {
                // Create review for a product
                ReviewDTO result = apiInstance.createReview(productId, reviewPostDTO);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ReviewRestControllerApi.createReview: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ReviewRestControllerApi();
$productId = 789; // Long | 
$reviewPostDTO = ; // ReviewPostDTO | 

try {
    $result = $api_instance->createReview($productId, $reviewPostDTO);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ReviewRestControllerApi->createReview: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::ReviewRestControllerApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ReviewRestControllerApi->new();
my $productId = 789; # Long | 
my $reviewPostDTO = WWW::OPenAPIClient::Object::ReviewPostDTO->new(); # ReviewPostDTO | 

eval {
    my $result = $api_instance->createReview(productId => $productId, reviewPostDTO => $reviewPostDTO);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ReviewRestControllerApi->createReview: $@\n";
}

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

# Create an instance of the API class
api_instance = openapi_client.ReviewRestControllerApi()
productId = 789 # Long |  (default to null)
reviewPostDTO =  # ReviewPostDTO | 

try:
    # Create review for a product
    api_response = api_instance.create_review(productId, reviewPostDTO)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ReviewRestControllerApi->createReview: %s\n" % e)

extern crate ReviewRestControllerApi;

pub fn main() {
    let productId = 789; // Long
    let reviewPostDTO = ; // ReviewPostDTO

    let mut context = ReviewRestControllerApi::Context::default();
    let result = client.createReview(productId, reviewPostDTO, &context).wait();

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

Scopes

Parameters

Path parameters

Name	Description
productId*	Long (int64) Required

Body parameters

Name	Description
reviewPostDTO *

Responses

Schema

Schema

Schema

deleteReviewById

Delete review

/api/v1/products/{productID}/reviews/{reviewID}

Usage and SDK Samples

curl -X DELETE \
 -H "Accept: */*" \
 "https://localhost:8443/api/v1/products/{productID}/reviews/{reviewID}"

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

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

public class ReviewRestControllerApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        ReviewRestControllerApi apiInstance = new ReviewRestControllerApi();
        Long productID = 789; // Long | 
        Long reviewID = 789; // Long | 

        try {
            ReviewDTO result = apiInstance.deleteReviewById(productID, reviewID);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ReviewRestControllerApi#deleteReviewById");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final Long productID = new Long(); // Long | 
final Long reviewID = new Long(); // Long | 

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

import org.openapitools.client.api.ReviewRestControllerApi;

public class ReviewRestControllerApiExample {
    public static void main(String[] args) {
        ReviewRestControllerApi apiInstance = new ReviewRestControllerApi();
        Long productID = 789; // Long | 
        Long reviewID = 789; // Long | 

        try {
            ReviewDTO result = apiInstance.deleteReviewById(productID, reviewID);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ReviewRestControllerApi#deleteReviewById");
            e.printStackTrace();
        }
    }
}



// Create an instance of the API class
ReviewRestControllerApi *apiInstance = [[ReviewRestControllerApi alloc] init];
Long *productID = 789; //  (default to null)
Long *reviewID = 789; //  (default to null)

// Delete review
[apiInstance deleteReviewByIdWith:productID
    reviewID:reviewID
              completionHandler: ^(ReviewDTO output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenApiDefinition = require('open_api_definition');

// Create an instance of the API class
var api = new OpenApiDefinition.ReviewRestControllerApi()
var productID = 789; // {Long} 
var reviewID = 789; // {Long} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new ReviewRestControllerApi();
            var productID = 789;  // Long |  (default to null)
            var reviewID = 789;  // Long |  (default to null)

            try {
                // Delete review
                ReviewDTO result = apiInstance.deleteReviewById(productID, reviewID);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ReviewRestControllerApi.deleteReviewById: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ReviewRestControllerApi();
$productID = 789; // Long | 
$reviewID = 789; // Long | 

try {
    $result = $api_instance->deleteReviewById($productID, $reviewID);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ReviewRestControllerApi->deleteReviewById: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::ReviewRestControllerApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ReviewRestControllerApi->new();
my $productID = 789; # Long | 
my $reviewID = 789; # Long | 

eval {
    my $result = $api_instance->deleteReviewById(productID => $productID, reviewID => $reviewID);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ReviewRestControllerApi->deleteReviewById: $@\n";
}

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

# Create an instance of the API class
api_instance = openapi_client.ReviewRestControllerApi()
productID = 789 # Long |  (default to null)
reviewID = 789 # Long |  (default to null)

try:
    # Delete review
    api_response = api_instance.delete_review_by_id(productID, reviewID)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ReviewRestControllerApi->deleteReviewById: %s\n" % e)

extern crate ReviewRestControllerApi;

pub fn main() {
    let productID = 789; // Long
    let reviewID = 789; // Long

    let mut context = ReviewRestControllerApi::Context::default();
    let result = client.deleteReviewById(productID, reviewID, &context).wait();

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

Scopes

Parameters

Path parameters

Name	Description
productID*	Long (int64) Required
reviewID*	Long (int64) Required

Responses

Schema

Schema

Schema

getAllReviews

Get all reviews

/api/v1/products/all/reviews/

Usage and SDK Samples

curl -X GET \
 -H "Accept: */*" \
 "https://localhost:8443/api/v1/products/all/reviews/"

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

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

public class ReviewRestControllerApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        ReviewRestControllerApi apiInstance = new ReviewRestControllerApi();

        try {
            array[ReviewDTO] result = apiInstance.getAllReviews();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ReviewRestControllerApi#getAllReviews");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();


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

import org.openapitools.client.api.ReviewRestControllerApi;

public class ReviewRestControllerApiExample {
    public static void main(String[] args) {
        ReviewRestControllerApi apiInstance = new ReviewRestControllerApi();

        try {
            array[ReviewDTO] result = apiInstance.getAllReviews();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ReviewRestControllerApi#getAllReviews");
            e.printStackTrace();
        }
    }
}



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

// Get all reviews
[apiInstance getAllReviewsWithCompletionHandler: 
              ^(array[ReviewDTO] output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenApiDefinition = require('open_api_definition');

// Create an instance of the API class
var api = new OpenApiDefinition.ReviewRestControllerApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getAllReviews(callback);

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

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

            // Create an instance of the API class
            var apiInstance = new ReviewRestControllerApi();

            try {
                // Get all reviews
                array[ReviewDTO] result = apiInstance.getAllReviews();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ReviewRestControllerApi.getAllReviews: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ReviewRestControllerApi();

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

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::ReviewRestControllerApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ReviewRestControllerApi->new();

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

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

# Create an instance of the API class
api_instance = openapi_client.ReviewRestControllerApi()

try:
    # Get all reviews
    api_response = api_instance.get_all_reviews()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ReviewRestControllerApi->getAllReviews: %s\n" % e)

extern crate ReviewRestControllerApi;

pub fn main() {

    let mut context = ReviewRestControllerApi::Context::default();
    let result = client.getAllReviews(&context).wait();

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

Scopes

Parameters

Responses

Schema

getReviewById

Get review by ID

/api/v1/products/all/reviews/{id}

Usage and SDK Samples

curl -X GET \
 -H "Accept: */*" \
 "https://localhost:8443/api/v1/products/all/reviews/{id}"

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

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

public class ReviewRestControllerApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        ReviewRestControllerApi apiInstance = new ReviewRestControllerApi();
        Long id = 789; // Long | 

        try {
            ReviewDTO result = apiInstance.getReviewById(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ReviewRestControllerApi#getReviewById");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final Long id = new Long(); // Long | 

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

import org.openapitools.client.api.ReviewRestControllerApi;

public class ReviewRestControllerApiExample {
    public static void main(String[] args) {
        ReviewRestControllerApi apiInstance = new ReviewRestControllerApi();
        Long id = 789; // Long | 

        try {
            ReviewDTO result = apiInstance.getReviewById(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ReviewRestControllerApi#getReviewById");
            e.printStackTrace();
        }
    }
}



// Create an instance of the API class
ReviewRestControllerApi *apiInstance = [[ReviewRestControllerApi alloc] init];
Long *id = 789; //  (default to null)

// Get review by ID
[apiInstance getReviewByIdWith:id
              completionHandler: ^(ReviewDTO output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenApiDefinition = require('open_api_definition');

// Create an instance of the API class
var api = new OpenApiDefinition.ReviewRestControllerApi()
var id = 789; // {Long} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new ReviewRestControllerApi();
            var id = 789;  // Long |  (default to null)

            try {
                // Get review by ID
                ReviewDTO result = apiInstance.getReviewById(id);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ReviewRestControllerApi.getReviewById: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ReviewRestControllerApi();
$id = 789; // Long | 

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

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::ReviewRestControllerApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ReviewRestControllerApi->new();
my $id = 789; # Long | 

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

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

# Create an instance of the API class
api_instance = openapi_client.ReviewRestControllerApi()
id = 789 # Long |  (default to null)

try:
    # Get review by ID
    api_response = api_instance.get_review_by_id(id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ReviewRestControllerApi->getReviewById: %s\n" % e)

extern crate ReviewRestControllerApi;

pub fn main() {
    let id = 789; // Long

    let mut context = ReviewRestControllerApi::Context::default();
    let result = client.getReviewById(id, &context).wait();

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

Scopes

Parameters

Path parameters

Name	Description
id*	Long (int64) Required

Responses

Schema

Schema

updateReview

Update a review

/api/v1/products/{productId}/reviews/{reviewId}

Usage and SDK Samples

curl -X PUT \
 -H "Accept: */*" \
 -H "Content-Type: application/json" \
 "https://localhost:8443/api/v1/products/{productId}/reviews/{reviewId}" \
 -d '{
  "stars" : 0,
  "title" : "title",
  "body" : "body"
}'

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

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

public class ReviewRestControllerApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        ReviewRestControllerApi apiInstance = new ReviewRestControllerApi();
        Long productId = 789; // Long | 
        Long reviewId = 789; // Long | 
        ReviewPostDTO reviewPostDTO = ; // ReviewPostDTO | 

        try {
            ReviewDTO result = apiInstance.updateReview(productId, reviewId, reviewPostDTO);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ReviewRestControllerApi#updateReview");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final Long productId = new Long(); // Long | 
final Long reviewId = new Long(); // Long | 
final ReviewPostDTO reviewPostDTO = new ReviewPostDTO(); // ReviewPostDTO | 

try {
    final result = await api_instance.updateReview(productId, reviewId, reviewPostDTO);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->updateReview: $e\n');
}

import org.openapitools.client.api.ReviewRestControllerApi;

public class ReviewRestControllerApiExample {
    public static void main(String[] args) {
        ReviewRestControllerApi apiInstance = new ReviewRestControllerApi();
        Long productId = 789; // Long | 
        Long reviewId = 789; // Long | 
        ReviewPostDTO reviewPostDTO = ; // ReviewPostDTO | 

        try {
            ReviewDTO result = apiInstance.updateReview(productId, reviewId, reviewPostDTO);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ReviewRestControllerApi#updateReview");
            e.printStackTrace();
        }
    }
}



// Create an instance of the API class
ReviewRestControllerApi *apiInstance = [[ReviewRestControllerApi alloc] init];
Long *productId = 789; //  (default to null)
Long *reviewId = 789; //  (default to null)
ReviewPostDTO *reviewPostDTO = ; // 

// Update a review
[apiInstance updateReviewWith:productId
    reviewId:reviewId
    reviewPostDTO:reviewPostDTO
              completionHandler: ^(ReviewDTO output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenApiDefinition = require('open_api_definition');

// Create an instance of the API class
var api = new OpenApiDefinition.ReviewRestControllerApi()
var productId = 789; // {Long} 
var reviewId = 789; // {Long} 
var reviewPostDTO = ; // {ReviewPostDTO} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new ReviewRestControllerApi();
            var productId = 789;  // Long |  (default to null)
            var reviewId = 789;  // Long |  (default to null)
            var reviewPostDTO = new ReviewPostDTO(); // ReviewPostDTO | 

            try {
                // Update a review
                ReviewDTO result = apiInstance.updateReview(productId, reviewId, reviewPostDTO);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ReviewRestControllerApi.updateReview: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ReviewRestControllerApi();
$productId = 789; // Long | 
$reviewId = 789; // Long | 
$reviewPostDTO = ; // ReviewPostDTO | 

try {
    $result = $api_instance->updateReview($productId, $reviewId, $reviewPostDTO);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ReviewRestControllerApi->updateReview: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::ReviewRestControllerApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ReviewRestControllerApi->new();
my $productId = 789; # Long | 
my $reviewId = 789; # Long | 
my $reviewPostDTO = WWW::OPenAPIClient::Object::ReviewPostDTO->new(); # ReviewPostDTO | 

eval {
    my $result = $api_instance->updateReview(productId => $productId, reviewId => $reviewId, reviewPostDTO => $reviewPostDTO);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ReviewRestControllerApi->updateReview: $@\n";
}

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

# Create an instance of the API class
api_instance = openapi_client.ReviewRestControllerApi()
productId = 789 # Long |  (default to null)
reviewId = 789 # Long |  (default to null)
reviewPostDTO =  # ReviewPostDTO | 

try:
    # Update a review
    api_response = api_instance.update_review(productId, reviewId, reviewPostDTO)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ReviewRestControllerApi->updateReview: %s\n" % e)

extern crate ReviewRestControllerApi;

pub fn main() {
    let productId = 789; // Long
    let reviewId = 789; // Long
    let reviewPostDTO = ; // ReviewPostDTO

    let mut context = ReviewRestControllerApi::Context::default();
    let result = client.updateReview(productId, reviewId, reviewPostDTO, &context).wait();

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

Scopes

Parameters

Path parameters

Name	Description
productId*	Long (int64) Required
reviewId*	Long (int64) Required

Body parameters

Name	Description
reviewPostDTO *

Responses

Schema

Schema

Schema

Schema

ShoppingCartRestController

addProductToCart

Add product to cart

/api/v1/carts/me/items

Usage and SDK Samples

curl -X POST \
 -H "Accept: */*" \
 -H "Content-Type: application/json" \
 "https://localhost:8443/api/v1/carts/me/items" \
 -d '{
  "productId" : 0
}'

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

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

public class ShoppingCartRestControllerApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        ShoppingCartRestControllerApi apiInstance = new ShoppingCartRestControllerApi();
        CartItemRequestDTO cartItemRequestDTO = ; // CartItemRequestDTO | 

        try {
            ShoppingCartDTO result = apiInstance.addProductToCart(cartItemRequestDTO);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ShoppingCartRestControllerApi#addProductToCart");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final CartItemRequestDTO cartItemRequestDTO = new CartItemRequestDTO(); // CartItemRequestDTO | 

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

import org.openapitools.client.api.ShoppingCartRestControllerApi;

public class ShoppingCartRestControllerApiExample {
    public static void main(String[] args) {
        ShoppingCartRestControllerApi apiInstance = new ShoppingCartRestControllerApi();
        CartItemRequestDTO cartItemRequestDTO = ; // CartItemRequestDTO | 

        try {
            ShoppingCartDTO result = apiInstance.addProductToCart(cartItemRequestDTO);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ShoppingCartRestControllerApi#addProductToCart");
            e.printStackTrace();
        }
    }
}



// Create an instance of the API class
ShoppingCartRestControllerApi *apiInstance = [[ShoppingCartRestControllerApi alloc] init];
CartItemRequestDTO *cartItemRequestDTO = ; // 

// Add product to cart
[apiInstance addProductToCartWith:cartItemRequestDTO
              completionHandler: ^(ShoppingCartDTO output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenApiDefinition = require('open_api_definition');

// Create an instance of the API class
var api = new OpenApiDefinition.ShoppingCartRestControllerApi()
var cartItemRequestDTO = ; // {CartItemRequestDTO} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new ShoppingCartRestControllerApi();
            var cartItemRequestDTO = new CartItemRequestDTO(); // CartItemRequestDTO | 

            try {
                // Add product to cart
                ShoppingCartDTO result = apiInstance.addProductToCart(cartItemRequestDTO);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ShoppingCartRestControllerApi.addProductToCart: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ShoppingCartRestControllerApi();
$cartItemRequestDTO = ; // CartItemRequestDTO | 

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

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::ShoppingCartRestControllerApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ShoppingCartRestControllerApi->new();
my $cartItemRequestDTO = WWW::OPenAPIClient::Object::CartItemRequestDTO->new(); # CartItemRequestDTO | 

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

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

# Create an instance of the API class
api_instance = openapi_client.ShoppingCartRestControllerApi()
cartItemRequestDTO =  # CartItemRequestDTO | 

try:
    # Add product to cart
    api_response = api_instance.add_product_to_cart(cartItemRequestDTO)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ShoppingCartRestControllerApi->addProductToCart: %s\n" % e)

extern crate ShoppingCartRestControllerApi;

pub fn main() {
    let cartItemRequestDTO = ; // CartItemRequestDTO

    let mut context = ShoppingCartRestControllerApi::Context::default();
    let result = client.addProductToCart(cartItemRequestDTO, &context).wait();

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

Scopes

Parameters

Body parameters

Name	Description
cartItemRequestDTO *

Responses

Schema

Schema

getMyCart

Get my shopping cart

/api/v1/carts/me

Usage and SDK Samples

curl -X GET \
 -H "Accept: */*" \
 "https://localhost:8443/api/v1/carts/me"

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

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

public class ShoppingCartRestControllerApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        ShoppingCartRestControllerApi apiInstance = new ShoppingCartRestControllerApi();

        try {
            ShoppingCartDTO result = apiInstance.getMyCart();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ShoppingCartRestControllerApi#getMyCart");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();


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

import org.openapitools.client.api.ShoppingCartRestControllerApi;

public class ShoppingCartRestControllerApiExample {
    public static void main(String[] args) {
        ShoppingCartRestControllerApi apiInstance = new ShoppingCartRestControllerApi();

        try {
            ShoppingCartDTO result = apiInstance.getMyCart();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ShoppingCartRestControllerApi#getMyCart");
            e.printStackTrace();
        }
    }
}



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

// Get my shopping cart
[apiInstance getMyCartWithCompletionHandler: 
              ^(ShoppingCartDTO output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenApiDefinition = require('open_api_definition');

// Create an instance of the API class
var api = new OpenApiDefinition.ShoppingCartRestControllerApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getMyCart(callback);

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

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

            // Create an instance of the API class
            var apiInstance = new ShoppingCartRestControllerApi();

            try {
                // Get my shopping cart
                ShoppingCartDTO result = apiInstance.getMyCart();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ShoppingCartRestControllerApi.getMyCart: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ShoppingCartRestControllerApi();

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

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::ShoppingCartRestControllerApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ShoppingCartRestControllerApi->new();

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

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

# Create an instance of the API class
api_instance = openapi_client.ShoppingCartRestControllerApi()

try:
    # Get my shopping cart
    api_response = api_instance.get_my_cart()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ShoppingCartRestControllerApi->getMyCart: %s\n" % e)

extern crate ShoppingCartRestControllerApi;

pub fn main() {

    let mut context = ShoppingCartRestControllerApi::Context::default();
    let result = client.getMyCart(&context).wait();

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

Scopes

Parameters

Responses

Schema

Schema

modifyQuantity

Modify item quantity in cart

/api/v1/carts/me/items/{cartItemId}

Usage and SDK Samples

curl -X PUT \
 -H "Accept: */*" \
 -H "Content-Type: application/json" \
 "https://localhost:8443/api/v1/carts/me/items/{cartItemId}" \
 -d ''

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

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

public class ShoppingCartRestControllerApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        ShoppingCartRestControllerApi apiInstance = new ShoppingCartRestControllerApi();
        Long cartItemId = 789; // Long | 
        map[String, Integer] requestBody = Object; // map[String, Integer] | 

        try {
            CartItemDTO result = apiInstance.modifyQuantity(cartItemId, requestBody);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ShoppingCartRestControllerApi#modifyQuantity");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final Long cartItemId = new Long(); // Long | 
final map[String, Integer] requestBody = new map[String, Integer](); // map[String, Integer] | 

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

import org.openapitools.client.api.ShoppingCartRestControllerApi;

public class ShoppingCartRestControllerApiExample {
    public static void main(String[] args) {
        ShoppingCartRestControllerApi apiInstance = new ShoppingCartRestControllerApi();
        Long cartItemId = 789; // Long | 
        map[String, Integer] requestBody = Object; // map[String, Integer] | 

        try {
            CartItemDTO result = apiInstance.modifyQuantity(cartItemId, requestBody);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ShoppingCartRestControllerApi#modifyQuantity");
            e.printStackTrace();
        }
    }
}



// Create an instance of the API class
ShoppingCartRestControllerApi *apiInstance = [[ShoppingCartRestControllerApi alloc] init];
Long *cartItemId = 789; //  (default to null)
map[String, Integer] *requestBody = Object; // 

// Modify item quantity in cart
[apiInstance modifyQuantityWith:cartItemId
    requestBody:requestBody
              completionHandler: ^(CartItemDTO output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenApiDefinition = require('open_api_definition');

// Create an instance of the API class
var api = new OpenApiDefinition.ShoppingCartRestControllerApi()
var cartItemId = 789; // {Long} 
var requestBody = Object; // {map[String, Integer]} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new ShoppingCartRestControllerApi();
            var cartItemId = 789;  // Long |  (default to null)
            var requestBody = new map[String, Integer](); // map[String, Integer] | 

            try {
                // Modify item quantity in cart
                CartItemDTO result = apiInstance.modifyQuantity(cartItemId, requestBody);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ShoppingCartRestControllerApi.modifyQuantity: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ShoppingCartRestControllerApi();
$cartItemId = 789; // Long | 
$requestBody = Object; // map[String, Integer] | 

try {
    $result = $api_instance->modifyQuantity($cartItemId, $requestBody);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ShoppingCartRestControllerApi->modifyQuantity: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::ShoppingCartRestControllerApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ShoppingCartRestControllerApi->new();
my $cartItemId = 789; # Long | 
my $requestBody = WWW::OPenAPIClient::Object::map[String, Integer]->new(); # map[String, Integer] | 

eval {
    my $result = $api_instance->modifyQuantity(cartItemId => $cartItemId, requestBody => $requestBody);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ShoppingCartRestControllerApi->modifyQuantity: $@\n";
}

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

# Create an instance of the API class
api_instance = openapi_client.ShoppingCartRestControllerApi()
cartItemId = 789 # Long |  (default to null)
requestBody = Object # map[String, Integer] | 

try:
    # Modify item quantity in cart
    api_response = api_instance.modify_quantity(cartItemId, requestBody)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ShoppingCartRestControllerApi->modifyQuantity: %s\n" % e)

extern crate ShoppingCartRestControllerApi;

pub fn main() {
    let cartItemId = 789; // Long
    let requestBody = Object; // map[String, Integer]

    let mut context = ShoppingCartRestControllerApi::Context::default();
    let result = client.modifyQuantity(cartItemId, requestBody, &context).wait();

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

Scopes

Parameters

Path parameters

Name	Description
cartItemId*	Long (int64) Required

Body parameters

Name	Description
requestBody *

Responses

Schema

Schema

Schema

removeProductFromCart

Remove product from cart

/api/v1/carts/me/items/{itemId}

Usage and SDK Samples

curl -X DELETE \
 -H "Accept: */*" \
 "https://localhost:8443/api/v1/carts/me/items/{itemId}"

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

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

public class ShoppingCartRestControllerApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        ShoppingCartRestControllerApi apiInstance = new ShoppingCartRestControllerApi();
        Long itemId = 789; // Long | 

        try {
            ShoppingCartDTO result = apiInstance.removeProductFromCart(itemId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ShoppingCartRestControllerApi#removeProductFromCart");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final Long itemId = new Long(); // Long | 

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

import org.openapitools.client.api.ShoppingCartRestControllerApi;

public class ShoppingCartRestControllerApiExample {
    public static void main(String[] args) {
        ShoppingCartRestControllerApi apiInstance = new ShoppingCartRestControllerApi();
        Long itemId = 789; // Long | 

        try {
            ShoppingCartDTO result = apiInstance.removeProductFromCart(itemId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ShoppingCartRestControllerApi#removeProductFromCart");
            e.printStackTrace();
        }
    }
}



// Create an instance of the API class
ShoppingCartRestControllerApi *apiInstance = [[ShoppingCartRestControllerApi alloc] init];
Long *itemId = 789; //  (default to null)

// Remove product from cart
[apiInstance removeProductFromCartWith:itemId
              completionHandler: ^(ShoppingCartDTO output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenApiDefinition = require('open_api_definition');

// Create an instance of the API class
var api = new OpenApiDefinition.ShoppingCartRestControllerApi()
var itemId = 789; // {Long} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new ShoppingCartRestControllerApi();
            var itemId = 789;  // Long |  (default to null)

            try {
                // Remove product from cart
                ShoppingCartDTO result = apiInstance.removeProductFromCart(itemId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ShoppingCartRestControllerApi.removeProductFromCart: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ShoppingCartRestControllerApi();
$itemId = 789; // Long | 

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

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::ShoppingCartRestControllerApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ShoppingCartRestControllerApi->new();
my $itemId = 789; # Long | 

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

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

# Create an instance of the API class
api_instance = openapi_client.ShoppingCartRestControllerApi()
itemId = 789 # Long |  (default to null)

try:
    # Remove product from cart
    api_response = api_instance.remove_product_from_cart(itemId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ShoppingCartRestControllerApi->removeProductFromCart: %s\n" % e)

extern crate ShoppingCartRestControllerApi;

pub fn main() {
    let itemId = 789; // Long

    let mut context = ShoppingCartRestControllerApi::Context::default();
    let result = client.removeProductFromCart(itemId, &context).wait();

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

Scopes

Parameters

Path parameters

Name	Description
itemId*	Long (int64) Required

Responses

Schema

Schema

UserRestController

changeUserState

Change user state (Admin)

/api/v1/users/{id}/state

Usage and SDK Samples

curl -X PUT \
 -H "Accept: */*" \
 -H "Content-Type: application/json" \
 "https://localhost:8443/api/v1/users/{id}/state" \
 -d ''

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

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

public class UserRestControllerApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        UserRestControllerApi apiInstance = new UserRestControllerApi();
        Long id = 789; // Long | 
        map[String, Boolean] requestBody = Object; // map[String, Boolean] | 

        try {
            UserBasicDTO result = apiInstance.changeUserState(id, requestBody);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling UserRestControllerApi#changeUserState");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final Long id = new Long(); // Long | 
final map[String, Boolean] requestBody = new map[String, Boolean](); // map[String, Boolean] | 

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

import org.openapitools.client.api.UserRestControllerApi;

public class UserRestControllerApiExample {
    public static void main(String[] args) {
        UserRestControllerApi apiInstance = new UserRestControllerApi();
        Long id = 789; // Long | 
        map[String, Boolean] requestBody = Object; // map[String, Boolean] | 

        try {
            UserBasicDTO result = apiInstance.changeUserState(id, requestBody);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling UserRestControllerApi#changeUserState");
            e.printStackTrace();
        }
    }
}



// Create an instance of the API class
UserRestControllerApi *apiInstance = [[UserRestControllerApi alloc] init];
Long *id = 789; //  (default to null)
map[String, Boolean] *requestBody = Object; // 

// Change user state (Admin)
[apiInstance changeUserStateWith:id
    requestBody:requestBody
              completionHandler: ^(UserBasicDTO output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenApiDefinition = require('open_api_definition');

// Create an instance of the API class
var api = new OpenApiDefinition.UserRestControllerApi()
var id = 789; // {Long} 
var requestBody = Object; // {map[String, Boolean]} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new UserRestControllerApi();
            var id = 789;  // Long |  (default to null)
            var requestBody = new map[String, Boolean](); // map[String, Boolean] | 

            try {
                // Change user state (Admin)
                UserBasicDTO result = apiInstance.changeUserState(id, requestBody);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling UserRestControllerApi.changeUserState: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\UserRestControllerApi();
$id = 789; // Long | 
$requestBody = Object; // map[String, Boolean] | 

try {
    $result = $api_instance->changeUserState($id, $requestBody);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling UserRestControllerApi->changeUserState: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::UserRestControllerApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::UserRestControllerApi->new();
my $id = 789; # Long | 
my $requestBody = WWW::OPenAPIClient::Object::map[String, Boolean]->new(); # map[String, Boolean] | 

eval {
    my $result = $api_instance->changeUserState(id => $id, requestBody => $requestBody);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling UserRestControllerApi->changeUserState: $@\n";
}

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

# Create an instance of the API class
api_instance = openapi_client.UserRestControllerApi()
id = 789 # Long |  (default to null)
requestBody = Object # map[String, Boolean] | 

try:
    # Change user state (Admin)
    api_response = api_instance.change_user_state(id, requestBody)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling UserRestControllerApi->changeUserState: %s\n" % e)

extern crate UserRestControllerApi;

pub fn main() {
    let id = 789; // Long
    let requestBody = Object; // map[String, Boolean]

    let mut context = UserRestControllerApi::Context::default();
    let result = client.changeUserState(id, requestBody, &context).wait();

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

Scopes

Parameters

Path parameters

Name	Description
id*	Long (int64) Required

Body parameters

Name	Description
requestBody *

Responses

Schema

Schema

Schema

Schema

createUser

/api/v1/users

Usage and SDK Samples

curl -X POST \
 -H "Accept: */*" \
 -H "Content-Type: application/json" \
 "https://localhost:8443/api/v1/users" \
 -d '{
  "password" : "password",
  "address" : "address",
  "surname" : "surname",
  "userName" : "userName",
  "email" : "email"
}'

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

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

public class UserRestControllerApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        UserRestControllerApi apiInstance = new UserRestControllerApi();
        UserPostDTO userPostDTO = ; // UserPostDTO | 

        try {
            UserBasicDTO result = apiInstance.createUser(userPostDTO);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling UserRestControllerApi#createUser");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final UserPostDTO userPostDTO = new UserPostDTO(); // UserPostDTO | 

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

import org.openapitools.client.api.UserRestControllerApi;

public class UserRestControllerApiExample {
    public static void main(String[] args) {
        UserRestControllerApi apiInstance = new UserRestControllerApi();
        UserPostDTO userPostDTO = ; // UserPostDTO | 

        try {
            UserBasicDTO result = apiInstance.createUser(userPostDTO);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling UserRestControllerApi#createUser");
            e.printStackTrace();
        }
    }
}



// Create an instance of the API class
UserRestControllerApi *apiInstance = [[UserRestControllerApi alloc] init];
UserPostDTO *userPostDTO = ; // 

// Register new user
[apiInstance createUserWith:userPostDTO
              completionHandler: ^(UserBasicDTO output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenApiDefinition = require('open_api_definition');

// Create an instance of the API class
var api = new OpenApiDefinition.UserRestControllerApi()
var userPostDTO = ; // {UserPostDTO} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new UserRestControllerApi();
            var userPostDTO = new UserPostDTO(); // UserPostDTO | 

            try {
                // Register new user
                UserBasicDTO result = apiInstance.createUser(userPostDTO);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling UserRestControllerApi.createUser: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\UserRestControllerApi();
$userPostDTO = ; // UserPostDTO | 

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

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::UserRestControllerApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::UserRestControllerApi->new();
my $userPostDTO = WWW::OPenAPIClient::Object::UserPostDTO->new(); # UserPostDTO | 

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

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

# Create an instance of the API class
api_instance = openapi_client.UserRestControllerApi()
userPostDTO =  # UserPostDTO | 

try:
    # Register new user
    api_response = api_instance.create_user(userPostDTO)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling UserRestControllerApi->createUser: %s\n" % e)

extern crate UserRestControllerApi;

pub fn main() {
    let userPostDTO = ; // UserPostDTO

    let mut context = UserRestControllerApi::Context::default();
    let result = client.createUser(userPostDTO, &context).wait();

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

Scopes

Parameters

Body parameters

Name	Description
userPostDTO *

Responses

Schema

Schema

deleteUserById

Delete user by ID

/api/v1/users/{id}

Usage and SDK Samples

curl -X DELETE \
 -H "Accept: */*" \
 "https://localhost:8443/api/v1/users/{id}"

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

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

public class UserRestControllerApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        UserRestControllerApi apiInstance = new UserRestControllerApi();
        Long id = 789; // Long | 

        try {
            UserBasicDTO result = apiInstance.deleteUserById(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling UserRestControllerApi#deleteUserById");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final Long id = new Long(); // Long | 

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

import org.openapitools.client.api.UserRestControllerApi;

public class UserRestControllerApiExample {
    public static void main(String[] args) {
        UserRestControllerApi apiInstance = new UserRestControllerApi();
        Long id = 789; // Long | 

        try {
            UserBasicDTO result = apiInstance.deleteUserById(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling UserRestControllerApi#deleteUserById");
            e.printStackTrace();
        }
    }
}



// Create an instance of the API class
UserRestControllerApi *apiInstance = [[UserRestControllerApi alloc] init];
Long *id = 789; //  (default to null)

// Delete user by ID
[apiInstance deleteUserByIdWith:id
              completionHandler: ^(UserBasicDTO output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenApiDefinition = require('open_api_definition');

// Create an instance of the API class
var api = new OpenApiDefinition.UserRestControllerApi()
var id = 789; // {Long} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new UserRestControllerApi();
            var id = 789;  // Long |  (default to null)

            try {
                // Delete user by ID
                UserBasicDTO result = apiInstance.deleteUserById(id);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling UserRestControllerApi.deleteUserById: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\UserRestControllerApi();
$id = 789; // Long | 

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

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::UserRestControllerApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::UserRestControllerApi->new();
my $id = 789; # Long | 

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

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

# Create an instance of the API class
api_instance = openapi_client.UserRestControllerApi()
id = 789 # Long |  (default to null)

try:
    # Delete user by ID
    api_response = api_instance.delete_user_by_id(id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling UserRestControllerApi->deleteUserById: %s\n" % e)

extern crate UserRestControllerApi;

pub fn main() {
    let id = 789; // Long

    let mut context = UserRestControllerApi::Context::default();
    let result = client.deleteUserById(id, &context).wait();

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

Scopes

Parameters

Path parameters

Name	Description
id*	Long (int64) Required

Responses

Schema

Schema

Schema

deleteUserImage

Delete user profile image

/api/v1/users/{id}/image/

Usage and SDK Samples

curl -X DELETE \
 -H "Accept: */*" \
 "https://localhost:8443/api/v1/users/{id}/image/"

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

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

public class UserRestControllerApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        UserRestControllerApi apiInstance = new UserRestControllerApi();
        Long id = 789; // Long | 

        try {
            ImageDTO result = apiInstance.deleteUserImage(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling UserRestControllerApi#deleteUserImage");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final Long id = new Long(); // Long | 

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

import org.openapitools.client.api.UserRestControllerApi;

public class UserRestControllerApiExample {
    public static void main(String[] args) {
        UserRestControllerApi apiInstance = new UserRestControllerApi();
        Long id = 789; // Long | 

        try {
            ImageDTO result = apiInstance.deleteUserImage(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling UserRestControllerApi#deleteUserImage");
            e.printStackTrace();
        }
    }
}



// Create an instance of the API class
UserRestControllerApi *apiInstance = [[UserRestControllerApi alloc] init];
Long *id = 789; //  (default to null)

// Delete user profile image
[apiInstance deleteUserImageWith:id
              completionHandler: ^(ImageDTO output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenApiDefinition = require('open_api_definition');

// Create an instance of the API class
var api = new OpenApiDefinition.UserRestControllerApi()
var id = 789; // {Long} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new UserRestControllerApi();
            var id = 789;  // Long |  (default to null)

            try {
                // Delete user profile image
                ImageDTO result = apiInstance.deleteUserImage(id);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling UserRestControllerApi.deleteUserImage: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\UserRestControllerApi();
$id = 789; // Long | 

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

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::UserRestControllerApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::UserRestControllerApi->new();
my $id = 789; # Long | 

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

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

# Create an instance of the API class
api_instance = openapi_client.UserRestControllerApi()
id = 789 # Long |  (default to null)

try:
    # Delete user profile image
    api_response = api_instance.delete_user_image(id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling UserRestControllerApi->deleteUserImage: %s\n" % e)

extern crate UserRestControllerApi;

pub fn main() {
    let id = 789; // Long

    let mut context = UserRestControllerApi::Context::default();
    let result = client.deleteUserImage(id, &context).wait();

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

Scopes

Parameters

Path parameters

Name	Description
id*	Long (int64) Required

Responses

Schema

Schema

Schema

getAllUsers

Get all users (Admin)

/api/v1/users

Usage and SDK Samples

curl -X GET \
 -H "Accept: */*" \
 "https://localhost:8443/api/v1/users"

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

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

public class UserRestControllerApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        UserRestControllerApi apiInstance = new UserRestControllerApi();

        try {
            array[UserBasicDTO] result = apiInstance.getAllUsers();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling UserRestControllerApi#getAllUsers");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();


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

import org.openapitools.client.api.UserRestControllerApi;

public class UserRestControllerApiExample {
    public static void main(String[] args) {
        UserRestControllerApi apiInstance = new UserRestControllerApi();

        try {
            array[UserBasicDTO] result = apiInstance.getAllUsers();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling UserRestControllerApi#getAllUsers");
            e.printStackTrace();
        }
    }
}



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

// Get all users (Admin)
[apiInstance getAllUsersWithCompletionHandler: 
              ^(array[UserBasicDTO] output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenApiDefinition = require('open_api_definition');

// Create an instance of the API class
var api = new OpenApiDefinition.UserRestControllerApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getAllUsers(callback);

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

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

            // Create an instance of the API class
            var apiInstance = new UserRestControllerApi();

            try {
                // Get all users (Admin)
                array[UserBasicDTO] result = apiInstance.getAllUsers();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling UserRestControllerApi.getAllUsers: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\UserRestControllerApi();

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

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::UserRestControllerApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::UserRestControllerApi->new();

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

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

# Create an instance of the API class
api_instance = openapi_client.UserRestControllerApi()

try:
    # Get all users (Admin)
    api_response = api_instance.get_all_users()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling UserRestControllerApi->getAllUsers: %s\n" % e)

extern crate UserRestControllerApi;

pub fn main() {

    let mut context = UserRestControllerApi::Context::default();
    let result = client.getAllUsers(&context).wait();

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

Scopes

Parameters

Responses

Schema

Schema

getUserById

Get user by ID

/api/v1/users/{id}

Usage and SDK Samples

curl -X GET \
 -H "Accept: */*" \
 "https://localhost:8443/api/v1/users/{id}"

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

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

public class UserRestControllerApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        UserRestControllerApi apiInstance = new UserRestControllerApi();
        Long id = 789; // Long | 

        try {
            UserBasicDTO result = apiInstance.getUserById(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling UserRestControllerApi#getUserById");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final Long id = new Long(); // Long | 

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

import org.openapitools.client.api.UserRestControllerApi;

public class UserRestControllerApiExample {
    public static void main(String[] args) {
        UserRestControllerApi apiInstance = new UserRestControllerApi();
        Long id = 789; // Long | 

        try {
            UserBasicDTO result = apiInstance.getUserById(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling UserRestControllerApi#getUserById");
            e.printStackTrace();
        }
    }
}



// Create an instance of the API class
UserRestControllerApi *apiInstance = [[UserRestControllerApi alloc] init];
Long *id = 789; //  (default to null)

// Get user by ID
[apiInstance getUserByIdWith:id
              completionHandler: ^(UserBasicDTO output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenApiDefinition = require('open_api_definition');

// Create an instance of the API class
var api = new OpenApiDefinition.UserRestControllerApi()
var id = 789; // {Long} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new UserRestControllerApi();
            var id = 789;  // Long |  (default to null)

            try {
                // Get user by ID
                UserBasicDTO result = apiInstance.getUserById(id);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling UserRestControllerApi.getUserById: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\UserRestControllerApi();
$id = 789; // Long | 

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

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::UserRestControllerApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::UserRestControllerApi->new();
my $id = 789; # Long | 

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

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

# Create an instance of the API class
api_instance = openapi_client.UserRestControllerApi()
id = 789 # Long |  (default to null)

try:
    # Get user by ID
    api_response = api_instance.get_user_by_id(id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling UserRestControllerApi->getUserById: %s\n" % e)

extern crate UserRestControllerApi;

pub fn main() {
    let id = 789; // Long

    let mut context = UserRestControllerApi::Context::default();
    let result = client.getUserById(id, &context).wait();

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

Scopes

Parameters

Path parameters

Name	Description
id*	Long (int64) Required

Responses

Schema

Schema

updateUser

Update user details

/api/v1/users/{id}

Usage and SDK Samples

curl -X PUT \
 -H "Accept: */*" \
 -H "Content-Type: application/json" \
 "https://localhost:8443/api/v1/users/{id}" \
 -d '{
  "password" : "password",
  "address" : "address",
  "surname" : "surname",
  "userName" : "userName",
  "email" : "email"
}'

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

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

public class UserRestControllerApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        UserRestControllerApi apiInstance = new UserRestControllerApi();
        Long id = 789; // Long | 
        UserPostDTO userPostDTO = ; // UserPostDTO | 

        try {
            UserBasicDTO result = apiInstance.updateUser(id, userPostDTO);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling UserRestControllerApi#updateUser");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final Long id = new Long(); // Long | 
final UserPostDTO userPostDTO = new UserPostDTO(); // UserPostDTO | 

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

import org.openapitools.client.api.UserRestControllerApi;

public class UserRestControllerApiExample {
    public static void main(String[] args) {
        UserRestControllerApi apiInstance = new UserRestControllerApi();
        Long id = 789; // Long | 
        UserPostDTO userPostDTO = ; // UserPostDTO | 

        try {
            UserBasicDTO result = apiInstance.updateUser(id, userPostDTO);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling UserRestControllerApi#updateUser");
            e.printStackTrace();
        }
    }
}



// Create an instance of the API class
UserRestControllerApi *apiInstance = [[UserRestControllerApi alloc] init];
Long *id = 789; //  (default to null)
UserPostDTO *userPostDTO = ; // 

// Update user details
[apiInstance updateUserWith:id
    userPostDTO:userPostDTO
              completionHandler: ^(UserBasicDTO output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenApiDefinition = require('open_api_definition');

// Create an instance of the API class
var api = new OpenApiDefinition.UserRestControllerApi()
var id = 789; // {Long} 
var userPostDTO = ; // {UserPostDTO} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new UserRestControllerApi();
            var id = 789;  // Long |  (default to null)
            var userPostDTO = new UserPostDTO(); // UserPostDTO | 

            try {
                // Update user details
                UserBasicDTO result = apiInstance.updateUser(id, userPostDTO);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling UserRestControllerApi.updateUser: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\UserRestControllerApi();
$id = 789; // Long | 
$userPostDTO = ; // UserPostDTO | 

try {
    $result = $api_instance->updateUser($id, $userPostDTO);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling UserRestControllerApi->updateUser: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::UserRestControllerApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::UserRestControllerApi->new();
my $id = 789; # Long | 
my $userPostDTO = WWW::OPenAPIClient::Object::UserPostDTO->new(); # UserPostDTO | 

eval {
    my $result = $api_instance->updateUser(id => $id, userPostDTO => $userPostDTO);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling UserRestControllerApi->updateUser: $@\n";
}

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

# Create an instance of the API class
api_instance = openapi_client.UserRestControllerApi()
id = 789 # Long |  (default to null)
userPostDTO =  # UserPostDTO | 

try:
    # Update user details
    api_response = api_instance.update_user(id, userPostDTO)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling UserRestControllerApi->updateUser: %s\n" % e)

extern crate UserRestControllerApi;

pub fn main() {
    let id = 789; // Long
    let userPostDTO = ; // UserPostDTO

    let mut context = UserRestControllerApi::Context::default();
    let result = client.updateUser(id, userPostDTO, &context).wait();

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

Scopes

Parameters

Path parameters

Name	Description
id*	Long (int64) Required

Body parameters

Name	Description
userPostDTO *

Responses

Schema

Schema

Schema

uploadUserImage

Upload user profile image

/api/v1/users/{id}/image

Usage and SDK Samples

curl -X POST \
 -H "Accept: */*" \
 -H "Content-Type: application/json" \
 "https://localhost:8443/api/v1/users/{id}/image" \
 -d ''

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

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

public class UserRestControllerApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        UserRestControllerApi apiInstance = new UserRestControllerApi();
        Long id = 789; // Long | 
        UploadUserImageRequest uploadUserImageRequest = ; // UploadUserImageRequest | 

        try {
            ImageDTO result = apiInstance.uploadUserImage(id, uploadUserImageRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling UserRestControllerApi#uploadUserImage");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final Long id = new Long(); // Long | 
final UploadUserImageRequest uploadUserImageRequest = new UploadUserImageRequest(); // UploadUserImageRequest | 

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

import org.openapitools.client.api.UserRestControllerApi;

public class UserRestControllerApiExample {
    public static void main(String[] args) {
        UserRestControllerApi apiInstance = new UserRestControllerApi();
        Long id = 789; // Long | 
        UploadUserImageRequest uploadUserImageRequest = ; // UploadUserImageRequest | 

        try {
            ImageDTO result = apiInstance.uploadUserImage(id, uploadUserImageRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling UserRestControllerApi#uploadUserImage");
            e.printStackTrace();
        }
    }
}



// Create an instance of the API class
UserRestControllerApi *apiInstance = [[UserRestControllerApi alloc] init];
Long *id = 789; //  (default to null)
UploadUserImageRequest *uploadUserImageRequest = ; // 

// Upload user profile image
[apiInstance uploadUserImageWith:id
    uploadUserImageRequest:uploadUserImageRequest
              completionHandler: ^(ImageDTO output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenApiDefinition = require('open_api_definition');

// Create an instance of the API class
var api = new OpenApiDefinition.UserRestControllerApi()
var id = 789; // {Long} 
var uploadUserImageRequest = ; // {UploadUserImageRequest} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new UserRestControllerApi();
            var id = 789;  // Long |  (default to null)
            var uploadUserImageRequest = new UploadUserImageRequest(); // UploadUserImageRequest | 

            try {
                // Upload user profile image
                ImageDTO result = apiInstance.uploadUserImage(id, uploadUserImageRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling UserRestControllerApi.uploadUserImage: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\UserRestControllerApi();
$id = 789; // Long | 
$uploadUserImageRequest = ; // UploadUserImageRequest | 

try {
    $result = $api_instance->uploadUserImage($id, $uploadUserImageRequest);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling UserRestControllerApi->uploadUserImage: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::UserRestControllerApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::UserRestControllerApi->new();
my $id = 789; # Long | 
my $uploadUserImageRequest = WWW::OPenAPIClient::Object::UploadUserImageRequest->new(); # UploadUserImageRequest | 

eval {
    my $result = $api_instance->uploadUserImage(id => $id, uploadUserImageRequest => $uploadUserImageRequest);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling UserRestControllerApi->uploadUserImage: $@\n";
}

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

# Create an instance of the API class
api_instance = openapi_client.UserRestControllerApi()
id = 789 # Long |  (default to null)
uploadUserImageRequest =  # UploadUserImageRequest | 

try:
    # Upload user profile image
    api_response = api_instance.upload_user_image(id, uploadUserImageRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling UserRestControllerApi->uploadUserImage: %s\n" % e)

extern crate UserRestControllerApi;

pub fn main() {
    let id = 789; // Long
    let uploadUserImageRequest = ; // UploadUserImageRequest

    let mut context = UserRestControllerApi::Context::default();
    let result = client.uploadUserImage(id, uploadUserImageRequest, &context).wait();

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

Scopes

Parameters

Path parameters

Name	Description
id*	Long (int64) Required

Body parameters

Name	Description
uploadUserImageRequest *

Responses

Schema

Schema

OpenAPI definition

API and SDK Documentation

AdminRestController

getKpis

Usage and SDK Samples

Scopes

Parameters

Responses

getProductsStates

Usage and SDK Samples

Scopes

Parameters

Responses

getTopProductsGraphic

Usage and SDK Samples

Scopes

Parameters

Responses

ImageRestController

getImage

Usage and SDK Samples

Scopes

Parameters

Responses

getImageFile

Usage and SDK Samples

Scopes

Parameters

Responses

replaceImageFile

Usage and SDK Samples

Scopes

Parameters

Responses

LoginController

logOut

Usage and SDK Samples

Scopes

Parameters

Responses

login

Usage and SDK Samples

Scopes

Parameters

Responses

refreshToken

Usage and SDK Samples

Scopes

Parameters

Responses

OrderRestController

acceptOrder

Usage and SDK Samples

Scopes

Parameters

Responses

getAllOrderPdf

Usage and SDK Samples

Scopes

Parameters

Responses

getAllOrders

Usage and SDK Samples

Scopes

Parameters

Responses

getAllUserOrders

Usage and SDK Samples

Scopes

Parameters

Responses

getOrderPdf

Usage and SDK Samples

Scopes

Parameters

Responses

shoppingCartToOrder

Usage and SDK Samples

Scopes

Parameters