OpenAPI definition

ApiGraphsController

displayGraph

Get company statistics graph

Retrieve the company statistics data for graph display.

/api/v1/graphs/companyGraph

Usage and SDK Samples

curl -X GET \
 -H "Authorization: Bearer [[accessToken]]" \
 -H "Accept: */*" \
 "https://localhost:8443/api/v1/graphs/companyGraph"

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

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

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

        // Configure Bearer (JWT) access token for authorization: bearerAuth
        HttpBearerAuth bearerAuth = (HttpBearerAuth) defaultClient.getAuthentication("bearerAuth");
        bearerAuth.setBearerToken("BEARER TOKEN");

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

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();


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

import org.openapitools.client.api.ApiGraphsControllerApi;

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

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

Configuration *apiConfig = [Configuration sharedConfig];

// Configure Bearer (JWT) access token for authorization: bearerAuth
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

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

// Get company statistics graph
[apiInstance displayGraphWithCompletionHandler: 
              ^(array[CompanyStadsDTO] output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenApiDefinition = require('open_api_definition');
var defaultClient = OpenApiDefinition.ApiClient.instance;

// Configure Bearer (JWT) access token for authorization: bearerAuth
var bearerAuth = defaultClient.authentications['bearerAuth'];
bearerAuth.accessToken = "YOUR ACCESS TOKEN";

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

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

namespace Example
{
    public class displayGraphExample
    {
        public void main()
        {
            // Configure Bearer (JWT) access token for authorization: bearerAuth
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

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

            try {
                // Get company statistics graph
                array[CompanyStadsDTO] result = apiInstance.displayGraph();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ApiGraphsControllerApi.displayGraph: " + e.Message );
            }
        }
    }
}

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

// Configure Bearer (JWT) access token for authorization: bearerAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('', 'YOUR_ACCESS_TOKEN');

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

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

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

# Configure Bearer (JWT) access token for authorization: bearerAuth
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

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

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

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

# Configure Bearer (JWT) access token for authorization: bearerAuth
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

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

try:
    # Get company statistics graph
    api_response = api_instance.display_graph()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ApiGraphsControllerApi->displayGraph: %s\n" % e)

extern crate ApiGraphsControllerApi;

pub fn main() {

    let mut context = ApiGraphsControllerApi::Context::default();
    let result = client.displayGraph(&context).wait();

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

Scopes

Parameters

Responses

Schema

Schema

Schema

displayUserGraph

Get user historical orders graph

Retrieve the user's historical orders data for graph display.

/api/v1/graphs/userGraph

Usage and SDK Samples

curl -X GET \
 -H "Authorization: Bearer [[accessToken]]" \
 -H "Accept: */*" \
 "https://localhost:8443/api/v1/graphs/userGraph"

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

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

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

        // Configure Bearer (JWT) access token for authorization: bearerAuth
        HttpBearerAuth bearerAuth = (HttpBearerAuth) defaultClient.getAuthentication("bearerAuth");
        bearerAuth.setBearerToken("BEARER TOKEN");

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

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();


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

import org.openapitools.client.api.ApiGraphsControllerApi;

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

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

Configuration *apiConfig = [Configuration sharedConfig];

// Configure Bearer (JWT) access token for authorization: bearerAuth
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

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

// Get user historical orders graph
[apiInstance displayUserGraphWithCompletionHandler: 
              ^(array[Double] output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenApiDefinition = require('open_api_definition');
var defaultClient = OpenApiDefinition.ApiClient.instance;

// Configure Bearer (JWT) access token for authorization: bearerAuth
var bearerAuth = defaultClient.authentications['bearerAuth'];
bearerAuth.accessToken = "YOUR ACCESS TOKEN";

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

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

namespace Example
{
    public class displayUserGraphExample
    {
        public void main()
        {
            // Configure Bearer (JWT) access token for authorization: bearerAuth
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

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

            try {
                // Get user historical orders graph
                array[Double] result = apiInstance.displayUserGraph();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ApiGraphsControllerApi.displayUserGraph: " + e.Message );
            }
        }
    }
}

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

// Configure Bearer (JWT) access token for authorization: bearerAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('', 'YOUR_ACCESS_TOKEN');

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

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

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

# Configure Bearer (JWT) access token for authorization: bearerAuth
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

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

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

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

# Configure Bearer (JWT) access token for authorization: bearerAuth
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

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

try:
    # Get user historical orders graph
    api_response = api_instance.display_user_graph()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ApiGraphsControllerApi->displayUserGraph: %s\n" % e)

extern crate ApiGraphsControllerApi;

pub fn main() {

    let mut context = ApiGraphsControllerApi::Context::default();
    let result = client.displayUserGraph(&context).wait();

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

Scopes

Parameters

Responses

Schema

Schema

Schema

ApiProductController

acceptProduct

Accept product

/api/v1/products/accept

Usage and SDK Samples

curl -X PUT \
 -H "Authorization: Bearer [[accessToken]]" \
 -H "Accept: */*" \
 "https://localhost:8443/api/v1/products/accept?id=789"

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

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

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

        // Configure Bearer (JWT) access token for authorization: bearerAuth
        HttpBearerAuth bearerAuth = (HttpBearerAuth) defaultClient.getAuthentication("bearerAuth");
        bearerAuth.setBearerToken("BEARER TOKEN");

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

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

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

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

import org.openapitools.client.api.ApiProductControllerApi;

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

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

Configuration *apiConfig = [Configuration sharedConfig];

// Configure Bearer (JWT) access token for authorization: bearerAuth
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

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

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

var OpenApiDefinition = require('open_api_definition');
var defaultClient = OpenApiDefinition.ApiClient.instance;

// Configure Bearer (JWT) access token for authorization: bearerAuth
var bearerAuth = defaultClient.authentications['bearerAuth'];
bearerAuth.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new OpenApiDefinition.ApiProductControllerApi()
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.acceptProduct(id, callback);

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

namespace Example
{
    public class acceptProductExample
    {
        public void main()
        {
            // Configure Bearer (JWT) access token for authorization: bearerAuth
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

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

            try {
                // Accept product
                ProductDTO result = apiInstance.acceptProduct(id);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ApiProductControllerApi.acceptProduct: " + e.Message );
            }
        }
    }
}

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

// Configure Bearer (JWT) access token for authorization: bearerAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('', 'YOUR_ACCESS_TOKEN');

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

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

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

# Configure Bearer (JWT) access token for authorization: bearerAuth
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

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

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

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

# Configure Bearer (JWT) access token for authorization: bearerAuth
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

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

try:
    # Accept product
    api_response = api_instance.accept_product(id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ApiProductControllerApi->acceptProduct: %s\n" % e)

extern crate ApiProductControllerApi;

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

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

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

Scopes

Parameters

Query parameters

Name	Description
id*	Long (int64) Required

Responses

Schema

addViewsCount

Increment views count

/api/v1/products/addViewsCount

Usage and SDK Samples

curl -X PUT \
 -H "Authorization: Bearer [[accessToken]]" \
 -H "Accept: */*" \
 "https://localhost:8443/api/v1/products/addViewsCount?id=789"

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

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

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

        // Configure Bearer (JWT) access token for authorization: bearerAuth
        HttpBearerAuth bearerAuth = (HttpBearerAuth) defaultClient.getAuthentication("bearerAuth");
        bearerAuth.setBearerToken("BEARER TOKEN");

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

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

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

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

import org.openapitools.client.api.ApiProductControllerApi;

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

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

Configuration *apiConfig = [Configuration sharedConfig];

// Configure Bearer (JWT) access token for authorization: bearerAuth
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

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

// Increment views count
[apiInstance addViewsCountWith:id
              completionHandler: ^(ProductDTO output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenApiDefinition = require('open_api_definition');
var defaultClient = OpenApiDefinition.ApiClient.instance;

// Configure Bearer (JWT) access token for authorization: bearerAuth
var bearerAuth = defaultClient.authentications['bearerAuth'];
bearerAuth.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new OpenApiDefinition.ApiProductControllerApi()
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.addViewsCount(id, callback);

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

namespace Example
{
    public class addViewsCountExample
    {
        public void main()
        {
            // Configure Bearer (JWT) access token for authorization: bearerAuth
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

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

            try {
                // Increment views count
                ProductDTO result = apiInstance.addViewsCount(id);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ApiProductControllerApi.addViewsCount: " + e.Message );
            }
        }
    }
}

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

// Configure Bearer (JWT) access token for authorization: bearerAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('', 'YOUR_ACCESS_TOKEN');

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

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

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

# Configure Bearer (JWT) access token for authorization: bearerAuth
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

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

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

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

# Configure Bearer (JWT) access token for authorization: bearerAuth
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

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

try:
    # Increment views count
    api_response = api_instance.add_views_count(id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ApiProductControllerApi->addViewsCount: %s\n" % e)

extern crate ApiProductControllerApi;

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

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

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

Scopes

Parameters

Query parameters

Name	Description
id*	Long (int64) Required

Responses

Schema

createProduct

Create a new product

Create a new product with a given set of properties.

/api/v1/products

Usage and SDK Samples

curl -X POST \
 -H "Authorization: Bearer [[accessToken]]" \
 -H "Accept: application/json,*/*" \
 -H "Content-Type: application/json" \
 "https://localhost:8443/api/v1/products" \
 -d '{
  "date" : "2000-01-23T04:56:07.000+00:00",
  "imageBase64" : "imageBase64",
  "reviews" : [ {
    "comment" : "comment",
    "calification" : 3,
    "creationDate" : "2000-01-23T04:56:07.000+00:00",
    "reviewId" : 9,
    "username" : "username"
  }, {
    "comment" : "comment",
    "calification" : 3,
    "creationDate" : "2000-01-23T04:56:07.000+00:00",
    "reviewId" : 9,
    "username" : "username"
  } ],
  "price" : 5.637376656633329,
  "isAccepted" : true,
  "name" : "name",
  "description" : "description",
  "company" : "company",
  "id" : 5,
  "views_count" : 7,
  "type" : "type",
  "stock" : 2
}'

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

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

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

        // Configure Bearer (JWT) access token for authorization: bearerAuth
        HttpBearerAuth bearerAuth = (HttpBearerAuth) defaultClient.getAuthentication("bearerAuth");
        bearerAuth.setBearerToken("BEARER TOKEN");

        // Create an instance of the API class
        ApiProductControllerApi apiInstance = new ApiProductControllerApi();
        ProductDTO productDTO = ; // ProductDTO | 

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final ProductDTO productDTO = new ProductDTO(); // ProductDTO | 

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

import org.openapitools.client.api.ApiProductControllerApi;

public class ApiProductControllerApiExample {
    public static void main(String[] args) {
        ApiProductControllerApi apiInstance = new ApiProductControllerApi();
        ProductDTO productDTO = ; // ProductDTO | 

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

Configuration *apiConfig = [Configuration sharedConfig];

// Configure Bearer (JWT) access token for authorization: bearerAuth
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

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

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

var OpenApiDefinition = require('open_api_definition');
var defaultClient = OpenApiDefinition.ApiClient.instance;

// Configure Bearer (JWT) access token for authorization: bearerAuth
var bearerAuth = defaultClient.authentications['bearerAuth'];
bearerAuth.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new OpenApiDefinition.ApiProductControllerApi()
var productDTO = ; // {ProductDTO} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.createProduct(productDTO, 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()
        {
            // Configure Bearer (JWT) access token for authorization: bearerAuth
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new ApiProductControllerApi();
            var productDTO = new ProductDTO(); // ProductDTO | 

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

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

// Configure Bearer (JWT) access token for authorization: bearerAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('', 'YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ApiProductControllerApi();
$productDTO = ; // ProductDTO | 

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

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

# Configure Bearer (JWT) access token for authorization: bearerAuth
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ApiProductControllerApi->new();
my $productDTO = WWW::OPenAPIClient::Object::ProductDTO->new(); # ProductDTO | 

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

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

# Configure Bearer (JWT) access token for authorization: bearerAuth
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.ApiProductControllerApi()
productDTO =  # ProductDTO | 

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

extern crate ApiProductControllerApi;

pub fn main() {
    let productDTO = ; // ProductDTO

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

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

Scopes

Parameters

Body parameters

Name	Description
productDTO *

Responses

Schema

Schema

Schema

createProductImage

Upload product image

Upload a new image for a specific product.

/api/v1/products/{id}/image

Usage and SDK Samples

curl -X POST \
 -H "Authorization: Bearer [[accessToken]]" \
 -H "Accept: */*" \
 -H "Content-Type: application/json" \
 "https://localhost:8443/api/v1/products/{id}/image" \
 -d ''

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

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

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

        // Configure Bearer (JWT) access token for authorization: bearerAuth
        HttpBearerAuth bearerAuth = (HttpBearerAuth) defaultClient.getAuthentication("bearerAuth");
        bearerAuth.setBearerToken("BEARER TOKEN");

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

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

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

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

import org.openapitools.client.api.ApiProductControllerApi;

public class ApiProductControllerApiExample {
    public static void main(String[] args) {
        ApiProductControllerApi apiInstance = new ApiProductControllerApi();
        Long id = 789; // Long | 
        CreateProductImageRequest createProductImageRequest = ; // CreateProductImageRequest | 

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

Configuration *apiConfig = [Configuration sharedConfig];

// Configure Bearer (JWT) access token for authorization: bearerAuth
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

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

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

var OpenApiDefinition = require('open_api_definition');
var defaultClient = OpenApiDefinition.ApiClient.instance;

// Configure Bearer (JWT) access token for authorization: bearerAuth
var bearerAuth = defaultClient.authentications['bearerAuth'];
bearerAuth.accessToken = "YOUR ACCESS TOKEN";

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

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()
        {
            // Configure Bearer (JWT) access token for authorization: bearerAuth
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

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

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

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

// Configure Bearer (JWT) access token for authorization: bearerAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('', 'YOUR_ACCESS_TOKEN');

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

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

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

# Configure Bearer (JWT) access token for authorization: bearerAuth
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

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

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

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

# Configure Bearer (JWT) access token for authorization: bearerAuth
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

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

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

extern crate ApiProductControllerApi;

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

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

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

Scopes

Parameters

Path parameters

Name	Description
id*	Long (int64) Required

Body parameters

Name	Description
createProductImageRequest

Responses

Schema

Schema

Schema

Schema

deleteProduct

Delete a product

Delete a product by its unique ID.

/api/v1/products/{id}

Usage and SDK Samples

curl -X DELETE \
 -H "Authorization: Bearer [[accessToken]]" \
 -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.ApiProductControllerApi;

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

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

        // Configure Bearer (JWT) access token for authorization: bearerAuth
        HttpBearerAuth bearerAuth = (HttpBearerAuth) defaultClient.getAuthentication("bearerAuth");
        bearerAuth.setBearerToken("BEARER TOKEN");

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

        try {
            ProductDTO result = apiInstance.deleteProduct(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiProductControllerApi#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.ApiProductControllerApi;

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

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

Configuration *apiConfig = [Configuration sharedConfig];

// Configure Bearer (JWT) access token for authorization: bearerAuth
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

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

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

var OpenApiDefinition = require('open_api_definition');
var defaultClient = OpenApiDefinition.ApiClient.instance;

// Configure Bearer (JWT) access token for authorization: bearerAuth
var bearerAuth = defaultClient.authentications['bearerAuth'];
bearerAuth.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new OpenApiDefinition.ApiProductControllerApi()
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()
        {
            // Configure Bearer (JWT) access token for authorization: bearerAuth
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

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

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

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

// Configure Bearer (JWT) access token for authorization: bearerAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('', 'YOUR_ACCESS_TOKEN');

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

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

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

# Configure Bearer (JWT) access token for authorization: bearerAuth
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

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

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

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

# Configure Bearer (JWT) access token for authorization: bearerAuth
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.ApiProductControllerApi()
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 ApiProductControllerApi->deleteProduct: %s\n" % e)

extern crate ApiProductControllerApi;

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

    let mut context = ApiProductControllerApi::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

Schema

deleteProduct1

Delete product

/api/v1/products/delete

Usage and SDK Samples

curl -X DELETE \
 -H "Authorization: Bearer [[accessToken]]" \
 "https://localhost:8443/api/v1/products/delete?id=789"

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

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

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

        // Configure Bearer (JWT) access token for authorization: bearerAuth
        HttpBearerAuth bearerAuth = (HttpBearerAuth) defaultClient.getAuthentication("bearerAuth");
        bearerAuth.setBearerToken("BEARER TOKEN");

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

        try {
            apiInstance.deleteProduct1(id);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiProductControllerApi#deleteProduct1");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

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

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

import org.openapitools.client.api.ApiProductControllerApi;

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

        try {
            apiInstance.deleteProduct1(id);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiProductControllerApi#deleteProduct1");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure Bearer (JWT) access token for authorization: bearerAuth
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

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

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

var OpenApiDefinition = require('open_api_definition');
var defaultClient = OpenApiDefinition.ApiClient.instance;

// Configure Bearer (JWT) access token for authorization: bearerAuth
var bearerAuth = defaultClient.authentications['bearerAuth'];
bearerAuth.accessToken = "YOUR ACCESS TOKEN";

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

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

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

namespace Example
{
    public class deleteProduct1Example
    {
        public void main()
        {
            // Configure Bearer (JWT) access token for authorization: bearerAuth
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

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

            try {
                // Delete product
                apiInstance.deleteProduct1(id);
            } catch (Exception e) {
                Debug.Print("Exception when calling ApiProductControllerApi.deleteProduct1: " + e.Message );
            }
        }
    }
}

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

// Configure Bearer (JWT) access token for authorization: bearerAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('', 'YOUR_ACCESS_TOKEN');

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

try {
    $api_instance->deleteProduct1($id);
} catch (Exception $e) {
    echo 'Exception when calling ApiProductControllerApi->deleteProduct1: ', $e->getMessage(), PHP_EOL;
}
?>

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

# Configure Bearer (JWT) access token for authorization: bearerAuth
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

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

eval {
    $api_instance->deleteProduct1(id => $id);
};
if ($@) {
    warn "Exception when calling ApiProductControllerApi->deleteProduct1: $@\n";
}

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

# Configure Bearer (JWT) access token for authorization: bearerAuth
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

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

try:
    # Delete product
    api_instance.delete_product1(id)
except ApiException as e:
    print("Exception when calling ApiProductControllerApi->deleteProduct1: %s\n" % e)

extern crate ApiProductControllerApi;

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

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

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

Scopes

Parameters

Query parameters

Name	Description
id*	Long (int64) Required

Responses

deleteProductImage1

Delete product image

Delete the image of a specific product.

/api/v1/products/{id}/image

Usage and SDK Samples

curl -X DELETE \
 -H "Authorization: Bearer [[accessToken]]" \
 -H "Accept: */*" \
 "https://localhost:8443/api/v1/products/{id}/image"

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

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

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

        // Configure Bearer (JWT) access token for authorization: bearerAuth
        HttpBearerAuth bearerAuth = (HttpBearerAuth) defaultClient.getAuthentication("bearerAuth");
        bearerAuth.setBearerToken("BEARER TOKEN");

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

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

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

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

import org.openapitools.client.api.ApiProductControllerApi;

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

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

Configuration *apiConfig = [Configuration sharedConfig];

// Configure Bearer (JWT) access token for authorization: bearerAuth
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

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

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

var OpenApiDefinition = require('open_api_definition');
var defaultClient = OpenApiDefinition.ApiClient.instance;

// Configure Bearer (JWT) access token for authorization: bearerAuth
var bearerAuth = defaultClient.authentications['bearerAuth'];
bearerAuth.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new OpenApiDefinition.ApiProductControllerApi()
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.deleteProductImage1(id, callback);

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

namespace Example
{
    public class deleteProductImage1Example
    {
        public void main()
        {
            // Configure Bearer (JWT) access token for authorization: bearerAuth
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

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

            try {
                // Delete product image
                ProductDTO result = apiInstance.deleteProductImage1(id);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ApiProductControllerApi.deleteProductImage1: " + e.Message );
            }
        }
    }
}

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

// Configure Bearer (JWT) access token for authorization: bearerAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('', 'YOUR_ACCESS_TOKEN');

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

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

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

# Configure Bearer (JWT) access token for authorization: bearerAuth
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

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

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

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

# Configure Bearer (JWT) access token for authorization: bearerAuth
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

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

try:
    # Delete product image
    api_response = api_instance.delete_product_image1(id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ApiProductControllerApi->deleteProductImage1: %s\n" % e)

extern crate ApiProductControllerApi;

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

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

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

Scopes

Parameters

Path parameters

Name	Description
id*	Long (int64) Required

Responses

Schema

Schema

Schema

Schema

getAllProducts

Get all accepted products

Retrieve all accepted products without pagination.

/api/v1/products/all

Usage and SDK Samples

curl -X GET \
 -H "Authorization: Bearer [[accessToken]]" \
 -H "Accept: application/json" \
 "https://localhost:8443/api/v1/products/all?accepted=true"

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

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

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

        // Configure Bearer (JWT) access token for authorization: bearerAuth
        HttpBearerAuth bearerAuth = (HttpBearerAuth) defaultClient.getAuthentication("bearerAuth");
        bearerAuth.setBearerToken("BEARER TOKEN");

        // Create an instance of the API class
        ApiProductControllerApi apiInstance = new ApiProductControllerApi();
        Boolean accepted = true; // Boolean | 

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final Boolean accepted = new Boolean(); // Boolean | 

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

import org.openapitools.client.api.ApiProductControllerApi;

public class ApiProductControllerApiExample {
    public static void main(String[] args) {
        ApiProductControllerApi apiInstance = new ApiProductControllerApi();
        Boolean accepted = true; // Boolean | 

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

Configuration *apiConfig = [Configuration sharedConfig];

// Configure Bearer (JWT) access token for authorization: bearerAuth
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

// Create an instance of the API class
ApiProductControllerApi *apiInstance = [[ApiProductControllerApi alloc] init];
Boolean *accepted = true; //  (optional) (default to null)

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

var OpenApiDefinition = require('open_api_definition');
var defaultClient = OpenApiDefinition.ApiClient.instance;

// Configure Bearer (JWT) access token for authorization: bearerAuth
var bearerAuth = defaultClient.authentications['bearerAuth'];
bearerAuth.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new OpenApiDefinition.ApiProductControllerApi()
var opts = {
  'accepted': true // {Boolean} 
};

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

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

namespace Example
{
    public class getAllProductsExample
    {
        public void main()
        {
            // Configure Bearer (JWT) access token for authorization: bearerAuth
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new ApiProductControllerApi();
            var accepted = true;  // Boolean |  (optional)  (default to null)

            try {
                // Get all accepted products
                ProductDTO result = apiInstance.getAllProducts(accepted);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ApiProductControllerApi.getAllProducts: " + e.Message );
            }
        }
    }
}

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

// Configure Bearer (JWT) access token for authorization: bearerAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('', 'YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ApiProductControllerApi();
$accepted = true; // Boolean | 

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

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

# Configure Bearer (JWT) access token for authorization: bearerAuth
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ApiProductControllerApi->new();
my $accepted = true; # Boolean | 

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

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

# Configure Bearer (JWT) access token for authorization: bearerAuth
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.ApiProductControllerApi()
accepted = true # Boolean |  (optional) (default to null)

try:
    # Get all accepted products
    api_response = api_instance.get_all_products(accepted=accepted)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ApiProductControllerApi->getAllProducts: %s\n" % e)

extern crate ApiProductControllerApi;

pub fn main() {
    let accepted = true; // Boolean

    let mut context = ApiProductControllerApi::Context::default();
    let result = client.getAllProducts(accepted, &context).wait();

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

Scopes

Parameters

Query parameters

Name	Description
accepted	Boolean

Responses

Schema

getAllProductsByType

Get products by type

Retrieve products filtered by type.

/api/v1/products/type/all

Usage and SDK Samples

curl -X GET \
 -H "Authorization: Bearer [[accessToken]]" \
 -H "Accept: application/json" \
 "https://localhost:8443/api/v1/products/type/all?type=type_example"

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

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

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

        // Configure Bearer (JWT) access token for authorization: bearerAuth
        HttpBearerAuth bearerAuth = (HttpBearerAuth) defaultClient.getAuthentication("bearerAuth");
        bearerAuth.setBearerToken("BEARER TOKEN");

        // Create an instance of the API class
        ApiProductControllerApi apiInstance = new ApiProductControllerApi();
        String type = type_example; // String | 

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

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

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

import org.openapitools.client.api.ApiProductControllerApi;

public class ApiProductControllerApiExample {
    public static void main(String[] args) {
        ApiProductControllerApi apiInstance = new ApiProductControllerApi();
        String type = type_example; // String | 

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

Configuration *apiConfig = [Configuration sharedConfig];

// Configure Bearer (JWT) access token for authorization: bearerAuth
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

// Create an instance of the API class
ApiProductControllerApi *apiInstance = [[ApiProductControllerApi alloc] init];
String *type = type_example; //  (default to null)

// Get products by type
[apiInstance getAllProductsByTypeWith:type
              completionHandler: ^(ProductDTO output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenApiDefinition = require('open_api_definition');
var defaultClient = OpenApiDefinition.ApiClient.instance;

// Configure Bearer (JWT) access token for authorization: bearerAuth
var bearerAuth = defaultClient.authentications['bearerAuth'];
bearerAuth.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new OpenApiDefinition.ApiProductControllerApi()
var type = type_example; // {String} 

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

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

namespace Example
{
    public class getAllProductsByTypeExample
    {
        public void main()
        {
            // Configure Bearer (JWT) access token for authorization: bearerAuth
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new ApiProductControllerApi();
            var type = type_example;  // String |  (default to null)

            try {
                // Get products by type
                ProductDTO result = apiInstance.getAllProductsByType(type);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ApiProductControllerApi.getAllProductsByType: " + e.Message );
            }
        }
    }
}

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

// Configure Bearer (JWT) access token for authorization: bearerAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('', 'YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ApiProductControllerApi();
$type = type_example; // String | 

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

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

# Configure Bearer (JWT) access token for authorization: bearerAuth
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ApiProductControllerApi->new();
my $type = type_example; # String | 

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

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

# Configure Bearer (JWT) access token for authorization: bearerAuth
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.ApiProductControllerApi()
type = type_example # String |  (default to null)

try:
    # Get products by type
    api_response = api_instance.get_all_products_by_type(type)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ApiProductControllerApi->getAllProductsByType: %s\n" % e)

extern crate ApiProductControllerApi;

pub fn main() {
    let type = type_example; // String

    let mut context = ApiProductControllerApi::Context::default();
    let result = client.getAllProductsByType(type, &context).wait();

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

Scopes

Parameters

Query parameters

Name	Description
type*	String Required

Responses

Schema

getLastProducts

Get last products

Retrieve a list of the last added products.

/api/v1/products/lastProducts

Usage and SDK Samples

curl -X GET \
 -H "Authorization: Bearer [[accessToken]]" \
 -H "Accept: application/json" \
 "https://localhost:8443/api/v1/products/lastProducts"

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

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

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

        // Configure Bearer (JWT) access token for authorization: bearerAuth
        HttpBearerAuth bearerAuth = (HttpBearerAuth) defaultClient.getAuthentication("bearerAuth");
        bearerAuth.setBearerToken("BEARER TOKEN");

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

        try {
            Product result = apiInstance.getLastProducts();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiProductControllerApi#getLastProducts");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();


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

import org.openapitools.client.api.ApiProductControllerApi;

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

        try {
            Product result = apiInstance.getLastProducts();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiProductControllerApi#getLastProducts");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure Bearer (JWT) access token for authorization: bearerAuth
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

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

// Get last products
[apiInstance getLastProductsWithCompletionHandler: 
              ^(Product output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenApiDefinition = require('open_api_definition');
var defaultClient = OpenApiDefinition.ApiClient.instance;

// Configure Bearer (JWT) access token for authorization: bearerAuth
var bearerAuth = defaultClient.authentications['bearerAuth'];
bearerAuth.accessToken = "YOUR ACCESS TOKEN";

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

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

namespace Example
{
    public class getLastProductsExample
    {
        public void main()
        {
            // Configure Bearer (JWT) access token for authorization: bearerAuth
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

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

            try {
                // Get last products
                Product result = apiInstance.getLastProducts();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ApiProductControllerApi.getLastProducts: " + e.Message );
            }
        }
    }
}

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

// Configure Bearer (JWT) access token for authorization: bearerAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('', 'YOUR_ACCESS_TOKEN');

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

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

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

# Configure Bearer (JWT) access token for authorization: bearerAuth
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

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

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

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

# Configure Bearer (JWT) access token for authorization: bearerAuth
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

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

try:
    # Get last products
    api_response = api_instance.get_last_products()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ApiProductControllerApi->getLastProducts: %s\n" % e)

extern crate ApiProductControllerApi;

pub fn main() {

    let mut context = ApiProductControllerApi::Context::default();
    let result = client.getLastProducts(&context).wait();

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

Scopes

Parameters

Responses

Schema

getMostViewedProducts

Get most viewed products

Retrieve a list of the most viewed products.

/api/v1/products/mostViewedProducts

Usage and SDK Samples

curl -X GET \
 -H "Authorization: Bearer [[accessToken]]" \
 -H "Accept: application/json" \
 "https://localhost:8443/api/v1/products/mostViewedProducts"

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

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

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

        // Configure Bearer (JWT) access token for authorization: bearerAuth
        HttpBearerAuth bearerAuth = (HttpBearerAuth) defaultClient.getAuthentication("bearerAuth");
        bearerAuth.setBearerToken("BEARER TOKEN");

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

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();


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

import org.openapitools.client.api.ApiProductControllerApi;

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

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

Configuration *apiConfig = [Configuration sharedConfig];

// Configure Bearer (JWT) access token for authorization: bearerAuth
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

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

// Get most viewed products
[apiInstance getMostViewedProductsWithCompletionHandler: 
              ^(ProductDTO output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenApiDefinition = require('open_api_definition');
var defaultClient = OpenApiDefinition.ApiClient.instance;

// Configure Bearer (JWT) access token for authorization: bearerAuth
var bearerAuth = defaultClient.authentications['bearerAuth'];
bearerAuth.accessToken = "YOUR ACCESS TOKEN";

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

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

namespace Example
{
    public class getMostViewedProductsExample
    {
        public void main()
        {
            // Configure Bearer (JWT) access token for authorization: bearerAuth
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

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

            try {
                // Get most viewed products
                ProductDTO result = apiInstance.getMostViewedProducts();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ApiProductControllerApi.getMostViewedProducts: " + e.Message );
            }
        }
    }
}

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

// Configure Bearer (JWT) access token for authorization: bearerAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('', 'YOUR_ACCESS_TOKEN');

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

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

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

# Configure Bearer (JWT) access token for authorization: bearerAuth
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

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

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

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

# Configure Bearer (JWT) access token for authorization: bearerAuth
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

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

try:
    # Get most viewed products
    api_response = api_instance.get_most_viewed_products()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ApiProductControllerApi->getMostViewedProducts: %s\n" % e)

extern crate ApiProductControllerApi;

pub fn main() {

    let mut context = ApiProductControllerApi::Context::default();
    let result = client.getMostViewedProducts(&context).wait();

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

Scopes

Parameters

Responses

Schema

getProductById

Get product by ID

Retrieve a product by its unique ID.

/api/v1/products/{id}

Usage and SDK Samples

curl -X GET \
 -H "Authorization: Bearer [[accessToken]]" \
 -H "Accept: application/json,*/*" \
 "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.ApiProductControllerApi;

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

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

        // Configure Bearer (JWT) access token for authorization: bearerAuth
        HttpBearerAuth bearerAuth = (HttpBearerAuth) defaultClient.getAuthentication("bearerAuth");
        bearerAuth.setBearerToken("BEARER TOKEN");

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

        try {
            ProductDTO result = apiInstance.getProductById(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiProductControllerApi#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.ApiProductControllerApi;

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

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

Configuration *apiConfig = [Configuration sharedConfig];

// Configure Bearer (JWT) access token for authorization: bearerAuth
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

// Create an instance of the API class
ApiProductControllerApi *apiInstance = [[ApiProductControllerApi 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');
var defaultClient = OpenApiDefinition.ApiClient.instance;

// Configure Bearer (JWT) access token for authorization: bearerAuth
var bearerAuth = defaultClient.authentications['bearerAuth'];
bearerAuth.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new OpenApiDefinition.ApiProductControllerApi()
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()
        {
            // Configure Bearer (JWT) access token for authorization: bearerAuth
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new ApiProductControllerApi();
            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 ApiProductControllerApi.getProductById: " + e.Message );
            }
        }
    }
}

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

// Configure Bearer (JWT) access token for authorization: bearerAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('', 'YOUR_ACCESS_TOKEN');

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

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

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

# Configure Bearer (JWT) access token for authorization: bearerAuth
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

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

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

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

# Configure Bearer (JWT) access token for authorization: bearerAuth
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.ApiProductControllerApi()
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 ApiProductControllerApi->getProductById: %s\n" % e)

extern crate ApiProductControllerApi;

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

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

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

Scopes

Parameters

Path parameters

Name	Description
id*	Long (int64) Required

Responses

Schema

Schema

getProductImage

Get product image

Retrieve the image of a specific product by its ID.

/api/v1/products/{id}/image

Usage and SDK Samples

curl -X GET \
 -H "Authorization: Bearer [[accessToken]]" \
 -H "Accept: image/jpeg,*/*" \
 "https://localhost:8443/api/v1/products/{id}/image"

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

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

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

        // Configure Bearer (JWT) access token for authorization: bearerAuth
        HttpBearerAuth bearerAuth = (HttpBearerAuth) defaultClient.getAuthentication("bearerAuth");
        bearerAuth.setBearerToken("BEARER TOKEN");

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

        try {
            apiInstance.getProductImage(id);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiProductControllerApi#getProductImage");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

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

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

import org.openapitools.client.api.ApiProductControllerApi;

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

        try {
            apiInstance.getProductImage(id);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiProductControllerApi#getProductImage");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure Bearer (JWT) access token for authorization: bearerAuth
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

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

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

var OpenApiDefinition = require('open_api_definition');
var defaultClient = OpenApiDefinition.ApiClient.instance;

// Configure Bearer (JWT) access token for authorization: bearerAuth
var bearerAuth = defaultClient.authentications['bearerAuth'];
bearerAuth.accessToken = "YOUR ACCESS TOKEN";

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

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

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

namespace Example
{
    public class getProductImageExample
    {
        public void main()
        {
            // Configure Bearer (JWT) access token for authorization: bearerAuth
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

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

            try {
                // Get product image
                apiInstance.getProductImage(id);
            } catch (Exception e) {
                Debug.Print("Exception when calling ApiProductControllerApi.getProductImage: " + e.Message );
            }
        }
    }
}

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

// Configure Bearer (JWT) access token for authorization: bearerAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('', 'YOUR_ACCESS_TOKEN');

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

try {
    $api_instance->getProductImage($id);
} catch (Exception $e) {
    echo 'Exception when calling ApiProductControllerApi->getProductImage: ', $e->getMessage(), PHP_EOL;
}
?>

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

# Configure Bearer (JWT) access token for authorization: bearerAuth
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

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

eval {
    $api_instance->getProductImage(id => $id);
};
if ($@) {
    warn "Exception when calling ApiProductControllerApi->getProductImage: $@\n";
}

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

# Configure Bearer (JWT) access token for authorization: bearerAuth
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

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

try:
    # Get product image
    api_instance.get_product_image(id)
except ApiException as e:
    print("Exception when calling ApiProductControllerApi->getProductImage: %s\n" % e)

extern crate ApiProductControllerApi;

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

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

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

Scopes

Parameters

Path parameters

Name	Description
id*	Long (int64) Required

Responses

Schema

getProducts

Get products

Retrieve products based on filters.

/api/v1/products

Usage and SDK Samples

curl -X GET \
 -H "Authorization: Bearer [[accessToken]]" \
 -H "Accept: application/json,*/*" \
 "https://localhost:8443/api/v1/products?accepted=true&company=company_example&pageable="

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

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

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

        // Configure Bearer (JWT) access token for authorization: bearerAuth
        HttpBearerAuth bearerAuth = (HttpBearerAuth) defaultClient.getAuthentication("bearerAuth");
        bearerAuth.setBearerToken("BEARER TOKEN");

        // Create an instance of the API class
        ApiProductControllerApi apiInstance = new ApiProductControllerApi();
        Pageable pageable = ; // Pageable | 
        Boolean accepted = true; // Boolean | 
        String company = company_example; // String | 

        try {
            ProductDTO result = apiInstance.getProducts(pageable, accepted, company);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiProductControllerApi#getProducts");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final Pageable pageable = new Pageable(); // Pageable | 
final Boolean accepted = new Boolean(); // Boolean | 
final String company = new String(); // String | 

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

import org.openapitools.client.api.ApiProductControllerApi;

public class ApiProductControllerApiExample {
    public static void main(String[] args) {
        ApiProductControllerApi apiInstance = new ApiProductControllerApi();
        Pageable pageable = ; // Pageable | 
        Boolean accepted = true; // Boolean | 
        String company = company_example; // String | 

        try {
            ProductDTO result = apiInstance.getProducts(pageable, accepted, company);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiProductControllerApi#getProducts");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure Bearer (JWT) access token for authorization: bearerAuth
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

// Create an instance of the API class
ApiProductControllerApi *apiInstance = [[ApiProductControllerApi alloc] init];
Pageable *pageable = ; //  (default to null)
Boolean *accepted = true; //  (optional) (default to null)
String *company = company_example; //  (optional) (default to null)

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

var OpenApiDefinition = require('open_api_definition');
var defaultClient = OpenApiDefinition.ApiClient.instance;

// Configure Bearer (JWT) access token for authorization: bearerAuth
var bearerAuth = defaultClient.authentications['bearerAuth'];
bearerAuth.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new OpenApiDefinition.ApiProductControllerApi()
var pageable = ; // {Pageable} 
var opts = {
  'accepted': true, // {Boolean} 
  'company': company_example // {String} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getProducts(pageable, opts, 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()
        {
            // Configure Bearer (JWT) access token for authorization: bearerAuth
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new ApiProductControllerApi();
            var pageable = new Pageable(); // Pageable |  (default to null)
            var accepted = true;  // Boolean |  (optional)  (default to null)
            var company = company_example;  // String |  (optional)  (default to null)

            try {
                // Get products
                ProductDTO result = apiInstance.getProducts(pageable, accepted, company);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ApiProductControllerApi.getProducts: " + e.Message );
            }
        }
    }
}

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

// Configure Bearer (JWT) access token for authorization: bearerAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('', 'YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ApiProductControllerApi();
$pageable = ; // Pageable | 
$accepted = true; // Boolean | 
$company = company_example; // String | 

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

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

# Configure Bearer (JWT) access token for authorization: bearerAuth
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ApiProductControllerApi->new();
my $pageable = ; # Pageable | 
my $accepted = true; # Boolean | 
my $company = company_example; # String | 

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

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

# Configure Bearer (JWT) access token for authorization: bearerAuth
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.ApiProductControllerApi()
pageable =  # Pageable |  (default to null)
accepted = true # Boolean |  (optional) (default to null)
company = company_example # String |  (optional) (default to null)

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

extern crate ApiProductControllerApi;

pub fn main() {
    let pageable = ; // Pageable
    let accepted = true; // Boolean
    let company = company_example; // String

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

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

Scopes

Parameters

Query parameters

Name	Description
accepted	Boolean
company	String
pageable*	Pageable Required

Responses

Schema

Schema

getProductsByType

Get products by type

Retrieve products filtered by type.

/api/v1/products/type

Usage and SDK Samples

curl -X GET \
 -H "Authorization: Bearer [[accessToken]]" \
 -H "Accept: application/json" \
 "https://localhost:8443/api/v1/products/type?type=type_example&pageable="

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

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

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

        // Configure Bearer (JWT) access token for authorization: bearerAuth
        HttpBearerAuth bearerAuth = (HttpBearerAuth) defaultClient.getAuthentication("bearerAuth");
        bearerAuth.setBearerToken("BEARER TOKEN");

        // Create an instance of the API class
        ApiProductControllerApi apiInstance = new ApiProductControllerApi();
        String type = type_example; // String | 
        Pageable pageable = ; // Pageable | 

        try {
            ProductDTO result = apiInstance.getProductsByType(type, pageable);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiProductControllerApi#getProductsByType");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

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

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

import org.openapitools.client.api.ApiProductControllerApi;

public class ApiProductControllerApiExample {
    public static void main(String[] args) {
        ApiProductControllerApi apiInstance = new ApiProductControllerApi();
        String type = type_example; // String | 
        Pageable pageable = ; // Pageable | 

        try {
            ProductDTO result = apiInstance.getProductsByType(type, pageable);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiProductControllerApi#getProductsByType");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure Bearer (JWT) access token for authorization: bearerAuth
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

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

// Get products by type
[apiInstance getProductsByTypeWith:type
    pageable:pageable
              completionHandler: ^(ProductDTO output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenApiDefinition = require('open_api_definition');
var defaultClient = OpenApiDefinition.ApiClient.instance;

// Configure Bearer (JWT) access token for authorization: bearerAuth
var bearerAuth = defaultClient.authentications['bearerAuth'];
bearerAuth.accessToken = "YOUR ACCESS TOKEN";

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

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

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

namespace Example
{
    public class getProductsByTypeExample
    {
        public void main()
        {
            // Configure Bearer (JWT) access token for authorization: bearerAuth
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

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

            try {
                // Get products by type
                ProductDTO result = apiInstance.getProductsByType(type, pageable);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ApiProductControllerApi.getProductsByType: " + e.Message );
            }
        }
    }
}

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

// Configure Bearer (JWT) access token for authorization: bearerAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('', 'YOUR_ACCESS_TOKEN');

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

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

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

# Configure Bearer (JWT) access token for authorization: bearerAuth
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

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

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

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

# Configure Bearer (JWT) access token for authorization: bearerAuth
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

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

try:
    # Get products by type
    api_response = api_instance.get_products_by_type(type, pageable)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ApiProductControllerApi->getProductsByType: %s\n" % e)

extern crate ApiProductControllerApi;

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

    let mut context = ApiProductControllerApi::Context::default();
    let result = client.getProductsByType(type, pageable, &context).wait();

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

Scopes

Parameters

Query parameters

Name	Description
type*	String Required
pageable*	Pageable Required

Responses

Schema

replaceProductImage1

Replace product image

Replace the existing image of a product with a new one.

/api/v1/products/{id}/image

Usage and SDK Samples

curl -X PUT \
 -H "Authorization: Bearer [[accessToken]]" \
 -H "Accept: */*" \
 -H "Content-Type: application/json" \
 "https://localhost:8443/api/v1/products/{id}/image" \
 -d ''

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

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

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

        // Configure Bearer (JWT) access token for authorization: bearerAuth
        HttpBearerAuth bearerAuth = (HttpBearerAuth) defaultClient.getAuthentication("bearerAuth");
        bearerAuth.setBearerToken("BEARER TOKEN");

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

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

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

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

import org.openapitools.client.api.ApiProductControllerApi;

public class ApiProductControllerApiExample {
    public static void main(String[] args) {
        ApiProductControllerApi apiInstance = new ApiProductControllerApi();
        Long id = 789; // Long | 
        ReplaceProductImage1Request replaceProductImage1Request = ; // ReplaceProductImage1Request | 

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

Configuration *apiConfig = [Configuration sharedConfig];

// Configure Bearer (JWT) access token for authorization: bearerAuth
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

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

// Replace product image
[apiInstance replaceProductImage1With:id
    replaceProductImage1Request:replaceProductImage1Request
              completionHandler: ^(ProductDTO output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenApiDefinition = require('open_api_definition');
var defaultClient = OpenApiDefinition.ApiClient.instance;

// Configure Bearer (JWT) access token for authorization: bearerAuth
var bearerAuth = defaultClient.authentications['bearerAuth'];
bearerAuth.accessToken = "YOUR ACCESS TOKEN";

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

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

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

namespace Example
{
    public class replaceProductImage1Example
    {
        public void main()
        {
            // Configure Bearer (JWT) access token for authorization: bearerAuth
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

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

            try {
                // Replace product image
                ProductDTO result = apiInstance.replaceProductImage1(id, replaceProductImage1Request);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ApiProductControllerApi.replaceProductImage1: " + e.Message );
            }
        }
    }
}

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

// Configure Bearer (JWT) access token for authorization: bearerAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('', 'YOUR_ACCESS_TOKEN');

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

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

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

# Configure Bearer (JWT) access token for authorization: bearerAuth
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

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

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

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

# Configure Bearer (JWT) access token for authorization: bearerAuth
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

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

try:
    # Replace product image
    api_response = api_instance.replace_product_image1(id, replaceProductImage1Request=replaceProductImage1Request)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ApiProductControllerApi->replaceProductImage1: %s\n" % e)

extern crate ApiProductControllerApi;

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

    let mut context = ApiProductControllerApi::Context::default();
    let result = client.replaceProductImage1(id, replaceProductImage1Request, &context).wait();

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

Scopes

Parameters

Path parameters

Name	Description
id*	Long (int64) Required

Body parameters

Name	Description
replaceProductImage1Request

Responses

Schema

Schema

Schema

Schema

searchProducts

Search products

/api/v1/products/search

Usage and SDK Samples

curl -X GET \
 -H "Authorization: Bearer [[accessToken]]" \
 -H "Accept: */*" \
 "https://localhost:8443/api/v1/products/search?search_text=searchText_example&type=type_example"

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

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

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

        // Configure Bearer (JWT) access token for authorization: bearerAuth
        HttpBearerAuth bearerAuth = (HttpBearerAuth) defaultClient.getAuthentication("bearerAuth");
        bearerAuth.setBearerToken("BEARER TOKEN");

        // Create an instance of the API class
        ApiProductControllerApi apiInstance = new ApiProductControllerApi();
        String searchText = searchText_example; // String | 
        String type = type_example; // String | 

        try {
            array[SearchProductDTO] result = apiInstance.searchProducts(searchText, type);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiProductControllerApi#searchProducts");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String searchText = new String(); // String | 
final String type = new String(); // String | 

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

import org.openapitools.client.api.ApiProductControllerApi;

public class ApiProductControllerApiExample {
    public static void main(String[] args) {
        ApiProductControllerApi apiInstance = new ApiProductControllerApi();
        String searchText = searchText_example; // String | 
        String type = type_example; // String | 

        try {
            array[SearchProductDTO] result = apiInstance.searchProducts(searchText, type);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiProductControllerApi#searchProducts");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure Bearer (JWT) access token for authorization: bearerAuth
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

// Create an instance of the API class
ApiProductControllerApi *apiInstance = [[ApiProductControllerApi alloc] init];
String *searchText = searchText_example; //  (optional) (default to null)
String *type = type_example; //  (optional) (default to all)

// Search products
[apiInstance searchProductsWith:searchText
    type:type
              completionHandler: ^(array[SearchProductDTO] output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenApiDefinition = require('open_api_definition');
var defaultClient = OpenApiDefinition.ApiClient.instance;

// Configure Bearer (JWT) access token for authorization: bearerAuth
var bearerAuth = defaultClient.authentications['bearerAuth'];
bearerAuth.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new OpenApiDefinition.ApiProductControllerApi()
var opts = {
  'searchText': searchText_example, // {String} 
  'type': type_example // {String} 
};

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

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

namespace Example
{
    public class searchProductsExample
    {
        public void main()
        {
            // Configure Bearer (JWT) access token for authorization: bearerAuth
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new ApiProductControllerApi();
            var searchText = searchText_example;  // String |  (optional)  (default to null)
            var type = type_example;  // String |  (optional)  (default to all)

            try {
                // Search products
                array[SearchProductDTO] result = apiInstance.searchProducts(searchText, type);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ApiProductControllerApi.searchProducts: " + e.Message );
            }
        }
    }
}

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

// Configure Bearer (JWT) access token for authorization: bearerAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('', 'YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ApiProductControllerApi();
$searchText = searchText_example; // String | 
$type = type_example; // String | 

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

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

# Configure Bearer (JWT) access token for authorization: bearerAuth
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ApiProductControllerApi->new();
my $searchText = searchText_example; # String | 
my $type = type_example; # String | 

eval {
    my $result = $api_instance->searchProducts(searchText => $searchText, type => $type);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ApiProductControllerApi->searchProducts: $@\n";
}

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

# Configure Bearer (JWT) access token for authorization: bearerAuth
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.ApiProductControllerApi()
searchText = searchText_example # String |  (optional) (default to null)
type = type_example # String |  (optional) (default to all)

try:
    # Search products
    api_response = api_instance.search_products(searchText=searchText, type=type)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ApiProductControllerApi->searchProducts: %s\n" % e)

extern crate ApiProductControllerApi;

pub fn main() {
    let searchText = searchText_example; // String
    let type = type_example; // String

    let mut context = ApiProductControllerApi::Context::default();
    let result = client.searchProducts(searchText, type, &context).wait();

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

Scopes

Parameters

Query parameters

Name	Description
search_text	String
type	String

Responses

Schema

updateProduct

Update a product

Update the details of an existing product.

/api/v1/products/{id}

Usage and SDK Samples

curl -X PUT \
 -H "Authorization: Bearer [[accessToken]]" \
 -H "Accept: application/json,*/*" \
 -H "Content-Type: application/json" \
 "https://localhost:8443/api/v1/products/{id}" \
 -d '{
  "date" : "2000-01-23T04:56:07.000+00:00",
  "imageBase64" : "imageBase64",
  "reviews" : [ {
    "comment" : "comment",
    "calification" : 3,
    "creationDate" : "2000-01-23T04:56:07.000+00:00",
    "reviewId" : 9,
    "username" : "username"
  }, {
    "comment" : "comment",
    "calification" : 3,
    "creationDate" : "2000-01-23T04:56:07.000+00:00",
    "reviewId" : 9,
    "username" : "username"
  } ],
  "price" : 5.637376656633329,
  "isAccepted" : true,
  "name" : "name",
  "description" : "description",
  "company" : "company",
  "id" : 5,
  "views_count" : 7,
  "type" : "type",
  "stock" : 2
}'

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

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

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

        // Configure Bearer (JWT) access token for authorization: bearerAuth
        HttpBearerAuth bearerAuth = (HttpBearerAuth) defaultClient.getAuthentication("bearerAuth");
        bearerAuth.setBearerToken("BEARER TOKEN");

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

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

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

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

import org.openapitools.client.api.ApiProductControllerApi;

public class ApiProductControllerApiExample {
    public static void main(String[] args) {
        ApiProductControllerApi apiInstance = new ApiProductControllerApi();
        Long id = 789; // Long | 
        ProductDTO productDTO = ; // ProductDTO | 

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

Configuration *apiConfig = [Configuration sharedConfig];

// Configure Bearer (JWT) access token for authorization: bearerAuth
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

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

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

var OpenApiDefinition = require('open_api_definition');
var defaultClient = OpenApiDefinition.ApiClient.instance;

// Configure Bearer (JWT) access token for authorization: bearerAuth
var bearerAuth = defaultClient.authentications['bearerAuth'];
bearerAuth.accessToken = "YOUR ACCESS TOKEN";

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

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.updateProduct(id, productDTO, 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()
        {
            // Configure Bearer (JWT) access token for authorization: bearerAuth
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

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

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

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

// Configure Bearer (JWT) access token for authorization: bearerAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('', 'YOUR_ACCESS_TOKEN');

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

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

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

# Configure Bearer (JWT) access token for authorization: bearerAuth
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

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

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

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

# Configure Bearer (JWT) access token for authorization: bearerAuth
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

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

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

extern crate ApiProductControllerApi;

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

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

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

Scopes

Parameters

Path parameters

Name	Description
id*	Long (int64) Required

Body parameters

Name	Description
productDTO *

Responses

Schema

Schema

Schema

ApiReviewsController

getReviewsByProductId

Get all reviews of a product

Retrieve all reviews for a specific product by its ID.

/api/v1/reviews/{id}

Usage and SDK Samples

curl -X GET \
 -H "Authorization: Bearer [[accessToken]]" \
 -H "Accept: application/json,*/*" \
 "https://localhost:8443/api/v1/reviews/{id}"

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

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

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

        // Configure Bearer (JWT) access token for authorization: bearerAuth
        HttpBearerAuth bearerAuth = (HttpBearerAuth) defaultClient.getAuthentication("bearerAuth");
        bearerAuth.setBearerToken("BEARER TOKEN");

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

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

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

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

import org.openapitools.client.api.ApiReviewsControllerApi;

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

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

Configuration *apiConfig = [Configuration sharedConfig];

// Configure Bearer (JWT) access token for authorization: bearerAuth
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

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

// Get all reviews of a product
[apiInstance getReviewsByProductIdWith:id
              completionHandler: ^(ReviewDTO output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenApiDefinition = require('open_api_definition');
var defaultClient = OpenApiDefinition.ApiClient.instance;

// Configure Bearer (JWT) access token for authorization: bearerAuth
var bearerAuth = defaultClient.authentications['bearerAuth'];
bearerAuth.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new OpenApiDefinition.ApiReviewsControllerApi()
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.getReviewsByProductId(id, callback);

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

namespace Example
{
    public class getReviewsByProductIdExample
    {
        public void main()
        {
            // Configure Bearer (JWT) access token for authorization: bearerAuth
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

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

            try {
                // Get all reviews of a product
                ReviewDTO result = apiInstance.getReviewsByProductId(id);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ApiReviewsControllerApi.getReviewsByProductId: " + e.Message );
            }
        }
    }
}

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

// Configure Bearer (JWT) access token for authorization: bearerAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('', 'YOUR_ACCESS_TOKEN');

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

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

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

# Configure Bearer (JWT) access token for authorization: bearerAuth
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

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

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

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

# Configure Bearer (JWT) access token for authorization: bearerAuth
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

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

try:
    # Get all reviews of a product
    api_response = api_instance.get_reviews_by_product_id(id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ApiReviewsControllerApi->getReviewsByProductId: %s\n" % e)

extern crate ApiReviewsControllerApi;

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

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

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

Scopes

Parameters

Path parameters

Name	Description
id*	Long (int64) Required

Responses

Schema

Schema

getReviewsOfAProductById

Get a specific review of a product

Retrieve a specific review for a product by its ID and review ID.

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

Usage and SDK Samples

curl -X GET \
 -H "Authorization: Bearer [[accessToken]]" \
 -H "Accept: application/json,*/*" \
 "https://localhost:8443/api/v1/reviews/{productId}/{reviewId}"

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

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

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

        // Configure Bearer (JWT) access token for authorization: bearerAuth
        HttpBearerAuth bearerAuth = (HttpBearerAuth) defaultClient.getAuthentication("bearerAuth");
        bearerAuth.setBearerToken("BEARER TOKEN");

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

        try {
            ReviewDTO result = apiInstance.getReviewsOfAProductById(productId, reviewId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiReviewsControllerApi#getReviewsOfAProductById");
            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.getReviewsOfAProductById(productId, reviewId);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->getReviewsOfAProductById: $e\n');
}

import org.openapitools.client.api.ApiReviewsControllerApi;

public class ApiReviewsControllerApiExample {
    public static void main(String[] args) {
        ApiReviewsControllerApi apiInstance = new ApiReviewsControllerApi();
        Long productId = 789; // Long | 
        Long reviewId = 789; // Long | 

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

Configuration *apiConfig = [Configuration sharedConfig];

// Configure Bearer (JWT) access token for authorization: bearerAuth
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

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

// Get a specific review of a product
[apiInstance getReviewsOfAProductByIdWith:productId
    reviewId:reviewId
              completionHandler: ^(ReviewDTO output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenApiDefinition = require('open_api_definition');
var defaultClient = OpenApiDefinition.ApiClient.instance;

// Configure Bearer (JWT) access token for authorization: bearerAuth
var bearerAuth = defaultClient.authentications['bearerAuth'];
bearerAuth.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new OpenApiDefinition.ApiReviewsControllerApi()
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.getReviewsOfAProductById(productId, reviewId, callback);

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

namespace Example
{
    public class getReviewsOfAProductByIdExample
    {
        public void main()
        {
            // Configure Bearer (JWT) access token for authorization: bearerAuth
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

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

            try {
                // Get a specific review of a product
                ReviewDTO result = apiInstance.getReviewsOfAProductById(productId, reviewId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ApiReviewsControllerApi.getReviewsOfAProductById: " + e.Message );
            }
        }
    }
}

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

// Configure Bearer (JWT) access token for authorization: bearerAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('', 'YOUR_ACCESS_TOKEN');

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

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

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

# Configure Bearer (JWT) access token for authorization: bearerAuth
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

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

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

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

# Configure Bearer (JWT) access token for authorization: bearerAuth
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

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

try:
    # Get a specific review of a product
    api_response = api_instance.get_reviews_of_a_product_by_id(productId, reviewId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ApiReviewsControllerApi->getReviewsOfAProductById: %s\n" % e)

extern crate ApiReviewsControllerApi;

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

    let mut context = ApiReviewsControllerApi::Context::default();
    let result = client.getReviewsOfAProductById(productId, reviewId, &context).wait();

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

Scopes

Parameters

Path parameters

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

Responses

Schema

Schema

postNewReview

Post a new review for a product

Add a new review to a product.

/api/v1/reviews/{id}

Usage and SDK Samples

curl -X POST \
 -H "Authorization: Bearer [[accessToken]]" \
 -H "Accept: application/json,*/*" \
 -H "Content-Type: application/json" \
 "https://localhost:8443/api/v1/reviews/{id}" \
 -d '{
  "comment" : "comment",
  "calification" : 4,
  "creationDate" : "2000-01-23",
  "reviewId" : 2,
  "username" : "username"
}'

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

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

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

        // Configure Bearer (JWT) access token for authorization: bearerAuth
        HttpBearerAuth bearerAuth = (HttpBearerAuth) defaultClient.getAuthentication("bearerAuth");
        bearerAuth.setBearerToken("BEARER TOKEN");

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

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

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

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

import org.openapitools.client.api.ApiReviewsControllerApi;

public class ApiReviewsControllerApiExample {
    public static void main(String[] args) {
        ApiReviewsControllerApi apiInstance = new ApiReviewsControllerApi();
        Long id = 789; // Long | 
        ReviewDTO reviewDTO = ; // ReviewDTO | 

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

Configuration *apiConfig = [Configuration sharedConfig];

// Configure Bearer (JWT) access token for authorization: bearerAuth
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

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

// Post a new review for a product
[apiInstance postNewReviewWith:id
    reviewDTO:reviewDTO
              completionHandler: ^(ReviewDTO output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenApiDefinition = require('open_api_definition');
var defaultClient = OpenApiDefinition.ApiClient.instance;

// Configure Bearer (JWT) access token for authorization: bearerAuth
var bearerAuth = defaultClient.authentications['bearerAuth'];
bearerAuth.accessToken = "YOUR ACCESS TOKEN";

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

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

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

namespace Example
{
    public class postNewReviewExample
    {
        public void main()
        {
            // Configure Bearer (JWT) access token for authorization: bearerAuth
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

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

            try {
                // Post a new review for a product
                ReviewDTO result = apiInstance.postNewReview(id, reviewDTO);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ApiReviewsControllerApi.postNewReview: " + e.Message );
            }
        }
    }
}

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

// Configure Bearer (JWT) access token for authorization: bearerAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('', 'YOUR_ACCESS_TOKEN');

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

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

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

# Configure Bearer (JWT) access token for authorization: bearerAuth
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

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

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

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

# Configure Bearer (JWT) access token for authorization: bearerAuth
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

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

try:
    # Post a new review for a product
    api_response = api_instance.post_new_review(id, reviewDTO)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ApiReviewsControllerApi->postNewReview: %s\n" % e)

extern crate ApiReviewsControllerApi;

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

    let mut context = ApiReviewsControllerApi::Context::default();
    let result = client.postNewReview(id, reviewDTO, &context).wait();

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

Scopes

Parameters

Path parameters

Name	Description
id*	Long (int64) Required

Body parameters

Name	Description
reviewDTO *

Responses

Schema

Schema

Schema

Schema

ApiShoppingCartController

addProductToCart

Add product to shopping cart

Add a product to the shopping cart of a specific user.

/api/v1/users/shoppingcarts/{productId}

Usage and SDK Samples

curl -X POST \
 -H "Authorization: Bearer [[accessToken]]" \
 -H "Accept: application/json,*/*" \
 "https://localhost:8443/api/v1/users/shoppingcarts/{productId}?id=789"

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

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

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

        // Configure Bearer (JWT) access token for authorization: bearerAuth
        HttpBearerAuth bearerAuth = (HttpBearerAuth) defaultClient.getAuthentication("bearerAuth");
        bearerAuth.setBearerToken("BEARER TOKEN");

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

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

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

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

import org.openapitools.client.api.ApiShoppingCartControllerApi;

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

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

Configuration *apiConfig = [Configuration sharedConfig];

// Configure Bearer (JWT) access token for authorization: bearerAuth
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

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

// Add product to shopping cart
[apiInstance addProductToCartWith:id
    productId:productId
              completionHandler: ^(ProductDTO output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenApiDefinition = require('open_api_definition');
var defaultClient = OpenApiDefinition.ApiClient.instance;

// Configure Bearer (JWT) access token for authorization: bearerAuth
var bearerAuth = defaultClient.authentications['bearerAuth'];
bearerAuth.accessToken = "YOUR ACCESS TOKEN";

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

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.addProductToCart(id, productId, 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()
        {
            // Configure Bearer (JWT) access token for authorization: bearerAuth
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

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

            try {
                // Add product to shopping cart
                ProductDTO result = apiInstance.addProductToCart(id, productId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ApiShoppingCartControllerApi.addProductToCart: " + e.Message );
            }
        }
    }
}

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

// Configure Bearer (JWT) access token for authorization: bearerAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('', 'YOUR_ACCESS_TOKEN');

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

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

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

# Configure Bearer (JWT) access token for authorization: bearerAuth
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

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

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

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

# Configure Bearer (JWT) access token for authorization: bearerAuth
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

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

try:
    # Add product to shopping cart
    api_response = api_instance.add_product_to_cart(id, productId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ApiShoppingCartControllerApi->addProductToCart: %s\n" % e)

extern crate ApiShoppingCartControllerApi;

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

    let mut context = ApiShoppingCartControllerApi::Context::default();
    let result = client.addProductToCart(id, productId, &context).wait();

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

Scopes

Parameters

Path parameters

Name	Description
productId*	Long (int64) Required

Query parameters

Name	Description
id*	Long (int64) Required

Responses

Schema

Schema

Schema

getShoppingCart

Get shopping cart of a user

Retrieve the shopping cart details of a specific user.

/api/v1/users/shoppingcarts

Usage and SDK Samples

curl -X GET \
 -H "Authorization: Bearer [[accessToken]]" \
 -H "Accept: application/json,*/*" \
 "https://localhost:8443/api/v1/users/shoppingcarts?id=789"

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

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

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

        // Configure Bearer (JWT) access token for authorization: bearerAuth
        HttpBearerAuth bearerAuth = (HttpBearerAuth) defaultClient.getAuthentication("bearerAuth");
        bearerAuth.setBearerToken("BEARER TOKEN");

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

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

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

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

import org.openapitools.client.api.ApiShoppingCartControllerApi;

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

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

Configuration *apiConfig = [Configuration sharedConfig];

// Configure Bearer (JWT) access token for authorization: bearerAuth
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

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

// Get shopping cart of a user
[apiInstance getShoppingCartWith:id
              completionHandler: ^(ShoppingCartDTO output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenApiDefinition = require('open_api_definition');
var defaultClient = OpenApiDefinition.ApiClient.instance;

// Configure Bearer (JWT) access token for authorization: bearerAuth
var bearerAuth = defaultClient.authentications['bearerAuth'];
bearerAuth.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new OpenApiDefinition.ApiShoppingCartControllerApi()
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.getShoppingCart(id, callback);

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

namespace Example
{
    public class getShoppingCartExample
    {
        public void main()
        {
            // Configure Bearer (JWT) access token for authorization: bearerAuth
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

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

            try {
                // Get shopping cart of a user
                ShoppingCartDTO result = apiInstance.getShoppingCart(id);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ApiShoppingCartControllerApi.getShoppingCart: " + e.Message );
            }
        }
    }
}

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

// Configure Bearer (JWT) access token for authorization: bearerAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('', 'YOUR_ACCESS_TOKEN');

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

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

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

# Configure Bearer (JWT) access token for authorization: bearerAuth
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

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

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

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

# Configure Bearer (JWT) access token for authorization: bearerAuth
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

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

try:
    # Get shopping cart of a user
    api_response = api_instance.get_shopping_cart(id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ApiShoppingCartControllerApi->getShoppingCart: %s\n" % e)

extern crate ApiShoppingCartControllerApi;

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

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

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

Scopes

Parameters

Query parameters

Name	Description
id*	Long (int64) Required

Responses

Schema

Schema

Schema

payment

Process payment for shopping cart

Process payment for the items in the shopping cart.

/api/v1/users/shoppingcarts/payment

Usage and SDK Samples

curl -X POST \
 -H "Authorization: Bearer [[accessToken]]" \
 -H "Accept: */*" \
 "https://localhost:8443/api/v1/users/shoppingcarts/payment"

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

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

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

        // Configure Bearer (JWT) access token for authorization: bearerAuth
        HttpBearerAuth bearerAuth = (HttpBearerAuth) defaultClient.getAuthentication("bearerAuth");
        bearerAuth.setBearerToken("BEARER TOKEN");

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

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();


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

import org.openapitools.client.api.ApiShoppingCartControllerApi;

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

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

Configuration *apiConfig = [Configuration sharedConfig];

// Configure Bearer (JWT) access token for authorization: bearerAuth
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

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

// Process payment for shopping cart
[apiInstance paymentWithCompletionHandler: 
              ^(Object output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenApiDefinition = require('open_api_definition');
var defaultClient = OpenApiDefinition.ApiClient.instance;

// Configure Bearer (JWT) access token for authorization: bearerAuth
var bearerAuth = defaultClient.authentications['bearerAuth'];
bearerAuth.accessToken = "YOUR ACCESS TOKEN";

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

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

namespace Example
{
    public class paymentExample
    {
        public void main()
        {
            // Configure Bearer (JWT) access token for authorization: bearerAuth
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

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

            try {
                // Process payment for shopping cart
                Object result = apiInstance.payment();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ApiShoppingCartControllerApi.payment: " + e.Message );
            }
        }
    }
}

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

// Configure Bearer (JWT) access token for authorization: bearerAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('', 'YOUR_ACCESS_TOKEN');

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

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

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

# Configure Bearer (JWT) access token for authorization: bearerAuth
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

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

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

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

# Configure Bearer (JWT) access token for authorization: bearerAuth
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

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

try:
    # Process payment for shopping cart
    api_response = api_instance.payment()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ApiShoppingCartControllerApi->payment: %s\n" % e)

extern crate ApiShoppingCartControllerApi;

pub fn main() {

    let mut context = ApiShoppingCartControllerApi::Context::default();
    let result = client.payment(&context).wait();

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

Scopes

Parameters

Responses

Schema

Schema

removeProductFromCart

Remove product from shopping cart

Remove a product from the shopping cart of a specific user.

/api/v1/users/shoppingcarts/{productId}

Usage and SDK Samples

curl -X DELETE \
 -H "Authorization: Bearer [[accessToken]]" \
 -H "Accept: application/json,*/*" \
 "https://localhost:8443/api/v1/users/shoppingcarts/{productId}?id=789"

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

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

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

        // Configure Bearer (JWT) access token for authorization: bearerAuth
        HttpBearerAuth bearerAuth = (HttpBearerAuth) defaultClient.getAuthentication("bearerAuth");
        bearerAuth.setBearerToken("BEARER TOKEN");

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

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

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

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

import org.openapitools.client.api.ApiShoppingCartControllerApi;

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

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

Configuration *apiConfig = [Configuration sharedConfig];

// Configure Bearer (JWT) access token for authorization: bearerAuth
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

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

// Remove product from shopping cart
[apiInstance removeProductFromCartWith:id
    productId:productId
              completionHandler: ^(ProductDTO output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenApiDefinition = require('open_api_definition');
var defaultClient = OpenApiDefinition.ApiClient.instance;

// Configure Bearer (JWT) access token for authorization: bearerAuth
var bearerAuth = defaultClient.authentications['bearerAuth'];
bearerAuth.accessToken = "YOUR ACCESS TOKEN";

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

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.removeProductFromCart(id, productId, 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()
        {
            // Configure Bearer (JWT) access token for authorization: bearerAuth
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

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

            try {
                // Remove product from shopping cart
                ProductDTO result = apiInstance.removeProductFromCart(id, productId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ApiShoppingCartControllerApi.removeProductFromCart: " + e.Message );
            }
        }
    }
}

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

// Configure Bearer (JWT) access token for authorization: bearerAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('', 'YOUR_ACCESS_TOKEN');

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

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

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

# Configure Bearer (JWT) access token for authorization: bearerAuth
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

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

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

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

# Configure Bearer (JWT) access token for authorization: bearerAuth
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

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

try:
    # Remove product from shopping cart
    api_response = api_instance.remove_product_from_cart(id, productId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ApiShoppingCartControllerApi->removeProductFromCart: %s\n" % e)

extern crate ApiShoppingCartControllerApi;

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

    let mut context = ApiShoppingCartControllerApi::Context::default();
    let result = client.removeProductFromCart(id, productId, &context).wait();

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

Scopes

Parameters

Path parameters

Name	Description
productId*	Long (int64) Required

Query parameters

Name	Description
id*	Long (int64) Required

Responses

Schema

Schema

Schema

ApiUserController

createUser

Create a new user

/api/v1/users

Usage and SDK Samples

curl -X POST \
 -H "Authorization: Bearer [[accessToken]]" \
 -H "Accept: application/json,*/*" \
 -H "Content-Type: application/json" \
 "https://localhost:8443/api/v1/users" \
 -d '{
  "imageBase64" : "imageBase64",
  "password" : "password",
  "role" : [ "role", "role" ],
  "reviews" : [ {
    "comment" : "comment",
    "calification" : 4,
    "creationDate" : "2000-01-23",
    "reviewId" : 2,
    "username" : "username"
  }, {
    "comment" : "comment",
    "calification" : 4,
    "creationDate" : "2000-01-23",
    "reviewId" : 2,
    "username" : "username"
  } ],
  "historicalOrderPrices" : [ 6.027456183070403, 6.027456183070403 ],
  "cartPrice" : 0.8008281904610115,
  "name" : "name",
  "orders" : [ {
    "total" : 1.4658129805029452,
    "id" : 6,
    "userName" : "userName",
    "products" : [ {
      "date" : "2000-01-23T04:56:07.000+00:00",
      "imageBase64" : "imageBase64",
      "reviews" : [ {
        "comment" : "comment",
        "calification" : 3,
        "creationDate" : "2000-01-23T04:56:07.000+00:00",
        "reviewId" : 9,
        "username" : "username"
      }, {
        "comment" : "comment",
        "calification" : 3,
        "creationDate" : "2000-01-23T04:56:07.000+00:00",
        "reviewId" : 9,
        "username" : "username"
      } ],
      "price" : 5.637376656633329,
      "isAccepted" : true,
      "name" : "name",
      "description" : "description",
      "company" : "company",
      "id" : 5,
      "views_count" : 7,
      "type" : "type",
      "stock" : 2
    }, {
      "date" : "2000-01-23T04:56:07.000+00:00",
      "imageBase64" : "imageBase64",
      "reviews" : [ {
        "comment" : "comment",
        "calification" : 3,
        "creationDate" : "2000-01-23T04:56:07.000+00:00",
        "reviewId" : 9,
        "username" : "username"
      }, {
        "comment" : "comment",
        "calification" : 3,
        "creationDate" : "2000-01-23T04:56:07.000+00:00",
        "reviewId" : 9,
        "username" : "username"
      } ],
      "price" : 5.637376656633329,
      "isAccepted" : true,
      "name" : "name",
      "description" : "description",
      "company" : "company",
      "id" : 5,
      "views_count" : 7,
      "type" : "type",
      "stock" : 2
    } ]
  }, {
    "total" : 1.4658129805029452,
    "id" : 6,
    "userName" : "userName",
    "products" : [ {
      "date" : "2000-01-23T04:56:07.000+00:00",
      "imageBase64" : "imageBase64",
      "reviews" : [ {
        "comment" : "comment",
        "calification" : 3,
        "creationDate" : "2000-01-23T04:56:07.000+00:00",
        "reviewId" : 9,
        "username" : "username"
      }, {
        "comment" : "comment",
        "calification" : 3,
        "creationDate" : "2000-01-23T04:56:07.000+00:00",
        "reviewId" : 9,
        "username" : "username"
      } ],
      "price" : 5.637376656633329,
      "isAccepted" : true,
      "name" : "name",
      "description" : "description",
      "company" : "company",
      "id" : 5,
      "views_count" : 7,
      "type" : "type",
      "stock" : 2
    }, {
      "date" : "2000-01-23T04:56:07.000+00:00",
      "imageBase64" : "imageBase64",
      "reviews" : [ {
        "comment" : "comment",
        "calification" : 3,
        "creationDate" : "2000-01-23T04:56:07.000+00:00",
        "reviewId" : 9,
        "username" : "username"
      }, {
        "comment" : "comment",
        "calification" : 3,
        "creationDate" : "2000-01-23T04:56:07.000+00:00",
        "reviewId" : 9,
        "username" : "username"
      } ],
      "price" : 5.637376656633329,
      "isAccepted" : true,
      "name" : "name",
      "description" : "description",
      "company" : "company",
      "id" : 5,
      "views_count" : 7,
      "type" : "type",
      "stock" : 2
    } ]
  } ],
  "email" : "email",
  "cart" : [ {
    "date" : "2000-01-23T04:56:07.000+00:00",
    "imageBase64" : "imageBase64",
    "reviews" : [ {
      "comment" : "comment",
      "calification" : 3,
      "creationDate" : "2000-01-23T04:56:07.000+00:00",
      "reviewId" : 9,
      "username" : "username"
    }, {
      "comment" : "comment",
      "calification" : 3,
      "creationDate" : "2000-01-23T04:56:07.000+00:00",
      "reviewId" : 9,
      "username" : "username"
    } ],
    "price" : 5.637376656633329,
    "isAccepted" : true,
    "name" : "name",
    "description" : "description",
    "company" : "company",
    "id" : 5,
    "views_count" : 7,
    "type" : "type",
    "stock" : 2
  }, {
    "date" : "2000-01-23T04:56:07.000+00:00",
    "imageBase64" : "imageBase64",
    "reviews" : [ {
      "comment" : "comment",
      "calification" : 3,
      "creationDate" : "2000-01-23T04:56:07.000+00:00",
      "reviewId" : 9,
      "username" : "username"
    }, {
      "comment" : "comment",
      "calification" : 3,
      "creationDate" : "2000-01-23T04:56:07.000+00:00",
      "reviewId" : 9,
      "username" : "username"
    } ],
    "price" : 5.637376656633329,
    "isAccepted" : true,
    "name" : "name",
    "description" : "description",
    "company" : "company",
    "id" : 5,
    "views_count" : 7,
    "type" : "type",
    "stock" : 2
  } ],
  "username" : "username"
}'

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

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

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

        // Configure Bearer (JWT) access token for authorization: bearerAuth
        HttpBearerAuth bearerAuth = (HttpBearerAuth) defaultClient.getAuthentication("bearerAuth");
        bearerAuth.setBearerToken("BEARER TOKEN");

        // Create an instance of the API class
        ApiUserControllerApi apiInstance = new ApiUserControllerApi();
        UserCreationDTO userCreationDTO = ; // UserCreationDTO | 

        try {
            UserDTO result = apiInstance.createUser(userCreationDTO);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiUserControllerApi#createUser");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final UserCreationDTO userCreationDTO = new UserCreationDTO(); // UserCreationDTO | 

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

import org.openapitools.client.api.ApiUserControllerApi;

public class ApiUserControllerApiExample {
    public static void main(String[] args) {
        ApiUserControllerApi apiInstance = new ApiUserControllerApi();
        UserCreationDTO userCreationDTO = ; // UserCreationDTO | 

        try {
            UserDTO result = apiInstance.createUser(userCreationDTO);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiUserControllerApi#createUser");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure Bearer (JWT) access token for authorization: bearerAuth
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

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

// Create a new user
[apiInstance createUserWith:userCreationDTO
              completionHandler: ^(UserDTO output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenApiDefinition = require('open_api_definition');
var defaultClient = OpenApiDefinition.ApiClient.instance;

// Configure Bearer (JWT) access token for authorization: bearerAuth
var bearerAuth = defaultClient.authentications['bearerAuth'];
bearerAuth.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new OpenApiDefinition.ApiUserControllerApi()
var userCreationDTO = ; // {UserCreationDTO} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.createUser(userCreationDTO, 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()
        {
            // Configure Bearer (JWT) access token for authorization: bearerAuth
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new ApiUserControllerApi();
            var userCreationDTO = new UserCreationDTO(); // UserCreationDTO | 

            try {
                // Create a new user
                UserDTO result = apiInstance.createUser(userCreationDTO);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ApiUserControllerApi.createUser: " + e.Message );
            }
        }
    }
}

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

// Configure Bearer (JWT) access token for authorization: bearerAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('', 'YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ApiUserControllerApi();
$userCreationDTO = ; // UserCreationDTO | 

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

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

# Configure Bearer (JWT) access token for authorization: bearerAuth
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ApiUserControllerApi->new();
my $userCreationDTO = WWW::OPenAPIClient::Object::UserCreationDTO->new(); # UserCreationDTO | 

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

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

# Configure Bearer (JWT) access token for authorization: bearerAuth
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.ApiUserControllerApi()
userCreationDTO =  # UserCreationDTO | 

try:
    # Create a new user
    api_response = api_instance.create_user(userCreationDTO)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ApiUserControllerApi->createUser: %s\n" % e)

extern crate ApiUserControllerApi;

pub fn main() {
    let userCreationDTO = ; // UserCreationDTO

    let mut context = ApiUserControllerApi::Context::default();
    let result = client.createUser(userCreationDTO, &context).wait();

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

Scopes

Parameters

Body parameters

Name	Description
userCreationDTO *

Responses

Schema

Schema

Schema

deleteProductImage

Delete user image

Delete a user's image.

/api/v1/users/{id}/image

Usage and SDK Samples

curl -X DELETE \
 -H "Authorization: Bearer [[accessToken]]" \
 -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.ApiUserControllerApi;

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

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

        // Configure Bearer (JWT) access token for authorization: bearerAuth
        HttpBearerAuth bearerAuth = (HttpBearerAuth) defaultClient.getAuthentication("bearerAuth");
        bearerAuth.setBearerToken("BEARER TOKEN");

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

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

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

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

import org.openapitools.client.api.ApiUserControllerApi;

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

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

Configuration *apiConfig = [Configuration sharedConfig];

// Configure Bearer (JWT) access token for authorization: bearerAuth
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

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

// Delete user image
[apiInstance deleteProductImageWith:id
              completionHandler: ^(Object output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenApiDefinition = require('open_api_definition');
var defaultClient = OpenApiDefinition.ApiClient.instance;

// Configure Bearer (JWT) access token for authorization: bearerAuth
var bearerAuth = defaultClient.authentications['bearerAuth'];
bearerAuth.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new OpenApiDefinition.ApiUserControllerApi()
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.deleteProductImage(id, 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()
        {
            // Configure Bearer (JWT) access token for authorization: bearerAuth
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

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

            try {
                // Delete user image
                Object result = apiInstance.deleteProductImage(id);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ApiUserControllerApi.deleteProductImage: " + e.Message );
            }
        }
    }
}

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

// Configure Bearer (JWT) access token for authorization: bearerAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('', 'YOUR_ACCESS_TOKEN');

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

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

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

# Configure Bearer (JWT) access token for authorization: bearerAuth
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

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

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

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

# Configure Bearer (JWT) access token for authorization: bearerAuth
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

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

try:
    # Delete user image
    api_response = api_instance.delete_product_image(id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ApiUserControllerApi->deleteProductImage: %s\n" % e)

extern crate ApiUserControllerApi;

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

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

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

Scopes

Parameters

Path parameters

Name	Description
id*	Long (int64) Required

Responses

Schema

Schema

Schema

Schema

deleteUser

Delete user

Delete a user by their unique ID.

/api/v1/users/{id}

Usage and SDK Samples

curl -X DELETE \
 -H "Authorization: Bearer [[accessToken]]" \
 -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.ApiUserControllerApi;

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

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

        // Configure Bearer (JWT) access token for authorization: bearerAuth
        HttpBearerAuth bearerAuth = (HttpBearerAuth) defaultClient.getAuthentication("bearerAuth");
        bearerAuth.setBearerToken("BEARER TOKEN");

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

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

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

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

import org.openapitools.client.api.ApiUserControllerApi;

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

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

Configuration *apiConfig = [Configuration sharedConfig];

// Configure Bearer (JWT) access token for authorization: bearerAuth
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

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

// Delete user
[apiInstance deleteUserWith:id
              completionHandler: ^(Object output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenApiDefinition = require('open_api_definition');
var defaultClient = OpenApiDefinition.ApiClient.instance;

// Configure Bearer (JWT) access token for authorization: bearerAuth
var bearerAuth = defaultClient.authentications['bearerAuth'];
bearerAuth.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new OpenApiDefinition.ApiUserControllerApi()
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.deleteUser(id, callback);

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

namespace Example
{
    public class deleteUserExample
    {
        public void main()
        {
            // Configure Bearer (JWT) access token for authorization: bearerAuth
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

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

            try {
                // Delete user
                Object result = apiInstance.deleteUser(id);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ApiUserControllerApi.deleteUser: " + e.Message );
            }
        }
    }
}

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

// Configure Bearer (JWT) access token for authorization: bearerAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('', 'YOUR_ACCESS_TOKEN');

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

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

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

# Configure Bearer (JWT) access token for authorization: bearerAuth
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

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

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

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

# Configure Bearer (JWT) access token for authorization: bearerAuth
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

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

try:
    # Delete user
    api_response = api_instance.delete_user(id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ApiUserControllerApi->deleteUser: %s\n" % e)

extern crate ApiUserControllerApi;

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

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

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

Scopes

Parameters

Path parameters

Name	Description
id*	Long (int64) Required

Responses

Schema

Schema

getAllUsers

Get all users

Retrieve a list of all users in the system.

/api/v1/users

Usage and SDK Samples

curl -X GET \
 -H "Authorization: Bearer [[accessToken]]" \
 -H "Accept: application/json,*/*" \
 "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.ApiUserControllerApi;

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

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

        // Configure Bearer (JWT) access token for authorization: bearerAuth
        HttpBearerAuth bearerAuth = (HttpBearerAuth) defaultClient.getAuthentication("bearerAuth");
        bearerAuth.setBearerToken("BEARER TOKEN");

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

        try {
            UserDTO result = apiInstance.getAllUsers();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiUserControllerApi#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.ApiUserControllerApi;

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

        try {
            UserDTO result = apiInstance.getAllUsers();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiUserControllerApi#getAllUsers");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure Bearer (JWT) access token for authorization: bearerAuth
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

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

// Get all users
[apiInstance getAllUsersWithCompletionHandler: 
              ^(UserDTO output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenApiDefinition = require('open_api_definition');
var defaultClient = OpenApiDefinition.ApiClient.instance;

// Configure Bearer (JWT) access token for authorization: bearerAuth
var bearerAuth = defaultClient.authentications['bearerAuth'];
bearerAuth.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new OpenApiDefinition.ApiUserControllerApi()
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()
        {
            // Configure Bearer (JWT) access token for authorization: bearerAuth
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

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

            try {
                // Get all users
                UserDTO result = apiInstance.getAllUsers();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ApiUserControllerApi.getAllUsers: " + e.Message );
            }
        }
    }
}

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

// Configure Bearer (JWT) access token for authorization: bearerAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('', 'YOUR_ACCESS_TOKEN');

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

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

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

# Configure Bearer (JWT) access token for authorization: bearerAuth
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

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

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

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

# Configure Bearer (JWT) access token for authorization: bearerAuth
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

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

try:
    # Get all users
    api_response = api_instance.get_all_users()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ApiUserControllerApi->getAllUsers: %s\n" % e)

extern crate ApiUserControllerApi;

pub fn main() {

    let mut context = ApiUserControllerApi::Context::default();
    let result = client.getAllUsers(&context).wait();

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

Scopes

Parameters

Responses

Schema

Schema

getProfile

Get user profile

Retrieve the profile details of the authenticated user.

/api/v1/users/profile

Usage and SDK Samples

curl -X GET \
 -H "Authorization: Bearer [[accessToken]]" \
 -H "Accept: application/json,*/*" \
 "https://localhost:8443/api/v1/users/profile"

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

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

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

        // Configure Bearer (JWT) access token for authorization: bearerAuth
        HttpBearerAuth bearerAuth = (HttpBearerAuth) defaultClient.getAuthentication("bearerAuth");
        bearerAuth.setBearerToken("BEARER TOKEN");

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

        try {
            UserDTO result = apiInstance.getProfile();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiUserControllerApi#getProfile");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();


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

import org.openapitools.client.api.ApiUserControllerApi;

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

        try {
            UserDTO result = apiInstance.getProfile();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiUserControllerApi#getProfile");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure Bearer (JWT) access token for authorization: bearerAuth
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

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

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

var OpenApiDefinition = require('open_api_definition');
var defaultClient = OpenApiDefinition.ApiClient.instance;

// Configure Bearer (JWT) access token for authorization: bearerAuth
var bearerAuth = defaultClient.authentications['bearerAuth'];
bearerAuth.accessToken = "YOUR ACCESS TOKEN";

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

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

namespace Example
{
    public class getProfileExample
    {
        public void main()
        {
            // Configure Bearer (JWT) access token for authorization: bearerAuth
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

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

            try {
                // Get user profile
                UserDTO result = apiInstance.getProfile();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ApiUserControllerApi.getProfile: " + e.Message );
            }
        }
    }
}

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

// Configure Bearer (JWT) access token for authorization: bearerAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('', 'YOUR_ACCESS_TOKEN');

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

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

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

# Configure Bearer (JWT) access token for authorization: bearerAuth
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

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

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

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

# Configure Bearer (JWT) access token for authorization: bearerAuth
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

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

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

extern crate ApiUserControllerApi;

pub fn main() {

    let mut context = ApiUserControllerApi::Context::default();
    let result = client.getProfile(&context).wait();

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

Scopes

Parameters

Responses

Schema

Schema

Schema

getUserById

Get user by ID

Retrieve a user by their unique ID.

/api/v1/users/{id}

Usage and SDK Samples

curl -X GET \
 -H "Authorization: Bearer [[accessToken]]" \
 -H "Accept: application/json,*/*" \
 "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.ApiUserControllerApi;

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

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

        // Configure Bearer (JWT) access token for authorization: bearerAuth
        HttpBearerAuth bearerAuth = (HttpBearerAuth) defaultClient.getAuthentication("bearerAuth");
        bearerAuth.setBearerToken("BEARER TOKEN");

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

        try {
            UserDTO result = apiInstance.getUserById(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiUserControllerApi#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.ApiUserControllerApi;

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

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

Configuration *apiConfig = [Configuration sharedConfig];

// Configure Bearer (JWT) access token for authorization: bearerAuth
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

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

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

var OpenApiDefinition = require('open_api_definition');
var defaultClient = OpenApiDefinition.ApiClient.instance;

// Configure Bearer (JWT) access token for authorization: bearerAuth
var bearerAuth = defaultClient.authentications['bearerAuth'];
bearerAuth.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new OpenApiDefinition.ApiUserControllerApi()
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()
        {
            // Configure Bearer (JWT) access token for authorization: bearerAuth
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

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

            try {
                // Get user by ID
                UserDTO result = apiInstance.getUserById(id);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ApiUserControllerApi.getUserById: " + e.Message );
            }
        }
    }
}

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

// Configure Bearer (JWT) access token for authorization: bearerAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('', 'YOUR_ACCESS_TOKEN');

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

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

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

# Configure Bearer (JWT) access token for authorization: bearerAuth
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

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

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

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

# Configure Bearer (JWT) access token for authorization: bearerAuth
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.ApiUserControllerApi()
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 ApiUserControllerApi->getUserById: %s\n" % e)

extern crate ApiUserControllerApi;

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

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

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

Scopes

Parameters

Path parameters

Name	Description
id*	Long (int64) Required

Responses

Schema

Schema

getUserIdByUsername

Get user ID by username

Retrieve a user's ID by their username.

/api/v1/users/by-username/{username}

Usage and SDK Samples

curl -X GET \
 -H "Authorization: Bearer [[accessToken]]" \
 -H "Accept: application/json,*/*" \
 "https://localhost:8443/api/v1/users/by-username/{username}"

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

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

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

        // Configure Bearer (JWT) access token for authorization: bearerAuth
        HttpBearerAuth bearerAuth = (HttpBearerAuth) defaultClient.getAuthentication("bearerAuth");
        bearerAuth.setBearerToken("BEARER TOKEN");

        // Create an instance of the API class
        ApiUserControllerApi apiInstance = new ApiUserControllerApi();
        String username = username_example; // String | 

        try {
            Long result = apiInstance.getUserIdByUsername(username);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiUserControllerApi#getUserIdByUsername");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

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

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

import org.openapitools.client.api.ApiUserControllerApi;

public class ApiUserControllerApiExample {
    public static void main(String[] args) {
        ApiUserControllerApi apiInstance = new ApiUserControllerApi();
        String username = username_example; // String | 

        try {
            Long result = apiInstance.getUserIdByUsername(username);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiUserControllerApi#getUserIdByUsername");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure Bearer (JWT) access token for authorization: bearerAuth
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

// Create an instance of the API class
ApiUserControllerApi *apiInstance = [[ApiUserControllerApi alloc] init];
String *username = username_example; //  (default to null)

// Get user ID by username
[apiInstance getUserIdByUsernameWith:username
              completionHandler: ^(Long output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenApiDefinition = require('open_api_definition');
var defaultClient = OpenApiDefinition.ApiClient.instance;

// Configure Bearer (JWT) access token for authorization: bearerAuth
var bearerAuth = defaultClient.authentications['bearerAuth'];
bearerAuth.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new OpenApiDefinition.ApiUserControllerApi()
var username = username_example; // {String} 

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

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

namespace Example
{
    public class getUserIdByUsernameExample
    {
        public void main()
        {
            // Configure Bearer (JWT) access token for authorization: bearerAuth
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new ApiUserControllerApi();
            var username = username_example;  // String |  (default to null)

            try {
                // Get user ID by username
                Long result = apiInstance.getUserIdByUsername(username);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ApiUserControllerApi.getUserIdByUsername: " + e.Message );
            }
        }
    }
}

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

// Configure Bearer (JWT) access token for authorization: bearerAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('', 'YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ApiUserControllerApi();
$username = username_example; // String | 

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

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

# Configure Bearer (JWT) access token for authorization: bearerAuth
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ApiUserControllerApi->new();
my $username = username_example; # String | 

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

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

# Configure Bearer (JWT) access token for authorization: bearerAuth
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.ApiUserControllerApi()
username = username_example # String |  (default to null)

try:
    # Get user ID by username
    api_response = api_instance.get_user_id_by_username(username)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ApiUserControllerApi->getUserIdByUsername: %s\n" % e)

extern crate ApiUserControllerApi;

pub fn main() {
    let username = username_example; // String

    let mut context = ApiUserControllerApi::Context::default();
    let result = client.getUserIdByUsername(username, &context).wait();

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

Scopes

Parameters

Path parameters

Name	Description
username*	String Required

Responses

Schema

Schema

getUserImage

Get user profile image

Retrieves the profile image for the specified user

/api/v1/users/{id}/image

Usage and SDK Samples

curl -X GET \
 -H "Authorization: Bearer [[accessToken]]" \
 -H "Accept: image/*,application/json" \
 "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.ApiUserControllerApi;

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

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

        // Configure Bearer (JWT) access token for authorization: bearerAuth
        HttpBearerAuth bearerAuth = (HttpBearerAuth) defaultClient.getAuthentication("bearerAuth");
        bearerAuth.setBearerToken("BEARER TOKEN");

        // Create an instance of the API class
        ApiUserControllerApi apiInstance = new ApiUserControllerApi();
        Long id = 789; // Long | Numeric ID of the user

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final Long id = new Long(); // Long | Numeric ID of the user

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

import org.openapitools.client.api.ApiUserControllerApi;

public class ApiUserControllerApiExample {
    public static void main(String[] args) {
        ApiUserControllerApi apiInstance = new ApiUserControllerApi();
        Long id = 789; // Long | Numeric ID of the user

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

Configuration *apiConfig = [Configuration sharedConfig];

// Configure Bearer (JWT) access token for authorization: bearerAuth
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

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

// Get user profile image
[apiInstance getUserImageWith:id
              completionHandler: ^(File output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenApiDefinition = require('open_api_definition');
var defaultClient = OpenApiDefinition.ApiClient.instance;

// Configure Bearer (JWT) access token for authorization: bearerAuth
var bearerAuth = defaultClient.authentications['bearerAuth'];
bearerAuth.accessToken = "YOUR ACCESS TOKEN";

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

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

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

namespace Example
{
    public class getUserImageExample
    {
        public void main()
        {
            // Configure Bearer (JWT) access token for authorization: bearerAuth
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

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

            try {
                // Get user profile image
                File result = apiInstance.getUserImage(id);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ApiUserControllerApi.getUserImage: " + e.Message );
            }
        }
    }
}

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

// Configure Bearer (JWT) access token for authorization: bearerAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('', 'YOUR_ACCESS_TOKEN');

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

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

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

# Configure Bearer (JWT) access token for authorization: bearerAuth
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

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

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

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

# Configure Bearer (JWT) access token for authorization: bearerAuth
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

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

try:
    # Get user profile image
    api_response = api_instance.get_user_image(id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ApiUserControllerApi->getUserImage: %s\n" % e)

extern crate ApiUserControllerApi;

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

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

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

Scopes

Parameters

Path parameters

Name	Description
id*	Long (int64) Numeric ID of the user Required

Responses

Schema

Schema

Schema

Schema

replaceUserImage

Replace user profile image

Uploads a new profile image replacing any existing one

/api/v1/users/{id}/image

Usage and SDK Samples

curl -X PUT \
 -H "Authorization: Bearer [[accessToken]]" \
 -H "Accept: application/json" \
 -H "Content-Type: multipart/form-data" \
 "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.ApiUserControllerApi;

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

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

        // Configure Bearer (JWT) access token for authorization: bearerAuth
        HttpBearerAuth bearerAuth = (HttpBearerAuth) defaultClient.getAuthentication("bearerAuth");
        bearerAuth.setBearerToken("BEARER TOKEN");

        // Create an instance of the API class
        ApiUserControllerApi apiInstance = new ApiUserControllerApi();
        Long id = 789; // Long | Numeric ID of the user
        File imageFile = BINARY_DATA_HERE; // File | The image file to upload (JPG/PNG)

        try {
            replaceUserImage_200_response result = apiInstance.replaceUserImage(id, imageFile);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiUserControllerApi#replaceUserImage");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final Long id = new Long(); // Long | Numeric ID of the user
final File imageFile = new File(); // File | The image file to upload (JPG/PNG)

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

import org.openapitools.client.api.ApiUserControllerApi;

public class ApiUserControllerApiExample {
    public static void main(String[] args) {
        ApiUserControllerApi apiInstance = new ApiUserControllerApi();
        Long id = 789; // Long | Numeric ID of the user
        File imageFile = BINARY_DATA_HERE; // File | The image file to upload (JPG/PNG)

        try {
            replaceUserImage_200_response result = apiInstance.replaceUserImage(id, imageFile);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiUserControllerApi#replaceUserImage");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure Bearer (JWT) access token for authorization: bearerAuth
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

// Create an instance of the API class
ApiUserControllerApi *apiInstance = [[ApiUserControllerApi alloc] init];
Long *id = 789; // Numeric ID of the user (default to null)
File *imageFile = BINARY_DATA_HERE; // The image file to upload (JPG/PNG) (default to null)

// Replace user profile image
[apiInstance replaceUserImageWith:id
    imageFile:imageFile
              completionHandler: ^(replaceUserImage_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenApiDefinition = require('open_api_definition');
var defaultClient = OpenApiDefinition.ApiClient.instance;

// Configure Bearer (JWT) access token for authorization: bearerAuth
var bearerAuth = defaultClient.authentications['bearerAuth'];
bearerAuth.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new OpenApiDefinition.ApiUserControllerApi()
var id = 789; // {Long} Numeric ID of the user
var imageFile = BINARY_DATA_HERE; // {File} The image file to upload (JPG/PNG)

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

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

namespace Example
{
    public class replaceUserImageExample
    {
        public void main()
        {
            // Configure Bearer (JWT) access token for authorization: bearerAuth
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new ApiUserControllerApi();
            var id = 789;  // Long | Numeric ID of the user (default to null)
            var imageFile = BINARY_DATA_HERE;  // File | The image file to upload (JPG/PNG) (default to null)

            try {
                // Replace user profile image
                replaceUserImage_200_response result = apiInstance.replaceUserImage(id, imageFile);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ApiUserControllerApi.replaceUserImage: " + e.Message );
            }
        }
    }
}

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

// Configure Bearer (JWT) access token for authorization: bearerAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('', 'YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ApiUserControllerApi();
$id = 789; // Long | Numeric ID of the user
$imageFile = BINARY_DATA_HERE; // File | The image file to upload (JPG/PNG)

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

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

# Configure Bearer (JWT) access token for authorization: bearerAuth
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ApiUserControllerApi->new();
my $id = 789; # Long | Numeric ID of the user
my $imageFile = BINARY_DATA_HERE; # File | The image file to upload (JPG/PNG)

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

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

# Configure Bearer (JWT) access token for authorization: bearerAuth
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.ApiUserControllerApi()
id = 789 # Long | Numeric ID of the user (default to null)
imageFile = BINARY_DATA_HERE # File | The image file to upload (JPG/PNG) (default to null)

try:
    # Replace user profile image
    api_response = api_instance.replace_user_image(id, imageFile)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ApiUserControllerApi->replaceUserImage: %s\n" % e)

extern crate ApiUserControllerApi;

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

    let mut context = ApiUserControllerApi::Context::default();
    let result = client.replaceUserImage(id, imageFile, &context).wait();

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

Scopes

Parameters

Path parameters

Name	Description
id*	Long (int64) Numeric ID of the user Required

Form parameters

Name	Description
imageFile*	File (binary) The image file to upload (JPG/PNG) Required

Responses

Schema

Schema

Schema

Schema

Schema

updateProfile

Update user profile

Update the details of an existing user.

/api/v1/users

Usage and SDK Samples

curl -X PUT \
 -H "Authorization: Bearer [[accessToken]]" \
 -H "Accept: */*" \
 -H "Content-Type: application/json" \
 "https://localhost:8443/api/v1/users" \
 -d '{
  "imageBase64" : "imageBase64",
  "password" : "password",
  "role" : [ "role", "role" ],
  "reviews" : [ {
    "comment" : "comment",
    "calification" : 4,
    "creationDate" : "2000-01-23",
    "reviewId" : 2,
    "username" : "username"
  }, {
    "comment" : "comment",
    "calification" : 4,
    "creationDate" : "2000-01-23",
    "reviewId" : 2,
    "username" : "username"
  } ],
  "historicalOrderPrices" : [ 6.027456183070403, 6.027456183070403 ],
  "cartPrice" : 0.8008281904610115,
  "name" : "name",
  "orders" : [ {
    "total" : 1.4658129805029452,
    "id" : 6,
    "userName" : "userName",
    "products" : [ {
      "date" : "2000-01-23T04:56:07.000+00:00",
      "imageBase64" : "imageBase64",
      "reviews" : [ {
        "comment" : "comment",
        "calification" : 3,
        "creationDate" : "2000-01-23T04:56:07.000+00:00",
        "reviewId" : 9,
        "username" : "username"
      }, {
        "comment" : "comment",
        "calification" : 3,
        "creationDate" : "2000-01-23T04:56:07.000+00:00",
        "reviewId" : 9,
        "username" : "username"
      } ],
      "price" : 5.637376656633329,
      "isAccepted" : true,
      "name" : "name",
      "description" : "description",
      "company" : "company",
      "id" : 5,
      "views_count" : 7,
      "type" : "type",
      "stock" : 2
    }, {
      "date" : "2000-01-23T04:56:07.000+00:00",
      "imageBase64" : "imageBase64",
      "reviews" : [ {
        "comment" : "comment",
        "calification" : 3,
        "creationDate" : "2000-01-23T04:56:07.000+00:00",
        "reviewId" : 9,
        "username" : "username"
      }, {
        "comment" : "comment",
        "calification" : 3,
        "creationDate" : "2000-01-23T04:56:07.000+00:00",
        "reviewId" : 9,
        "username" : "username"
      } ],
      "price" : 5.637376656633329,
      "isAccepted" : true,
      "name" : "name",
      "description" : "description",
      "company" : "company",
      "id" : 5,
      "views_count" : 7,
      "type" : "type",
      "stock" : 2
    } ]
  }, {
    "total" : 1.4658129805029452,
    "id" : 6,
    "userName" : "userName",
    "products" : [ {
      "date" : "2000-01-23T04:56:07.000+00:00",
      "imageBase64" : "imageBase64",
      "reviews" : [ {
        "comment" : "comment",
        "calification" : 3,
        "creationDate" : "2000-01-23T04:56:07.000+00:00",
        "reviewId" : 9,
        "username" : "username"
      }, {
        "comment" : "comment",
        "calification" : 3,
        "creationDate" : "2000-01-23T04:56:07.000+00:00",
        "reviewId" : 9,
        "username" : "username"
      } ],
      "price" : 5.637376656633329,
      "isAccepted" : true,
      "name" : "name",
      "description" : "description",
      "company" : "company",
      "id" : 5,
      "views_count" : 7,
      "type" : "type",
      "stock" : 2
    }, {
      "date" : "2000-01-23T04:56:07.000+00:00",
      "imageBase64" : "imageBase64",
      "reviews" : [ {
        "comment" : "comment",
        "calification" : 3,
        "creationDate" : "2000-01-23T04:56:07.000+00:00",
        "reviewId" : 9,
        "username" : "username"
      }, {
        "comment" : "comment",
        "calification" : 3,
        "creationDate" : "2000-01-23T04:56:07.000+00:00",
        "reviewId" : 9,
        "username" : "username"
      } ],
      "price" : 5.637376656633329,
      "isAccepted" : true,
      "name" : "name",
      "description" : "description",
      "company" : "company",
      "id" : 5,
      "views_count" : 7,
      "type" : "type",
      "stock" : 2
    } ]
  } ],
  "email" : "email",
  "cart" : [ {
    "date" : "2000-01-23T04:56:07.000+00:00",
    "imageBase64" : "imageBase64",
    "reviews" : [ {
      "comment" : "comment",
      "calification" : 3,
      "creationDate" : "2000-01-23T04:56:07.000+00:00",
      "reviewId" : 9,
      "username" : "username"
    }, {
      "comment" : "comment",
      "calification" : 3,
      "creationDate" : "2000-01-23T04:56:07.000+00:00",
      "reviewId" : 9,
      "username" : "username"
    } ],
    "price" : 5.637376656633329,
    "isAccepted" : true,
    "name" : "name",
    "description" : "description",
    "company" : "company",
    "id" : 5,
    "views_count" : 7,
    "type" : "type",
    "stock" : 2
  }, {
    "date" : "2000-01-23T04:56:07.000+00:00",
    "imageBase64" : "imageBase64",
    "reviews" : [ {
      "comment" : "comment",
      "calification" : 3,
      "creationDate" : "2000-01-23T04:56:07.000+00:00",
      "reviewId" : 9,
      "username" : "username"
    }, {
      "comment" : "comment",
      "calification" : 3,
      "creationDate" : "2000-01-23T04:56:07.000+00:00",
      "reviewId" : 9,
      "username" : "username"
    } ],
    "price" : 5.637376656633329,
    "isAccepted" : true,
    "name" : "name",
    "description" : "description",
    "company" : "company",
    "id" : 5,
    "views_count" : 7,
    "type" : "type",
    "stock" : 2
  } ],
  "username" : "username"
}'

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

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

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

        // Configure Bearer (JWT) access token for authorization: bearerAuth
        HttpBearerAuth bearerAuth = (HttpBearerAuth) defaultClient.getAuthentication("bearerAuth");
        bearerAuth.setBearerToken("BEARER TOKEN");

        // Create an instance of the API class
        ApiUserControllerApi apiInstance = new ApiUserControllerApi();
        UserCreationDTO userCreationDTO = ; // UserCreationDTO | 

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final UserCreationDTO userCreationDTO = new UserCreationDTO(); // UserCreationDTO | 

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

import org.openapitools.client.api.ApiUserControllerApi;

public class ApiUserControllerApiExample {
    public static void main(String[] args) {
        ApiUserControllerApi apiInstance = new ApiUserControllerApi();
        UserCreationDTO userCreationDTO = ; // UserCreationDTO | 

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

Configuration *apiConfig = [Configuration sharedConfig];

// Configure Bearer (JWT) access token for authorization: bearerAuth
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

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

// Update user profile
[apiInstance updateProfileWith:userCreationDTO
              completionHandler: ^(Object output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenApiDefinition = require('open_api_definition');
var defaultClient = OpenApiDefinition.ApiClient.instance;

// Configure Bearer (JWT) access token for authorization: bearerAuth
var bearerAuth = defaultClient.authentications['bearerAuth'];
bearerAuth.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new OpenApiDefinition.ApiUserControllerApi()
var userCreationDTO = ; // {UserCreationDTO} 

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

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

namespace Example
{
    public class updateProfileExample
    {
        public void main()
        {
            // Configure Bearer (JWT) access token for authorization: bearerAuth
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new ApiUserControllerApi();
            var userCreationDTO = new UserCreationDTO(); // UserCreationDTO | 

            try {
                // Update user profile
                Object result = apiInstance.updateProfile(userCreationDTO);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ApiUserControllerApi.updateProfile: " + e.Message );
            }
        }
    }
}

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

// Configure Bearer (JWT) access token for authorization: bearerAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('', 'YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ApiUserControllerApi();
$userCreationDTO = ; // UserCreationDTO | 

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

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

# Configure Bearer (JWT) access token for authorization: bearerAuth
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ApiUserControllerApi->new();
my $userCreationDTO = WWW::OPenAPIClient::Object::UserCreationDTO->new(); # UserCreationDTO | 

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

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

# Configure Bearer (JWT) access token for authorization: bearerAuth
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.ApiUserControllerApi()
userCreationDTO =  # UserCreationDTO | 

try:
    # Update user profile
    api_response = api_instance.update_profile(userCreationDTO)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ApiUserControllerApi->updateProfile: %s\n" % e)

extern crate ApiUserControllerApi;

pub fn main() {
    let userCreationDTO = ; // UserCreationDTO

    let mut context = ApiUserControllerApi::Context::default();
    let result = client.updateProfile(userCreationDTO, &context).wait();

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

Scopes

Parameters

Body parameters

Name	Description
userCreationDTO *

Responses

Schema

Schema

Schema

uploadUserImage

Upload user profile image

Uploads a profile image (requires no existing image)

/api/v1/users/{id}/image

Usage and SDK Samples

curl -X POST \
 -H "Authorization: Bearer [[accessToken]]" \
 -H "Accept: application/json" \
 -H "Content-Type: multipart/form-data" \
 "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.ApiUserControllerApi;

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

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

        // Configure Bearer (JWT) access token for authorization: bearerAuth
        HttpBearerAuth bearerAuth = (HttpBearerAuth) defaultClient.getAuthentication("bearerAuth");
        bearerAuth.setBearerToken("BEARER TOKEN");

        // Create an instance of the API class
        ApiUserControllerApi apiInstance = new ApiUserControllerApi();
        Long id = 789; // Long | Numeric ID of the user
        File imageFile = BINARY_DATA_HERE; // File | The image file to upload (JPG/PNG)

        try {
            replaceUserImage_200_response result = apiInstance.uploadUserImage(id, imageFile);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiUserControllerApi#uploadUserImage");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final Long id = new Long(); // Long | Numeric ID of the user
final File imageFile = new File(); // File | The image file to upload (JPG/PNG)

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

import org.openapitools.client.api.ApiUserControllerApi;

public class ApiUserControllerApiExample {
    public static void main(String[] args) {
        ApiUserControllerApi apiInstance = new ApiUserControllerApi();
        Long id = 789; // Long | Numeric ID of the user
        File imageFile = BINARY_DATA_HERE; // File | The image file to upload (JPG/PNG)

        try {
            replaceUserImage_200_response result = apiInstance.uploadUserImage(id, imageFile);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ApiUserControllerApi#uploadUserImage");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure Bearer (JWT) access token for authorization: bearerAuth
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

// Create an instance of the API class
ApiUserControllerApi *apiInstance = [[ApiUserControllerApi alloc] init];
Long *id = 789; // Numeric ID of the user (default to null)
File *imageFile = BINARY_DATA_HERE; // The image file to upload (JPG/PNG) (default to null)

// Upload user profile image
[apiInstance uploadUserImageWith:id
    imageFile:imageFile
              completionHandler: ^(replaceUserImage_200_response output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenApiDefinition = require('open_api_definition');
var defaultClient = OpenApiDefinition.ApiClient.instance;

// Configure Bearer (JWT) access token for authorization: bearerAuth
var bearerAuth = defaultClient.authentications['bearerAuth'];
bearerAuth.accessToken = "YOUR ACCESS TOKEN";

// Create an instance of the API class
var api = new OpenApiDefinition.ApiUserControllerApi()
var id = 789; // {Long} Numeric ID of the user
var imageFile = BINARY_DATA_HERE; // {File} The image file to upload (JPG/PNG)

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.uploadUserImage(id, imageFile, 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()
        {
            // Configure Bearer (JWT) access token for authorization: bearerAuth
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // Create an instance of the API class
            var apiInstance = new ApiUserControllerApi();
            var id = 789;  // Long | Numeric ID of the user (default to null)
            var imageFile = BINARY_DATA_HERE;  // File | The image file to upload (JPG/PNG) (default to null)

            try {
                // Upload user profile image
                replaceUserImage_200_response result = apiInstance.uploadUserImage(id, imageFile);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ApiUserControllerApi.uploadUserImage: " + e.Message );
            }
        }
    }
}

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

// Configure Bearer (JWT) access token for authorization: bearerAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('', 'YOUR_ACCESS_TOKEN');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ApiUserControllerApi();
$id = 789; // Long | Numeric ID of the user
$imageFile = BINARY_DATA_HERE; // File | The image file to upload (JPG/PNG)

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

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

# Configure Bearer (JWT) access token for authorization: bearerAuth
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ApiUserControllerApi->new();
my $id = 789; # Long | Numeric ID of the user
my $imageFile = BINARY_DATA_HERE; # File | The image file to upload (JPG/PNG)

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

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

# Configure Bearer (JWT) access token for authorization: bearerAuth
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# Create an instance of the API class
api_instance = openapi_client.ApiUserControllerApi()
id = 789 # Long | Numeric ID of the user (default to null)
imageFile = BINARY_DATA_HERE # File | The image file to upload (JPG/PNG) (default to null)

try:
    # Upload user profile image
    api_response = api_instance.upload_user_image(id, imageFile)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ApiUserControllerApi->uploadUserImage: %s\n" % e)

extern crate ApiUserControllerApi;

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

    let mut context = ApiUserControllerApi::Context::default();
    let result = client.uploadUserImage(id, imageFile, &context).wait();

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

Scopes

Parameters

Path parameters

Name	Description
id*	Long (int64) Numeric ID of the user Required

Form parameters

Name	Description
imageFile*	File (binary) The image file to upload (JPG/PNG) Required

Responses

Schema

Schema

Schema

Schema

Schema

LoginController

logOut

Logout a user

Logout the user by invalidating the session and refresh token.

/api/v1/auth/logout

Usage and SDK Samples

curl -X POST \
 -H "Authorization: Bearer [[accessToken]]" \
 -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) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure Bearer (JWT) access token for authorization: bearerAuth
        HttpBearerAuth bearerAuth = (HttpBearerAuth) defaultClient.getAuthentication("bearerAuth");
        bearerAuth.setBearerToken("BEARER TOKEN");

        // 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();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure Bearer (JWT) access token for authorization: bearerAuth
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

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

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

var OpenApiDefinition = require('open_api_definition');
var defaultClient = OpenApiDefinition.ApiClient.instance;

// Configure Bearer (JWT) access token for authorization: bearerAuth
var bearerAuth = defaultClient.authentications['bearerAuth'];
bearerAuth.accessToken = "YOUR ACCESS TOKEN";

// 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()
        {
            // Configure Bearer (JWT) access token for authorization: bearerAuth
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

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

            try {
                // Logout a 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');

// Configure Bearer (JWT) access token for authorization: bearerAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('', 'YOUR_ACCESS_TOKEN');

// 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;

# Configure Bearer (JWT) access token for authorization: bearerAuth
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# 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

# Configure Bearer (JWT) access token for authorization: bearerAuth
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

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

try:
    # Logout a 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

Schema

login

Authenticate a user and provide a JWT token along with user details upon successful login.

/api/v1/auth/login

Usage and SDK Samples

curl -X POST \
 -H "Authorization: Bearer [[accessToken]]" \
 -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) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure Bearer (JWT) access token for authorization: bearerAuth
        HttpBearerAuth bearerAuth = (HttpBearerAuth) defaultClient.getAuthentication("bearerAuth");
        bearerAuth.setBearerToken("BEARER TOKEN");

        // 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();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure Bearer (JWT) access token for authorization: bearerAuth
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

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

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

var OpenApiDefinition = require('open_api_definition');
var defaultClient = OpenApiDefinition.ApiClient.instance;

// Configure Bearer (JWT) access token for authorization: bearerAuth
var bearerAuth = defaultClient.authentications['bearerAuth'];
bearerAuth.accessToken = "YOUR ACCESS TOKEN";

// 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()
        {
            // Configure Bearer (JWT) access token for authorization: bearerAuth
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

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

            try {
                // Login a 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');

// Configure Bearer (JWT) access token for authorization: bearerAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('', 'YOUR_ACCESS_TOKEN');

// 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;

# Configure Bearer (JWT) access token for authorization: bearerAuth
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

# 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

# Configure Bearer (JWT) access token for authorization: bearerAuth
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

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

try:
    # Login a 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

refresh

Refresh authentication token

Refresh the user's authentication token using the refresh token stored in the cookie.

/api/v1/auth/refresh

Usage and SDK Samples

curl -X POST \
 -H "Authorization: Bearer [[accessToken]]" \
 -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) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure Bearer (JWT) access token for authorization: bearerAuth
        HttpBearerAuth bearerAuth = (HttpBearerAuth) defaultClient.getAuthentication("bearerAuth");
        bearerAuth.setBearerToken("BEARER TOKEN");

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

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

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

try {
    final result = await api_instance.refresh(refreshToken);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->refresh: $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.refresh(refreshToken);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling LoginControllerApi#refresh");
            e.printStackTrace();
        }
    }
}

Configuration *apiConfig = [Configuration sharedConfig];

// Configure Bearer (JWT) access token for authorization: bearerAuth
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

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

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

var OpenApiDefinition = require('open_api_definition');
var defaultClient = OpenApiDefinition.ApiClient.instance;

// Configure Bearer (JWT) access token for authorization: bearerAuth
var bearerAuth = defaultClient.authentications['bearerAuth'];
bearerAuth.accessToken = "YOUR ACCESS TOKEN";

// 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.refresh(opts, callback);

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

namespace Example
{
    public class refreshExample
    {
        public void main()
        {
            // Configure Bearer (JWT) access token for authorization: bearerAuth
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

            // 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.refresh(refreshToken);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling LoginControllerApi.refresh: " + e.Message );
            }
        }
    }
}

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

// Configure Bearer (JWT) access token for authorization: bearerAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('', 'YOUR_ACCESS_TOKEN');

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

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

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

# Configure Bearer (JWT) access token for authorization: bearerAuth
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

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

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

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

# Configure Bearer (JWT) access token for authorization: bearerAuth
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

# 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(refreshToken=refreshToken)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling LoginControllerApi->refresh: %s\n" % e)

extern crate LoginControllerApi;

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

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

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

Scopes

Parameters

Responses

Schema

Schema

test

Test login endpoint

Check if the login endpoint is accessible.

/api/v1/auth/test

Usage and SDK Samples

curl -X GET \
 -H "Authorization: Bearer [[accessToken]]" \
 -H "Accept: */*" \
 "https://localhost:8443/api/v1/auth/test"

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) {
        ApiClient defaultClient = Configuration.getDefaultApiClient();

        // Configure Bearer (JWT) access token for authorization: bearerAuth
        HttpBearerAuth bearerAuth = (HttpBearerAuth) defaultClient.getAuthentication("bearerAuth");
        bearerAuth.setBearerToken("BEARER TOKEN");

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

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();


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

import org.openapitools.client.api.LoginControllerApi;

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

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

Configuration *apiConfig = [Configuration sharedConfig];

// Configure Bearer (JWT) access token for authorization: bearerAuth
[apiConfig setAccessToken:@"YOUR_ACCESS_TOKEN"];

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

// Test login endpoint
[apiInstance testWithCompletionHandler: 
              ^('String' output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenApiDefinition = require('open_api_definition');
var defaultClient = OpenApiDefinition.ApiClient.instance;

// Configure Bearer (JWT) access token for authorization: bearerAuth
var bearerAuth = defaultClient.authentications['bearerAuth'];
bearerAuth.accessToken = "YOUR ACCESS TOKEN";

// 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.test(callback);

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

namespace Example
{
    public class testExample
    {
        public void main()
        {
            // Configure Bearer (JWT) access token for authorization: bearerAuth
            Configuration.Default.AccessToken = "YOUR_ACCESS_TOKEN";

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

            try {
                // Test login endpoint
                'String' result = apiInstance.test();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling LoginControllerApi.test: " + e.Message );
            }
        }
    }
}

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

// Configure Bearer (JWT) access token for authorization: bearerAuth
OpenAPITools\Client\Configuration::getDefaultConfiguration()->setAccessToken('', 'YOUR_ACCESS_TOKEN');

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

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

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

# Configure Bearer (JWT) access token for authorization: bearerAuth
$WWW::OPenAPIClient::Configuration::access_token = 'YOUR_ACCESS_TOKEN';

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

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

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

# Configure Bearer (JWT) access token for authorization: bearerAuth
openapi_client.configuration.access_token = 'YOUR_ACCESS_TOKEN'

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

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

extern crate LoginControllerApi;

pub fn main() {

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

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

Scopes

Parameters

Responses

Schema

OpenAPI definition

API and SDK Documentation

ApiGraphsController

displayGraph

Usage and SDK Samples

Scopes

Parameters

Responses

displayUserGraph

Usage and SDK Samples

Scopes

Parameters

Responses

ApiProductController

acceptProduct

Usage and SDK Samples

Scopes

Parameters

Responses

addViewsCount

Usage and SDK Samples

Scopes

Parameters

Responses

createProduct

Usage and SDK Samples

Scopes

Parameters

Responses

createProductImage

Usage and SDK Samples

Scopes

Parameters

Responses

deleteProduct

Usage and SDK Samples

Scopes

Parameters

Responses

deleteProduct1

Usage and SDK Samples

Scopes

Parameters

Responses

deleteProductImage1

Usage and SDK Samples

Scopes

Parameters

Responses

getAllProducts

Usage and SDK Samples

Scopes

Parameters

Responses

getAllProductsByType

Usage and SDK Samples

Scopes

Parameters

Responses

getLastProducts

Usage and SDK Samples

Scopes

Parameters

Responses

getMostViewedProducts

Usage and SDK Samples

Scopes

Parameters

Responses

getProductById

Usage and SDK Samples

Scopes

Parameters

Responses

getProductImage

Usage and SDK Samples

Scopes

Parameters

Responses

getProducts