OpenAPI definition

CouponRestController

addCoupon


/api/coupons

Usage and SDK Samples

curl -X POST \
 -H "Accept: */*" \
 -H "Content-Type: application/json" \
 "https://localhost:8080/api/coupons" \
 -d '{
  "dateOfExpiry" : "dateOfExpiry",
  "code" : "code",
  "affectedProducts" : [ {
    "images" : [ "images", "images" ],
    "size" : "XS",
    "price" : 2.3021358869347655,
    "name" : "name",
    "description" : "description",
    "id" : 5,
    "stock" : 7
  }, {
    "images" : [ "images", "images" ],
    "size" : "XS",
    "price" : 2.3021358869347655,
    "name" : "name",
    "description" : "description",
    "id" : 5,
    "stock" : 7
  } ],
  "discount" : 5.962134,
  "id" : 6,
  "type" : "type",
  "minimum" : 1.4658129,
  "startDate" : "startDate"
}'
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.CouponRestControllerApi;

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

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

        // Create an instance of the API class
        CouponRestControllerApi apiInstance = new CouponRestControllerApi();
        Coupon coupon = ; // Coupon | 

        try {
            Coupon result = apiInstance.addCoupon(coupon);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CouponRestControllerApi#addCoupon");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.CouponRestControllerApi;

public class CouponRestControllerApiExample {
    public static void main(String[] args) {
        CouponRestControllerApi apiInstance = new CouponRestControllerApi();
        Coupon coupon = ; // Coupon | 

        try {
            Coupon result = apiInstance.addCoupon(coupon);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CouponRestControllerApi#addCoupon");
            e.printStackTrace();
        }
    }
}


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

[apiInstance addCouponWith:coupon
              completionHandler: ^(Coupon output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var OpenApiDefinition = require('open_api_definition');

// Create an instance of the API class
var api = new OpenApiDefinition.CouponRestControllerApi()
var coupon = ; // {Coupon} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.addCoupon(coupon, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

            // Create an instance of the API class
            var apiInstance = new CouponRestControllerApi();
            var coupon = new Coupon(); // Coupon | 

            try {
                Coupon result = apiInstance.addCoupon(coupon);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling CouponRestControllerApi.addCoupon: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\CouponRestControllerApi();
$coupon = ; // Coupon | 

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::CouponRestControllerApi->new();
my $coupon = WWW::OPenAPIClient::Object::Coupon->new(); # Coupon | 

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

# Create an instance of the API class
api_instance = openapi_client.CouponRestControllerApi()
coupon =  # Coupon | 

try:
    api_response = api_instance.add_coupon(coupon)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling CouponRestControllerApi->addCoupon: %s\n" % e)
extern crate CouponRestControllerApi;

pub fn main() {
    let coupon = ; // Coupon

    let mut context = CouponRestControllerApi::Context::default();
    let result = client.addCoupon(coupon, &context).wait();

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

Scopes

Parameters

Body parameters
Name Description
coupon *

{
id:
integer (int64)
code:
string
type:
string
startDate:
string
dateOfExpiry:
string
minimum:
number (float)
discount:
number (float)
affectedProducts:
[
{
id:
integer (int64)
name:
string
description:
string
price:
number (double)
stock:
integer (int64)
size:
string
Enum: XS, S, M, L, XL
images:
[
string
]
]

Responses

Status: 200 - OK

{
id:
integer (int64)
code:
string
type:
string
startDate:
string
dateOfExpiry:
string
minimum:
number (float)
discount:
number (float)
affectedProducts:
[
{
id:
integer (int64)
name:
string
description:
string
price:
number (double)
stock:
integer (int64)
size:
string
Enum: XS, S, M, L, XL
images:
[
string
]
]

addProductToCoupon


/api/coupons/{couponId}/products/{productId}

Usage and SDK Samples

curl -X POST \
 -H "Accept: */*" \
 "https://localhost:8080/api/coupons/{couponId}/products/{productId}"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.CouponRestControllerApi;

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

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

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

        try {
            Coupon result = apiInstance.addProductToCoupon(couponId, productId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CouponRestControllerApi#addProductToCoupon");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.CouponRestControllerApi;

public class CouponRestControllerApiExample {
    public static void main(String[] args) {
        CouponRestControllerApi apiInstance = new CouponRestControllerApi();
        Long couponId = 789; // Long | 
        Long productId = 789; // Long | 

        try {
            Coupon result = apiInstance.addProductToCoupon(couponId, productId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CouponRestControllerApi#addProductToCoupon");
            e.printStackTrace();
        }
    }
}


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

[apiInstance addProductToCouponWith:couponId
    productId:productId
              completionHandler: ^(Coupon output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var OpenApiDefinition = require('open_api_definition');

// Create an instance of the API class
var api = new OpenApiDefinition.CouponRestControllerApi()
var couponId = 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.addProductToCoupon(couponId, productId, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

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

            try {
                Coupon result = apiInstance.addProductToCoupon(couponId, productId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling CouponRestControllerApi.addProductToCoupon: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

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

try {
    $result = $api_instance->addProductToCoupon($couponId, $productId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling CouponRestControllerApi->addProductToCoupon: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::CouponRestControllerApi;

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

eval {
    my $result = $api_instance->addProductToCoupon(couponId => $couponId, productId => $productId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling CouponRestControllerApi->addProductToCoupon: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

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

try:
    api_response = api_instance.add_product_to_coupon(couponId, productId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling CouponRestControllerApi->addProductToCoupon: %s\n" % e)
extern crate CouponRestControllerApi;

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

    let mut context = CouponRestControllerApi::Context::default();
    let result = client.addProductToCoupon(couponId, productId, &context).wait();

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

Scopes

Parameters

Path parameters
Name Description
couponId*
Long (int64)
Required
productId*
Long (int64)
Required

Responses

Status: 200 - OK

{
id:
integer (int64)
code:
string
type:
string
startDate:
string
dateOfExpiry:
string
minimum:
number (float)
discount:
number (float)
affectedProducts:
[
{
id:
integer (int64)
name:
string
description:
string
price:
number (double)
stock:
integer (int64)
size:
string
Enum: XS, S, M, L, XL
images:
[
string
]
]

deleteProductFromCoupon


/api/coupons/{couponId}/products/{productId}

Usage and SDK Samples

curl -X DELETE \
 -H "Accept: */*" \
 "https://localhost:8080/api/coupons/{couponId}/products/{productId}"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.CouponRestControllerApi;

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

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

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

        try {
            Product result = apiInstance.deleteProductFromCoupon(couponId, productId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CouponRestControllerApi#deleteProductFromCoupon");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.CouponRestControllerApi;

public class CouponRestControllerApiExample {
    public static void main(String[] args) {
        CouponRestControllerApi apiInstance = new CouponRestControllerApi();
        Long couponId = 789; // Long | 
        Long productId = 789; // Long | 

        try {
            Product result = apiInstance.deleteProductFromCoupon(couponId, productId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CouponRestControllerApi#deleteProductFromCoupon");
            e.printStackTrace();
        }
    }
}


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

[apiInstance deleteProductFromCouponWith:couponId
    productId:productId
              completionHandler: ^(Product output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var OpenApiDefinition = require('open_api_definition');

// Create an instance of the API class
var api = new OpenApiDefinition.CouponRestControllerApi()
var couponId = 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.deleteProductFromCoupon(couponId, productId, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

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

            try {
                Product result = apiInstance.deleteProductFromCoupon(couponId, productId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling CouponRestControllerApi.deleteProductFromCoupon: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

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

try {
    $result = $api_instance->deleteProductFromCoupon($couponId, $productId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling CouponRestControllerApi->deleteProductFromCoupon: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::CouponRestControllerApi;

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

eval {
    my $result = $api_instance->deleteProductFromCoupon(couponId => $couponId, productId => $productId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling CouponRestControllerApi->deleteProductFromCoupon: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

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

try:
    api_response = api_instance.delete_product_from_coupon(couponId, productId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling CouponRestControllerApi->deleteProductFromCoupon: %s\n" % e)
extern crate CouponRestControllerApi;

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

    let mut context = CouponRestControllerApi::Context::default();
    let result = client.deleteProductFromCoupon(couponId, productId, &context).wait();

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

Scopes

Parameters

Path parameters
Name Description
couponId*
Long (int64)
Required
productId*
Long (int64)
Required

Responses

Status: 200 - OK

{
id:
integer (int64)
name:
string
description:
string
price:
number (double)
stock:
integer (int64)
size:
string
Enum: XS, S, M, L, XL
images:
[
string
]

editCoupon


/api/coupons/{id}

Usage and SDK Samples

curl -X PUT \
 -H "Accept: */*" \
 -H "Content-Type: application/json" \
 "https://localhost:8080/api/coupons/{id}" \
 -d '{
  "dateOfExpiry" : "dateOfExpiry",
  "code" : "code",
  "affectedProducts" : [ {
    "images" : [ "images", "images" ],
    "size" : "XS",
    "price" : 2.3021358869347655,
    "name" : "name",
    "description" : "description",
    "id" : 5,
    "stock" : 7
  }, {
    "images" : [ "images", "images" ],
    "size" : "XS",
    "price" : 2.3021358869347655,
    "name" : "name",
    "description" : "description",
    "id" : 5,
    "stock" : 7
  } ],
  "discount" : 5.962134,
  "id" : 6,
  "type" : "type",
  "minimum" : 1.4658129,
  "startDate" : "startDate"
}'
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.CouponRestControllerApi;

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

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

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

        try {
            Coupon result = apiInstance.editCoupon(id, coupon);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CouponRestControllerApi#editCoupon");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.CouponRestControllerApi;

public class CouponRestControllerApiExample {
    public static void main(String[] args) {
        CouponRestControllerApi apiInstance = new CouponRestControllerApi();
        Long id = 789; // Long | 
        Coupon coupon = ; // Coupon | 

        try {
            Coupon result = apiInstance.editCoupon(id, coupon);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CouponRestControllerApi#editCoupon");
            e.printStackTrace();
        }
    }
}


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

[apiInstance editCouponWith:id
    coupon:coupon
              completionHandler: ^(Coupon output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var OpenApiDefinition = require('open_api_definition');

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

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.editCoupon(id, coupon, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

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

            try {
                Coupon result = apiInstance.editCoupon(id, coupon);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling CouponRestControllerApi.editCoupon: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

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

try {
    $result = $api_instance->editCoupon($id, $coupon);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling CouponRestControllerApi->editCoupon: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::CouponRestControllerApi;

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

eval {
    my $result = $api_instance->editCoupon(id => $id, coupon => $coupon);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling CouponRestControllerApi->editCoupon: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

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

try:
    api_response = api_instance.edit_coupon(id, coupon)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling CouponRestControllerApi->editCoupon: %s\n" % e)
extern crate CouponRestControllerApi;

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

    let mut context = CouponRestControllerApi::Context::default();
    let result = client.editCoupon(id, coupon, &context).wait();

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

Scopes

Parameters

Path parameters
Name Description
id*
Long (int64)
Required
Body parameters
Name Description
coupon *

{
id:
integer (int64)
code:
string
type:
string
startDate:
string
dateOfExpiry:
string
minimum:
number (float)
discount:
number (float)
affectedProducts:
[
{
id:
integer (int64)
name:
string
description:
string
price:
number (double)
stock:
integer (int64)
size:
string
Enum: XS, S, M, L, XL
images:
[
string
]
]

Responses

Status: 200 - OK

{
id:
integer (int64)
code:
string
type:
string
startDate:
string
dateOfExpiry:
string
minimum:
number (float)
discount:
number (float)
affectedProducts:
[
{
id:
integer (int64)
name:
string
description:
string
price:
number (double)
stock:
integer (int64)
size:
string
Enum: XS, S, M, L, XL
images:
[
string
]
]

getCoupon


/api/coupons

Usage and SDK Samples

curl -X GET \
 -H "Accept: */*" \
 "https://localhost:8080/api/coupons?page=56"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.CouponRestControllerApi;

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

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

        // Create an instance of the API class
        CouponRestControllerApi apiInstance = new CouponRestControllerApi();
        Integer page = 56; // Integer | 

        try {
            array[Coupon] result = apiInstance.getCoupon(page);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CouponRestControllerApi#getCoupon");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.CouponRestControllerApi;

public class CouponRestControllerApiExample {
    public static void main(String[] args) {
        CouponRestControllerApi apiInstance = new CouponRestControllerApi();
        Integer page = 56; // Integer | 

        try {
            array[Coupon] result = apiInstance.getCoupon(page);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CouponRestControllerApi#getCoupon");
            e.printStackTrace();
        }
    }
}


// Create an instance of the API class
CouponRestControllerApi *apiInstance = [[CouponRestControllerApi alloc] init];
Integer *page = 56; //  (optional) (default to null)

[apiInstance getCouponWith:page
              completionHandler: ^(array[Coupon] output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var OpenApiDefinition = require('open_api_definition');

// Create an instance of the API class
var api = new OpenApiDefinition.CouponRestControllerApi()
var opts = {
  'page': 56 // {Integer} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getCoupon(opts, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

            // Create an instance of the API class
            var apiInstance = new CouponRestControllerApi();
            var page = 56;  // Integer |  (optional)  (default to null)

            try {
                array[Coupon] result = apiInstance.getCoupon(page);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling CouponRestControllerApi.getCoupon: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\CouponRestControllerApi();
$page = 56; // Integer | 

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::CouponRestControllerApi->new();
my $page = 56; # Integer | 

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

# Create an instance of the API class
api_instance = openapi_client.CouponRestControllerApi()
page = 56 # Integer |  (optional) (default to null)

try:
    api_response = api_instance.get_coupon(page=page)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling CouponRestControllerApi->getCoupon: %s\n" % e)
extern crate CouponRestControllerApi;

pub fn main() {
    let page = 56; // Integer

    let mut context = CouponRestControllerApi::Context::default();
    let result = client.getCoupon(page, &context).wait();

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

Scopes

Parameters

Query parameters
Name Description
page
Integer (int32)

Responses

Status: 200 - OK

[
{
id:
integer (int64)
code:
string
type:
string
startDate:
string
dateOfExpiry:
string
minimum:
number (float)
discount:
number (float)
affectedProducts:
[
{
id:
integer (int64)
name:
string
description:
string
price:
number (double)
stock:
integer (int64)
size:
string
Enum: XS, S, M, L, XL
images:
[
string
]
]
]

getTransactionById1


/api/coupons/{id}

Usage and SDK Samples

curl -X GET \
 -H "Accept: */*" \
 "https://localhost:8080/api/coupons/{id}"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.CouponRestControllerApi;

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

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

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

        try {
            Coupon result = apiInstance.getTransactionById1(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CouponRestControllerApi#getTransactionById1");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.CouponRestControllerApi;

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

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


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

[apiInstance getTransactionById1With:id
              completionHandler: ^(Coupon output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var OpenApiDefinition = require('open_api_definition');

// Create an instance of the API class
var api = new OpenApiDefinition.CouponRestControllerApi()
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.getTransactionById1(id, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

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

            try {
                Coupon result = apiInstance.getTransactionById1(id);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling CouponRestControllerApi.getTransactionById1: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

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

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

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

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

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

try:
    api_response = api_instance.get_transaction_by_id1(id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling CouponRestControllerApi->getTransactionById1: %s\n" % e)
extern crate CouponRestControllerApi;

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

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

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

Scopes

Parameters

Path parameters
Name Description
id*
Long (int64)
Required

Responses

Status: 200 - OK

{
id:
integer (int64)
code:
string
type:
string
startDate:
string
dateOfExpiry:
string
minimum:
number (float)
discount:
number (float)
affectedProducts:
[
{
id:
integer (int64)
name:
string
description:
string
price:
number (double)
stock:
integer (int64)
size:
string
Enum: XS, S, M, L, XL
images:
[
string
]
]

removeCoupon


/api/coupons/{id}

Usage and SDK Samples

curl -X DELETE \
 -H "Accept: */*" \
 "https://localhost:8080/api/coupons/{id}"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.CouponRestControllerApi;

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

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

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

        try {
            Coupon result = apiInstance.removeCoupon(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CouponRestControllerApi#removeCoupon");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.CouponRestControllerApi;

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

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


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

[apiInstance removeCouponWith:id
              completionHandler: ^(Coupon output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var OpenApiDefinition = require('open_api_definition');

// Create an instance of the API class
var api = new OpenApiDefinition.CouponRestControllerApi()
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.removeCoupon(id, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

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

            try {
                Coupon result = apiInstance.removeCoupon(id);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling CouponRestControllerApi.removeCoupon: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

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

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

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

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

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

try:
    api_response = api_instance.remove_coupon(id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling CouponRestControllerApi->removeCoupon: %s\n" % e)
extern crate CouponRestControllerApi;

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

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

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

Scopes

Parameters

Path parameters
Name Description
id*
Long (int64)
Required

Responses

Status: 200 - OK

{
id:
integer (int64)
code:
string
type:
string
startDate:
string
dateOfExpiry:
string
minimum:
number (float)
discount:
number (float)
affectedProducts:
[
{
id:
integer (int64)
name:
string
description:
string
price:
number (double)
stock:
integer (int64)
size:
string
Enum: XS, S, M, L, XL
images:
[
string
]
]

LoginController

logOut


/api/auth/logout

Usage and SDK Samples

curl -X POST \
 -H "Accept: */*" \
 "https://localhost:8080/api/auth/logout"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.LoginControllerApi;

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

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

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

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

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

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


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

[apiInstance logOutWithCompletionHandler: 
              ^(AuthResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var OpenApiDefinition = require('open_api_definition');

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

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

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

            try {
                AuthResponse result = apiInstance.logOut();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling LoginControllerApi.logOut: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

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

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

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

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

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

try:
    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

Status: 200 - OK

{
status:
string
Enum: SUCCESS, FAILURE
message:
string
error:
string

login


/api/auth/login

Usage and SDK Samples

curl -X POST \
 -H "Accept: */*" \
 -H "Content-Type: application/json" \
 "https://localhost:8080/api/auth/login" \
 -d '{
  "password" : "password",
  "username" : "username"
}'
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.LoginControllerApi;

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

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

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

        try {
            AuthResponse result = apiInstance.login(loginRequest, accessToken, refreshToken);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling LoginControllerApi#login");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.LoginControllerApi;

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

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


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

[apiInstance loginWith:loginRequest
    accessToken:accessToken
    refreshToken:refreshToken
              completionHandler: ^(AuthResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var OpenApiDefinition = require('open_api_definition');

// Create an instance of the API class
var api = new OpenApiDefinition.LoginControllerApi()
var loginRequest = ; // {LoginRequest} 
var opts = {
  'accessToken': accessToken_example, // {String} 
  '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.login(loginRequest, opts, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

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

            try {
                AuthResponse result = apiInstance.login(loginRequest, accessToken, refreshToken);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling LoginControllerApi.login: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

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

try {
    $result = $api_instance->login($loginRequest, $accessToken, $refreshToken);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling LoginControllerApi->login: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::LoginControllerApi;

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

eval {
    my $result = $api_instance->login(loginRequest => $loginRequest, accessToken => $accessToken, refreshToken => $refreshToken);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling LoginControllerApi->login: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

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

try:
    api_response = api_instance.login(loginRequest, accessToken=accessToken, refreshToken=refreshToken)
    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 accessToken = accessToken_example; // String
    let refreshToken = refreshToken_example; // String

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

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

Scopes

Parameters

Body parameters
Name Description
loginRequest *

{
username:
string
password:
string

Responses

Status: 200 - OK

{
status:
string
Enum: SUCCESS, FAILURE
message:
string
error:
string

refreshToken


/api/auth/refresh

Usage and SDK Samples

curl -X POST \
 -H "Accept: */*" \
 "https://localhost:8080/api/auth/refresh"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.LoginControllerApi;

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

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

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

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

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

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


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

[apiInstance refreshTokenWith:refreshToken
              completionHandler: ^(AuthResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var OpenApiDefinition = require('open_api_definition');

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

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.refreshToken(opts, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

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

            try {
                AuthResponse result = apiInstance.refreshToken(refreshToken);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling LoginControllerApi.refreshToken: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

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

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

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

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

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

try:
    api_response = api_instance.refresh_token(refreshToken=refreshToken)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling LoginControllerApi->refreshToken: %s\n" % e)
extern crate LoginControllerApi;

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

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

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

Scopes

Parameters

Responses

Status: 200 - OK

{
status:
string
Enum: SUCCESS, FAILURE
message:
string
error:
string

ProductRestController

createProduct


/api/products

Usage and SDK Samples

curl -X POST \
 -H "Accept: */*" \
 -H "Content-Type: application/json" \
 "https://localhost:8080/api/products" \
 -d '{
  "size" : "XS",
  "price" : 0.8008281904610115,
  "name" : "name",
  "description" : "description",
  "stock" : 6
}'
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.ProductRestControllerApi;

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

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

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

        try {
            Product result = apiInstance.createProduct(productNoImagesDTO);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProductRestControllerApi#createProduct");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.ProductRestControllerApi;

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

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


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

[apiInstance createProductWith:productNoImagesDTO
              completionHandler: ^(Product output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var OpenApiDefinition = require('open_api_definition');

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

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.createProduct(productNoImagesDTO, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

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

            try {
                Product result = apiInstance.createProduct(productNoImagesDTO);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ProductRestControllerApi.createProduct: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

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

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

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

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

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

try:
    api_response = api_instance.create_product(productNoImagesDTO)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ProductRestControllerApi->createProduct: %s\n" % e)
extern crate ProductRestControllerApi;

pub fn main() {
    let productNoImagesDTO = ; // ProductNoImagesDTO

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

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

Scopes

Parameters

Body parameters
Name Description
productNoImagesDTO *

{
name:
string
description:
string
price:
number (double)
stock:
integer (int64)
size:
string
Enum: XS, S, M, L, XL

Responses

Status: 200 - OK

{
id:
integer (int64)
name:
string
description:
string
price:
number (double)
stock:
integer (int64)
size:
string
Enum: XS, S, M, L, XL
images:
[
string
]

deleteAllImage


/api/products/{productId}/image

Usage and SDK Samples

curl -X DELETE \
 -H "Accept: */*" \
 "https://localhost:8080/api/products/{productId}/image"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.ProductRestControllerApi;

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

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

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

        try {
            Object result = apiInstance.deleteAllImage(productId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProductRestControllerApi#deleteAllImage");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.ProductRestControllerApi;

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

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


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

[apiInstance deleteAllImageWith:productId
              completionHandler: ^(Object output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var OpenApiDefinition = require('open_api_definition');

// Create an instance of the API class
var api = new OpenApiDefinition.ProductRestControllerApi()
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.deleteAllImage(productId, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

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

            try {
                Object result = apiInstance.deleteAllImage(productId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ProductRestControllerApi.deleteAllImage: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

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

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

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

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

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

try:
    api_response = api_instance.delete_all_image(productId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ProductRestControllerApi->deleteAllImage: %s\n" % e)
extern crate ProductRestControllerApi;

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

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

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

Scopes

Parameters

Path parameters
Name Description
productId*
Long (int64)
Required

Responses

Status: 200 - OK

deleteImage


/api/products/{productId}/image/{imageIndex}

Usage and SDK Samples

curl -X DELETE \
 -H "Accept: */*" \
 "https://localhost:8080/api/products/{productId}/image/{imageIndex}"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.ProductRestControllerApi;

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

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

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

        try {
            Object result = apiInstance.deleteImage(productId, imageIndex);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProductRestControllerApi#deleteImage");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.ProductRestControllerApi;

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

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


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

[apiInstance deleteImageWith:productId
    imageIndex:imageIndex
              completionHandler: ^(Object output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var OpenApiDefinition = require('open_api_definition');

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

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.deleteImage(productId, imageIndex, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

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

            try {
                Object result = apiInstance.deleteImage(productId, imageIndex);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ProductRestControllerApi.deleteImage: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

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

try {
    $result = $api_instance->deleteImage($productId, $imageIndex);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ProductRestControllerApi->deleteImage: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::ProductRestControllerApi;

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

eval {
    my $result = $api_instance->deleteImage(productId => $productId, imageIndex => $imageIndex);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ProductRestControllerApi->deleteImage: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

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

try:
    api_response = api_instance.delete_image(productId, imageIndex)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ProductRestControllerApi->deleteImage: %s\n" % e)
extern crate ProductRestControllerApi;

pub fn main() {
    let productId = 789; // Long
    let imageIndex = 56; // Integer

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

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

Scopes

Parameters

Path parameters
Name Description
productId*
Long (int64)
Required
imageIndex*
Integer (int32)
Required

Responses

Status: 200 - OK

deleteProduct


/api/products/{id}

Usage and SDK Samples

curl -X DELETE \
 -H "Accept: */*" \
 "https://localhost:8080/api/products/{id}"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.ProductRestControllerApi;

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

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

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

        try {
            Product result = apiInstance.deleteProduct(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProductRestControllerApi#deleteProduct");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.ProductRestControllerApi;

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

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


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

[apiInstance deleteProductWith:id
              completionHandler: ^(Product output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var OpenApiDefinition = require('open_api_definition');

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

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.deleteProduct(id, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

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

            try {
                Product result = apiInstance.deleteProduct(id);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ProductRestControllerApi.deleteProduct: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

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

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

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

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

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

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

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

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

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

Scopes

Parameters

Path parameters
Name Description
id*
Long (int64)
Required

Responses

Status: 200 - OK

{
id:
integer (int64)
name:
string
description:
string
price:
number (double)
stock:
integer (int64)
size:
string
Enum: XS, S, M, L, XL
images:
[
string
]

getProduct


/api/products

Usage and SDK Samples

curl -X GET \
 -H "Accept: */*" \
 "https://localhost:8080/api/products?name=name_example&size=size_example&page=56"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.ProductRestControllerApi;

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

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

        // Create an instance of the API class
        ProductRestControllerApi apiInstance = new ProductRestControllerApi();
        String name = name_example; // String | 
        String size = size_example; // String | 
        Integer page = 56; // Integer | 

        try {
            array[Product] result = apiInstance.getProduct(name, size, page);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProductRestControllerApi#getProduct");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.ProductRestControllerApi;

public class ProductRestControllerApiExample {
    public static void main(String[] args) {
        ProductRestControllerApi apiInstance = new ProductRestControllerApi();
        String name = name_example; // String | 
        String size = size_example; // String | 
        Integer page = 56; // Integer | 

        try {
            array[Product] result = apiInstance.getProduct(name, size, page);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProductRestControllerApi#getProduct");
            e.printStackTrace();
        }
    }
}


// Create an instance of the API class
ProductRestControllerApi *apiInstance = [[ProductRestControllerApi alloc] init];
String *name = name_example; //  (optional) (default to null)
String *size = size_example; //  (optional) (default to null)
Integer *page = 56; //  (optional) (default to null)

[apiInstance getProductWith:name
    size:size
    page:page
              completionHandler: ^(array[Product] output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var OpenApiDefinition = require('open_api_definition');

// Create an instance of the API class
var api = new OpenApiDefinition.ProductRestControllerApi()
var opts = {
  'name': name_example, // {String} 
  'size': size_example, // {String} 
  'page': 56 // {Integer} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getProduct(opts, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

            // Create an instance of the API class
            var apiInstance = new ProductRestControllerApi();
            var name = name_example;  // String |  (optional)  (default to null)
            var size = size_example;  // String |  (optional)  (default to null)
            var page = 56;  // Integer |  (optional)  (default to null)

            try {
                array[Product] result = apiInstance.getProduct(name, size, page);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ProductRestControllerApi.getProduct: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ProductRestControllerApi();
$name = name_example; // String | 
$size = size_example; // String | 
$page = 56; // Integer | 

try {
    $result = $api_instance->getProduct($name, $size, $page);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ProductRestControllerApi->getProduct: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::ProductRestControllerApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ProductRestControllerApi->new();
my $name = name_example; # String | 
my $size = size_example; # String | 
my $page = 56; # Integer | 

eval {
    my $result = $api_instance->getProduct(name => $name, size => $size, page => $page);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ProductRestControllerApi->getProduct: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Create an instance of the API class
api_instance = openapi_client.ProductRestControllerApi()
name = name_example # String |  (optional) (default to null)
size = size_example # String |  (optional) (default to null)
page = 56 # Integer |  (optional) (default to null)

try:
    api_response = api_instance.get_product(name=name, size=size, page=page)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ProductRestControllerApi->getProduct: %s\n" % e)
extern crate ProductRestControllerApi;

pub fn main() {
    let name = name_example; // String
    let size = size_example; // String
    let page = 56; // Integer

    let mut context = ProductRestControllerApi::Context::default();
    let result = client.getProduct(name, size, page, &context).wait();

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

Scopes

Parameters

Query parameters
Name Description
name
String
size
String
page
Integer (int32)

Responses

Status: 200 - OK

[
{
id:
integer (int64)
name:
string
description:
string
price:
number (double)
stock:
integer (int64)
size:
string
Enum: XS, S, M, L, XL
images:
[
string
]
]

getProduct1


/api/products/{id}

Usage and SDK Samples

curl -X GET \
 -H "Accept: */*" \
 "https://localhost:8080/api/products/{id}"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.ProductRestControllerApi;

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

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

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

        try {
            Product result = apiInstance.getProduct1(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProductRestControllerApi#getProduct1");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.ProductRestControllerApi;

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

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


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

[apiInstance getProduct1With:id
              completionHandler: ^(Product output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var OpenApiDefinition = require('open_api_definition');

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

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getProduct1(id, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

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

            try {
                Product result = apiInstance.getProduct1(id);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ProductRestControllerApi.getProduct1: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

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

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

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

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

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

try:
    api_response = api_instance.get_product1(id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ProductRestControllerApi->getProduct1: %s\n" % e)
extern crate ProductRestControllerApi;

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

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

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

Scopes

Parameters

Path parameters
Name Description
id*
Long (int64)
Required

Responses

Status: 200 - OK

{
id:
integer (int64)
name:
string
description:
string
price:
number (double)
stock:
integer (int64)
size:
string
Enum: XS, S, M, L, XL
images:
[
string
]

getProductImage


/api/products/{productId}/image/{imageIndex}

Usage and SDK Samples

curl -X GET \
 -H "Accept: */*" \
 "https://localhost:8080/api/products/{productId}/image/{imageIndex}"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.ProductRestControllerApi;

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

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

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

        try {
            Object result = apiInstance.getProductImage(productId, imageIndex);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProductRestControllerApi#getProductImage");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.ProductRestControllerApi;

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

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


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

[apiInstance getProductImageWith:productId
    imageIndex:imageIndex
              completionHandler: ^(Object output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var OpenApiDefinition = require('open_api_definition');

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

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getProductImage(productId, imageIndex, 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()
        {

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

            try {
                Object result = apiInstance.getProductImage(productId, imageIndex);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ProductRestControllerApi.getProductImage: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

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

try {
    $result = $api_instance->getProductImage($productId, $imageIndex);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ProductRestControllerApi->getProductImage: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::ProductRestControllerApi;

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

eval {
    my $result = $api_instance->getProductImage(productId => $productId, imageIndex => $imageIndex);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ProductRestControllerApi->getProductImage: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

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

try:
    api_response = api_instance.get_product_image(productId, imageIndex)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ProductRestControllerApi->getProductImage: %s\n" % e)
extern crate ProductRestControllerApi;

pub fn main() {
    let productId = 789; // Long
    let imageIndex = 56; // Integer

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

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

Scopes

Parameters

Path parameters
Name Description
productId*
Long (int64)
Required
imageIndex*
Integer (int32)
Required

Responses

Status: 200 - OK

replaceProduct


/api/products/{id}

Usage and SDK Samples

curl -X PUT \
 -H "Accept: */*" \
 -H "Content-Type: application/json" \
 "https://localhost:8080/api/products/{id}" \
 -d '{
  "size" : "XS",
  "price" : 0.8008281904610115,
  "name" : "name",
  "description" : "description",
  "stock" : 6
}'
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.ProductRestControllerApi;

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

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

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

        try {
            Product result = apiInstance.replaceProduct(id, productNoImagesDTO);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProductRestControllerApi#replaceProduct");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.ProductRestControllerApi;

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

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


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

[apiInstance replaceProductWith:id
    productNoImagesDTO:productNoImagesDTO
              completionHandler: ^(Product output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var OpenApiDefinition = require('open_api_definition');

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

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.replaceProduct(id, productNoImagesDTO, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

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

            try {
                Product result = apiInstance.replaceProduct(id, productNoImagesDTO);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ProductRestControllerApi.replaceProduct: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

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

try {
    $result = $api_instance->replaceProduct($id, $productNoImagesDTO);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ProductRestControllerApi->replaceProduct: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::ProductRestControllerApi;

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

eval {
    my $result = $api_instance->replaceProduct(id => $id, productNoImagesDTO => $productNoImagesDTO);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ProductRestControllerApi->replaceProduct: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

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

try:
    api_response = api_instance.replace_product(id, productNoImagesDTO)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ProductRestControllerApi->replaceProduct: %s\n" % e)
extern crate ProductRestControllerApi;

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

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

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

Scopes

Parameters

Path parameters
Name Description
id*
Long (int64)
Required
Body parameters
Name Description
productNoImagesDTO *

{
name:
string
description:
string
price:
number (double)
stock:
integer (int64)
size:
string
Enum: XS, S, M, L, XL

Responses

Status: 200 - OK

{
id:
integer (int64)
name:
string
description:
string
price:
number (double)
stock:
integer (int64)
size:
string
Enum: XS, S, M, L, XL
images:
[
string
]

saveProductImage


/api/products/{productId}/image

Usage and SDK Samples

curl -X POST \
 -H "Accept: */*" \
 -H "Content-Type: application/json" \
 "https://localhost:8080/api/products/{productId}/image" \
 -d ''
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.ProductRestControllerApi;

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

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

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

        try {
            Object result = apiInstance.saveProductImage(productId, inlineObject);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ProductRestControllerApi#saveProductImage");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.ProductRestControllerApi;

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

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


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

[apiInstance saveProductImageWith:productId
    inlineObject:inlineObject
              completionHandler: ^(Object output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var OpenApiDefinition = require('open_api_definition');

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

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.saveProductImage(productId, opts, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

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

            try {
                Object result = apiInstance.saveProductImage(productId, inlineObject);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ProductRestControllerApi.saveProductImage: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

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

try {
    $result = $api_instance->saveProductImage($productId, $inlineObject);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ProductRestControllerApi->saveProductImage: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::ProductRestControllerApi;

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

eval {
    my $result = $api_instance->saveProductImage(productId => $productId, inlineObject => $inlineObject);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ProductRestControllerApi->saveProductImage: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

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

try:
    api_response = api_instance.save_product_image(productId, inlineObject=inlineObject)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ProductRestControllerApi->saveProductImage: %s\n" % e)
extern crate ProductRestControllerApi;

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

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

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

Scopes

Parameters

Path parameters
Name Description
productId*
Long (int64)
Required
Body parameters
Name Description
inlineObject

{
Required: imageFile
imageFile:
string (binary)

Responses

Status: 200 - OK

RestTransactionController

addProductToTransaction


/api/transactions/{transactionId}/products/{productId}

Usage and SDK Samples

curl -X POST \
 -H "Accept: */*" \
 "https://localhost:8080/api/transactions/{transactionId}/products/{productId}"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.RestTransactionControllerApi;

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

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

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

        try {
            Transaction result = apiInstance.addProductToTransaction(transactionId, productId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling RestTransactionControllerApi#addProductToTransaction");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.RestTransactionControllerApi;

public class RestTransactionControllerApiExample {
    public static void main(String[] args) {
        RestTransactionControllerApi apiInstance = new RestTransactionControllerApi();
        Long transactionId = 789; // Long | 
        Long productId = 789; // Long | 

        try {
            Transaction result = apiInstance.addProductToTransaction(transactionId, productId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling RestTransactionControllerApi#addProductToTransaction");
            e.printStackTrace();
        }
    }
}


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

[apiInstance addProductToTransactionWith:transactionId
    productId:productId
              completionHandler: ^(Transaction output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var OpenApiDefinition = require('open_api_definition');

// Create an instance of the API class
var api = new OpenApiDefinition.RestTransactionControllerApi()
var transactionId = 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.addProductToTransaction(transactionId, productId, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

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

            try {
                Transaction result = apiInstance.addProductToTransaction(transactionId, productId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling RestTransactionControllerApi.addProductToTransaction: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

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

try {
    $result = $api_instance->addProductToTransaction($transactionId, $productId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling RestTransactionControllerApi->addProductToTransaction: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::RestTransactionControllerApi;

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

eval {
    my $result = $api_instance->addProductToTransaction(transactionId => $transactionId, productId => $productId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling RestTransactionControllerApi->addProductToTransaction: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

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

try:
    api_response = api_instance.add_product_to_transaction(transactionId, productId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling RestTransactionControllerApi->addProductToTransaction: %s\n" % e)
extern crate RestTransactionControllerApi;

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

    let mut context = RestTransactionControllerApi::Context::default();
    let result = client.addProductToTransaction(transactionId, productId, &context).wait();

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

Scopes

Parameters

Path parameters
Name Description
transactionId*
Long (int64)
Required
productId*
Long (int64)
Required

Responses

Status: 200 - OK

{
id:
integer (int64)
type:
string
user:
{
id:
integer (int64)
username:
string
email:
string
name:
string
lastName:
string
password:
string
address:
string
mobileNumber:
integer (int32)
birthdate:
string
role:
string
usedCoupon:
{
id:
integer (int64)
code:
string
type:
string
startDate:
string
dateOfExpiry:
string
minimum:
number (float)
discount:
number (float)
affectedProducts:
[
{
id:
integer (int64)
name:
string
description:
string
price:
number (double)
stock:
integer (int64)
size:
string
Enum: XS, S, M, L, XL
images:
[
string
]
]
date:
string
totalPrice:
number (double)
products:
[
{
id:
integer (int64)
name:
string
description:
string
price:
number (double)
stock:
integer (int64)
size:
string
Enum: XS, S, M, L, XL
images:
[
string
]
]

addTransaction


/api/transactions

Usage and SDK Samples

curl -X POST \
 -H "Accept: */*" \
 -H "Content-Type: application/json" \
 "https://localhost:8080/api/transactions" \
 -d '{
  "date" : "date",
  "totalPrice" : 9.301444243932576,
  "id" : 0,
  "type" : "type",
  "user" : {
    "lastName" : "lastName",
    "password" : "password",
    "address" : "address",
    "birthdate" : "birthdate",
    "role" : "role",
    "mobileNumber" : 6,
    "name" : "name",
    "id" : 0,
    "email" : "email",
    "username" : "username"
  },
  "usedCoupon" : {
    "dateOfExpiry" : "dateOfExpiry",
    "code" : "code",
    "affectedProducts" : [ {
      "images" : [ "images", "images" ],
      "size" : "XS",
      "price" : 2.3021358869347655,
      "name" : "name",
      "description" : "description",
      "id" : 5,
      "stock" : 7
    }, {
      "images" : [ "images", "images" ],
      "size" : "XS",
      "price" : 2.3021358869347655,
      "name" : "name",
      "description" : "description",
      "id" : 5,
      "stock" : 7
    } ],
    "discount" : 5.962134,
    "id" : 6,
    "type" : "type",
    "minimum" : 1.4658129,
    "startDate" : "startDate"
  },
  "products" : [ {
    "images" : [ "images", "images" ],
    "size" : "XS",
    "price" : 2.3021358869347655,
    "name" : "name",
    "description" : "description",
    "id" : 5,
    "stock" : 7
  }, {
    "images" : [ "images", "images" ],
    "size" : "XS",
    "price" : 2.3021358869347655,
    "name" : "name",
    "description" : "description",
    "id" : 5,
    "stock" : 7
  } ]
}'
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.RestTransactionControllerApi;

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

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

        // Create an instance of the API class
        RestTransactionControllerApi apiInstance = new RestTransactionControllerApi();
        Transaction transaction = ; // Transaction | 

        try {
            Transaction result = apiInstance.addTransaction(transaction);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling RestTransactionControllerApi#addTransaction");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.RestTransactionControllerApi;

public class RestTransactionControllerApiExample {
    public static void main(String[] args) {
        RestTransactionControllerApi apiInstance = new RestTransactionControllerApi();
        Transaction transaction = ; // Transaction | 

        try {
            Transaction result = apiInstance.addTransaction(transaction);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling RestTransactionControllerApi#addTransaction");
            e.printStackTrace();
        }
    }
}


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

[apiInstance addTransactionWith:transaction
              completionHandler: ^(Transaction output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var OpenApiDefinition = require('open_api_definition');

// Create an instance of the API class
var api = new OpenApiDefinition.RestTransactionControllerApi()
var transaction = ; // {Transaction} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.addTransaction(transaction, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

            // Create an instance of the API class
            var apiInstance = new RestTransactionControllerApi();
            var transaction = new Transaction(); // Transaction | 

            try {
                Transaction result = apiInstance.addTransaction(transaction);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling RestTransactionControllerApi.addTransaction: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\RestTransactionControllerApi();
$transaction = ; // Transaction | 

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::RestTransactionControllerApi->new();
my $transaction = WWW::OPenAPIClient::Object::Transaction->new(); # Transaction | 

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

# Create an instance of the API class
api_instance = openapi_client.RestTransactionControllerApi()
transaction =  # Transaction | 

try:
    api_response = api_instance.add_transaction(transaction)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling RestTransactionControllerApi->addTransaction: %s\n" % e)
extern crate RestTransactionControllerApi;

pub fn main() {
    let transaction = ; // Transaction

    let mut context = RestTransactionControllerApi::Context::default();
    let result = client.addTransaction(transaction, &context).wait();

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

Scopes

Parameters

Body parameters
Name Description
transaction *

{
id:
integer (int64)
type:
string
user:
{
id:
username:
email:
name:
lastName:
password:
address:
mobileNumber:
birthdate:
role:
usedCoupon:
{
id:
code:
type:
startDate:
dateOfExpiry:
minimum:
discount:
affectedProducts:
date:
string
totalPrice:
number (double)
products:
[
{
id:
integer (int64)
name:
string
description:
string
price:
number (double)
stock:
integer (int64)
size:
string
Enum: XS, S, M, L, XL
images:
[
string
]
]

Responses

Status: 200 - OK

{
id:
integer (int64)
type:
string
user:
{
id:
integer (int64)
username:
string
email:
string
name:
string
lastName:
string
password:
string
address:
string
mobileNumber:
integer (int32)
birthdate:
string
role:
string
usedCoupon:
{
id:
integer (int64)
code:
string
type:
string
startDate:
string
dateOfExpiry:
string
minimum:
number (float)
discount:
number (float)
affectedProducts:
[
{
id:
integer (int64)
name:
string
description:
string
price:
number (double)
stock:
integer (int64)
size:
string
Enum: XS, S, M, L, XL
images:
[
string
]
]
date:
string
totalPrice:
number (double)
products:
[
{
id:
integer (int64)
name:
string
description:
string
price:
number (double)
stock:
integer (int64)
size:
string
Enum: XS, S, M, L, XL
images:
[
string
]
]

deleteProductFromTransaction


/api/transactions/{transactionId}/products/{productId}

Usage and SDK Samples

curl -X DELETE \
 -H "Accept: */*" \
 "https://localhost:8080/api/transactions/{transactionId}/products/{productId}"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.RestTransactionControllerApi;

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

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

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

        try {
            Product result = apiInstance.deleteProductFromTransaction(transactionId, productId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling RestTransactionControllerApi#deleteProductFromTransaction");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.RestTransactionControllerApi;

public class RestTransactionControllerApiExample {
    public static void main(String[] args) {
        RestTransactionControllerApi apiInstance = new RestTransactionControllerApi();
        Long transactionId = 789; // Long | 
        Long productId = 789; // Long | 

        try {
            Product result = apiInstance.deleteProductFromTransaction(transactionId, productId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling RestTransactionControllerApi#deleteProductFromTransaction");
            e.printStackTrace();
        }
    }
}


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

[apiInstance deleteProductFromTransactionWith:transactionId
    productId:productId
              completionHandler: ^(Product output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var OpenApiDefinition = require('open_api_definition');

// Create an instance of the API class
var api = new OpenApiDefinition.RestTransactionControllerApi()
var transactionId = 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.deleteProductFromTransaction(transactionId, productId, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

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

            try {
                Product result = apiInstance.deleteProductFromTransaction(transactionId, productId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling RestTransactionControllerApi.deleteProductFromTransaction: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

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

try {
    $result = $api_instance->deleteProductFromTransaction($transactionId, $productId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling RestTransactionControllerApi->deleteProductFromTransaction: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::RestTransactionControllerApi;

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

eval {
    my $result = $api_instance->deleteProductFromTransaction(transactionId => $transactionId, productId => $productId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling RestTransactionControllerApi->deleteProductFromTransaction: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

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

try:
    api_response = api_instance.delete_product_from_transaction(transactionId, productId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling RestTransactionControllerApi->deleteProductFromTransaction: %s\n" % e)
extern crate RestTransactionControllerApi;

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

    let mut context = RestTransactionControllerApi::Context::default();
    let result = client.deleteProductFromTransaction(transactionId, productId, &context).wait();

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

Scopes

Parameters

Path parameters
Name Description
transactionId*
Long (int64)
Required
productId*
Long (int64)
Required

Responses

Status: 200 - OK

{
id:
integer (int64)
name:
string
description:
string
price:
number (double)
stock:
integer (int64)
size:
string
Enum: XS, S, M, L, XL
images:
[
string
]

editTransaction


/api/transactions/{id}

Usage and SDK Samples

curl -X PUT \
 -H "Accept: */*" \
 -H "Content-Type: application/json" \
 "https://localhost:8080/api/transactions/{id}" \
 -d '{
  "date" : "date",
  "totalPrice" : 9.301444243932576,
  "id" : 0,
  "type" : "type",
  "user" : {
    "lastName" : "lastName",
    "password" : "password",
    "address" : "address",
    "birthdate" : "birthdate",
    "role" : "role",
    "mobileNumber" : 6,
    "name" : "name",
    "id" : 0,
    "email" : "email",
    "username" : "username"
  },
  "usedCoupon" : {
    "dateOfExpiry" : "dateOfExpiry",
    "code" : "code",
    "affectedProducts" : [ {
      "images" : [ "images", "images" ],
      "size" : "XS",
      "price" : 2.3021358869347655,
      "name" : "name",
      "description" : "description",
      "id" : 5,
      "stock" : 7
    }, {
      "images" : [ "images", "images" ],
      "size" : "XS",
      "price" : 2.3021358869347655,
      "name" : "name",
      "description" : "description",
      "id" : 5,
      "stock" : 7
    } ],
    "discount" : 5.962134,
    "id" : 6,
    "type" : "type",
    "minimum" : 1.4658129,
    "startDate" : "startDate"
  },
  "products" : [ {
    "images" : [ "images", "images" ],
    "size" : "XS",
    "price" : 2.3021358869347655,
    "name" : "name",
    "description" : "description",
    "id" : 5,
    "stock" : 7
  }, {
    "images" : [ "images", "images" ],
    "size" : "XS",
    "price" : 2.3021358869347655,
    "name" : "name",
    "description" : "description",
    "id" : 5,
    "stock" : 7
  } ]
}'
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.RestTransactionControllerApi;

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

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

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

        try {
            Transaction result = apiInstance.editTransaction(id, transaction);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling RestTransactionControllerApi#editTransaction");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.RestTransactionControllerApi;

public class RestTransactionControllerApiExample {
    public static void main(String[] args) {
        RestTransactionControllerApi apiInstance = new RestTransactionControllerApi();
        Long id = 789; // Long | 
        Transaction transaction = ; // Transaction | 

        try {
            Transaction result = apiInstance.editTransaction(id, transaction);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling RestTransactionControllerApi#editTransaction");
            e.printStackTrace();
        }
    }
}


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

[apiInstance editTransactionWith:id
    transaction:transaction
              completionHandler: ^(Transaction output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var OpenApiDefinition = require('open_api_definition');

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

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.editTransaction(id, transaction, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

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

            try {
                Transaction result = apiInstance.editTransaction(id, transaction);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling RestTransactionControllerApi.editTransaction: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

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

try {
    $result = $api_instance->editTransaction($id, $transaction);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling RestTransactionControllerApi->editTransaction: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::RestTransactionControllerApi;

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

eval {
    my $result = $api_instance->editTransaction(id => $id, transaction => $transaction);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling RestTransactionControllerApi->editTransaction: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

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

try:
    api_response = api_instance.edit_transaction(id, transaction)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling RestTransactionControllerApi->editTransaction: %s\n" % e)
extern crate RestTransactionControllerApi;

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

    let mut context = RestTransactionControllerApi::Context::default();
    let result = client.editTransaction(id, transaction, &context).wait();

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

Scopes

Parameters

Path parameters
Name Description
id*
Long (int64)
Required
Body parameters
Name Description
transaction *

{
id:
integer (int64)
type:
string
user:
{
id:
username:
email:
name:
lastName:
password:
address:
mobileNumber:
birthdate:
role:
usedCoupon:
{
id:
code:
type:
startDate:
dateOfExpiry:
minimum:
discount:
affectedProducts:
date:
string
totalPrice:
number (double)
products:
[
{
id:
integer (int64)
name:
string
description:
string
price:
number (double)
stock:
integer (int64)
size:
string
Enum: XS, S, M, L, XL
images:
[
string
]
]

Responses

Status: 200 - OK

{
id:
integer (int64)
type:
string
user:
{
id:
integer (int64)
username:
string
email:
string
name:
string
lastName:
string
password:
string
address:
string
mobileNumber:
integer (int32)
birthdate:
string
role:
string
usedCoupon:
{
id:
integer (int64)
code:
string
type:
string
startDate:
string
dateOfExpiry:
string
minimum:
number (float)
discount:
number (float)
affectedProducts:
[
{
id:
integer (int64)
name:
string
description:
string
price:
number (double)
stock:
integer (int64)
size:
string
Enum: XS, S, M, L, XL
images:
[
string
]
]
date:
string
totalPrice:
number (double)
products:
[
{
id:
integer (int64)
name:
string
description:
string
price:
number (double)
stock:
integer (int64)
size:
string
Enum: XS, S, M, L, XL
images:
[
string
]
]

getCart


/api/transactions/carts

Usage and SDK Samples

curl -X GET \
 -H "Accept: */*" \
 "https://localhost:8080/api/transactions/carts?page=56"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.RestTransactionControllerApi;

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

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

        // Create an instance of the API class
        RestTransactionControllerApi apiInstance = new RestTransactionControllerApi();
        Integer page = 56; // Integer | 

        try {
            array[Transaction] result = apiInstance.getCart(page);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling RestTransactionControllerApi#getCart");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.RestTransactionControllerApi;

public class RestTransactionControllerApiExample {
    public static void main(String[] args) {
        RestTransactionControllerApi apiInstance = new RestTransactionControllerApi();
        Integer page = 56; // Integer | 

        try {
            array[Transaction] result = apiInstance.getCart(page);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling RestTransactionControllerApi#getCart");
            e.printStackTrace();
        }
    }
}


// Create an instance of the API class
RestTransactionControllerApi *apiInstance = [[RestTransactionControllerApi alloc] init];
Integer *page = 56; //  (optional) (default to null)

[apiInstance getCartWith:page
              completionHandler: ^(array[Transaction] output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var OpenApiDefinition = require('open_api_definition');

// Create an instance of the API class
var api = new OpenApiDefinition.RestTransactionControllerApi()
var opts = {
  'page': 56 // {Integer} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getCart(opts, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

            // Create an instance of the API class
            var apiInstance = new RestTransactionControllerApi();
            var page = 56;  // Integer |  (optional)  (default to null)

            try {
                array[Transaction] result = apiInstance.getCart(page);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling RestTransactionControllerApi.getCart: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\RestTransactionControllerApi();
$page = 56; // Integer | 

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::RestTransactionControllerApi->new();
my $page = 56; # Integer | 

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

# Create an instance of the API class
api_instance = openapi_client.RestTransactionControllerApi()
page = 56 # Integer |  (optional) (default to null)

try:
    api_response = api_instance.get_cart(page=page)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling RestTransactionControllerApi->getCart: %s\n" % e)
extern crate RestTransactionControllerApi;

pub fn main() {
    let page = 56; // Integer

    let mut context = RestTransactionControllerApi::Context::default();
    let result = client.getCart(page, &context).wait();

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

Scopes

Parameters

Query parameters
Name Description
page
Integer (int32)

Responses

Status: 200 - OK

[
{
id:
integer (int64)
type:
string
user:
{
id:
integer (int64)
username:
string
email:
string
name:
string
lastName:
string
password:
string
address:
string
mobileNumber:
integer (int32)
birthdate:
string
role:
string
usedCoupon:
{
id:
integer (int64)
code:
string
type:
string
startDate:
string
dateOfExpiry:
string
minimum:
number (float)
discount:
number (float)
affectedProducts:
[
{
id:
integer (int64)
name:
string
description:
string
price:
number (double)
stock:
integer (int64)
size:
string
Enum: XS, S, M, L, XL
images:
[
string
]
]
date:
string
totalPrice:
number (double)
products:
[
{
id:
integer (int64)
name:
string
description:
string
price:
number (double)
stock:
integer (int64)
size:
string
Enum: XS, S, M, L, XL
images:
[
string
]
]
]

getProcessed


/api/transactions/processed

Usage and SDK Samples

curl -X GET \
 -H "Accept: */*" \
 "https://localhost:8080/api/transactions/processed?page=56"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.RestTransactionControllerApi;

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

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

        // Create an instance of the API class
        RestTransactionControllerApi apiInstance = new RestTransactionControllerApi();
        Integer page = 56; // Integer | 

        try {
            array[Transaction] result = apiInstance.getProcessed(page);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling RestTransactionControllerApi#getProcessed");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.RestTransactionControllerApi;

public class RestTransactionControllerApiExample {
    public static void main(String[] args) {
        RestTransactionControllerApi apiInstance = new RestTransactionControllerApi();
        Integer page = 56; // Integer | 

        try {
            array[Transaction] result = apiInstance.getProcessed(page);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling RestTransactionControllerApi#getProcessed");
            e.printStackTrace();
        }
    }
}


// Create an instance of the API class
RestTransactionControllerApi *apiInstance = [[RestTransactionControllerApi alloc] init];
Integer *page = 56; //  (optional) (default to null)

[apiInstance getProcessedWith:page
              completionHandler: ^(array[Transaction] output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var OpenApiDefinition = require('open_api_definition');

// Create an instance of the API class
var api = new OpenApiDefinition.RestTransactionControllerApi()
var opts = {
  'page': 56 // {Integer} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getProcessed(opts, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

            // Create an instance of the API class
            var apiInstance = new RestTransactionControllerApi();
            var page = 56;  // Integer |  (optional)  (default to null)

            try {
                array[Transaction] result = apiInstance.getProcessed(page);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling RestTransactionControllerApi.getProcessed: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\RestTransactionControllerApi();
$page = 56; // Integer | 

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::RestTransactionControllerApi->new();
my $page = 56; # Integer | 

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

# Create an instance of the API class
api_instance = openapi_client.RestTransactionControllerApi()
page = 56 # Integer |  (optional) (default to null)

try:
    api_response = api_instance.get_processed(page=page)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling RestTransactionControllerApi->getProcessed: %s\n" % e)
extern crate RestTransactionControllerApi;

pub fn main() {
    let page = 56; // Integer

    let mut context = RestTransactionControllerApi::Context::default();
    let result = client.getProcessed(page, &context).wait();

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

Scopes

Parameters

Query parameters
Name Description
page
Integer (int32)

Responses

Status: 200 - OK

[
{
id:
integer (int64)
type:
string
user:
{
id:
integer (int64)
username:
string
email:
string
name:
string
lastName:
string
password:
string
address:
string
mobileNumber:
integer (int32)
birthdate:
string
role:
string
usedCoupon:
{
id:
integer (int64)
code:
string
type:
string
startDate:
string
dateOfExpiry:
string
minimum:
number (float)
discount:
number (float)
affectedProducts:
[
{
id:
integer (int64)
name:
string
description:
string
price:
number (double)
stock:
integer (int64)
size:
string
Enum: XS, S, M, L, XL
images:
[
string
]
]
date:
string
totalPrice:
number (double)
products:
[
{
id:
integer (int64)
name:
string
description:
string
price:
number (double)
stock:
integer (int64)
size:
string
Enum: XS, S, M, L, XL
images:
[
string
]
]
]

getTransactionById


/api/transactions/{id}

Usage and SDK Samples

curl -X GET \
 -H "Accept: */*" \
 "https://localhost:8080/api/transactions/{id}"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.RestTransactionControllerApi;

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

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

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

        try {
            Transaction result = apiInstance.getTransactionById(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling RestTransactionControllerApi#getTransactionById");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.RestTransactionControllerApi;

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

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


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

[apiInstance getTransactionByIdWith:id
              completionHandler: ^(Transaction output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var OpenApiDefinition = require('open_api_definition');

// Create an instance of the API class
var api = new OpenApiDefinition.RestTransactionControllerApi()
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.getTransactionById(id, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

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

            try {
                Transaction result = apiInstance.getTransactionById(id);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling RestTransactionControllerApi.getTransactionById: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

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

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

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

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

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

try:
    api_response = api_instance.get_transaction_by_id(id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling RestTransactionControllerApi->getTransactionById: %s\n" % e)
extern crate RestTransactionControllerApi;

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

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

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

Scopes

Parameters

Path parameters
Name Description
id*
Long (int64)
Required

Responses

Status: 200 - OK

{
id:
integer (int64)
type:
string
user:
{
id:
integer (int64)
username:
string
email:
string
name:
string
lastName:
string
password:
string
address:
string
mobileNumber:
integer (int32)
birthdate:
string
role:
string
usedCoupon:
{
id:
integer (int64)
code:
string
type:
string
startDate:
string
dateOfExpiry:
string
minimum:
number (float)
discount:
number (float)
affectedProducts:
[
{
id:
integer (int64)
name:
string
description:
string
price:
number (double)
stock:
integer (int64)
size:
string
Enum: XS, S, M, L, XL
images:
[
string
]
]
date:
string
totalPrice:
number (double)
products:
[
{
id:
integer (int64)
name:
string
description:
string
price:
number (double)
stock:
integer (int64)
size:
string
Enum: XS, S, M, L, XL
images:
[
string
]
]

getTransactions


/api/transactions

Usage and SDK Samples

curl -X GET \
 -H "Accept: */*" \
 "https://localhost:8080/api/transactions?page=56"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.RestTransactionControllerApi;

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

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

        // Create an instance of the API class
        RestTransactionControllerApi apiInstance = new RestTransactionControllerApi();
        Integer page = 56; // Integer | 

        try {
            array[Transaction] result = apiInstance.getTransactions(page);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling RestTransactionControllerApi#getTransactions");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.RestTransactionControllerApi;

public class RestTransactionControllerApiExample {
    public static void main(String[] args) {
        RestTransactionControllerApi apiInstance = new RestTransactionControllerApi();
        Integer page = 56; // Integer | 

        try {
            array[Transaction] result = apiInstance.getTransactions(page);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling RestTransactionControllerApi#getTransactions");
            e.printStackTrace();
        }
    }
}


// Create an instance of the API class
RestTransactionControllerApi *apiInstance = [[RestTransactionControllerApi alloc] init];
Integer *page = 56; //  (optional) (default to null)

[apiInstance getTransactionsWith:page
              completionHandler: ^(array[Transaction] output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var OpenApiDefinition = require('open_api_definition');

// Create an instance of the API class
var api = new OpenApiDefinition.RestTransactionControllerApi()
var opts = {
  'page': 56 // {Integer} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getTransactions(opts, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

            // Create an instance of the API class
            var apiInstance = new RestTransactionControllerApi();
            var page = 56;  // Integer |  (optional)  (default to null)

            try {
                array[Transaction] result = apiInstance.getTransactions(page);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling RestTransactionControllerApi.getTransactions: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\RestTransactionControllerApi();
$page = 56; // Integer | 

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::RestTransactionControllerApi->new();
my $page = 56; # Integer | 

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

# Create an instance of the API class
api_instance = openapi_client.RestTransactionControllerApi()
page = 56 # Integer |  (optional) (default to null)

try:
    api_response = api_instance.get_transactions(page=page)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling RestTransactionControllerApi->getTransactions: %s\n" % e)
extern crate RestTransactionControllerApi;

pub fn main() {
    let page = 56; // Integer

    let mut context = RestTransactionControllerApi::Context::default();
    let result = client.getTransactions(page, &context).wait();

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

Scopes

Parameters

Query parameters
Name Description
page
Integer (int32)

Responses

Status: 200 - OK

[
{
id:
integer (int64)
type:
string
user:
{
id:
integer (int64)
username:
string
email:
string
name:
string
lastName:
string
password:
string
address:
string
mobileNumber:
integer (int32)
birthdate:
string
role:
string
usedCoupon:
{
id:
integer (int64)
code:
string
type:
string
startDate:
string
dateOfExpiry:
string
minimum:
number (float)
discount:
number (float)
affectedProducts:
[
{
id:
integer (int64)
name:
string
description:
string
price:
number (double)
stock:
integer (int64)
size:
string
Enum: XS, S, M, L, XL
images:
[
string
]
]
date:
string
totalPrice:
number (double)
products:
[
{
id:
integer (int64)
name:
string
description:
string
price:
number (double)
stock:
integer (int64)
size:
string
Enum: XS, S, M, L, XL
images:
[
string
]
]
]

getWishlist


/api/transactions/wishlists

Usage and SDK Samples

curl -X GET \
 -H "Accept: */*" \
 "https://localhost:8080/api/transactions/wishlists?page=56"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.RestTransactionControllerApi;

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

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

        // Create an instance of the API class
        RestTransactionControllerApi apiInstance = new RestTransactionControllerApi();
        Integer page = 56; // Integer | 

        try {
            array[Transaction] result = apiInstance.getWishlist(page);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling RestTransactionControllerApi#getWishlist");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.RestTransactionControllerApi;

public class RestTransactionControllerApiExample {
    public static void main(String[] args) {
        RestTransactionControllerApi apiInstance = new RestTransactionControllerApi();
        Integer page = 56; // Integer | 

        try {
            array[Transaction] result = apiInstance.getWishlist(page);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling RestTransactionControllerApi#getWishlist");
            e.printStackTrace();
        }
    }
}


// Create an instance of the API class
RestTransactionControllerApi *apiInstance = [[RestTransactionControllerApi alloc] init];
Integer *page = 56; //  (optional) (default to null)

[apiInstance getWishlistWith:page
              completionHandler: ^(array[Transaction] output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var OpenApiDefinition = require('open_api_definition');

// Create an instance of the API class
var api = new OpenApiDefinition.RestTransactionControllerApi()
var opts = {
  'page': 56 // {Integer} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getWishlist(opts, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

            // Create an instance of the API class
            var apiInstance = new RestTransactionControllerApi();
            var page = 56;  // Integer |  (optional)  (default to null)

            try {
                array[Transaction] result = apiInstance.getWishlist(page);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling RestTransactionControllerApi.getWishlist: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\RestTransactionControllerApi();
$page = 56; // Integer | 

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::RestTransactionControllerApi->new();
my $page = 56; # Integer | 

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

# Create an instance of the API class
api_instance = openapi_client.RestTransactionControllerApi()
page = 56 # Integer |  (optional) (default to null)

try:
    api_response = api_instance.get_wishlist(page=page)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling RestTransactionControllerApi->getWishlist: %s\n" % e)
extern crate RestTransactionControllerApi;

pub fn main() {
    let page = 56; // Integer

    let mut context = RestTransactionControllerApi::Context::default();
    let result = client.getWishlist(page, &context).wait();

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

Scopes

Parameters

Query parameters
Name Description
page
Integer (int32)

Responses

Status: 200 - OK

[
{
id:
integer (int64)
type:
string
user:
{
id:
integer (int64)
username:
string
email:
string
name:
string
lastName:
string
password:
string
address:
string
mobileNumber:
integer (int32)
birthdate:
string
role:
string
usedCoupon:
{
id:
integer (int64)
code:
string
type:
string
startDate:
string
dateOfExpiry:
string
minimum:
number (float)
discount:
number (float)
affectedProducts:
[
{
id:
integer (int64)
name:
string
description:
string
price:
number (double)
stock:
integer (int64)
size:
string
Enum: XS, S, M, L, XL
images:
[
string
]
]
date:
string
totalPrice:
number (double)
products:
[
{
id:
integer (int64)
name:
string
description:
string
price:
number (double)
stock:
integer (int64)
size:
string
Enum: XS, S, M, L, XL
images:
[
string
]
]
]

removeTransaction


/api/transactions/{id}

Usage and SDK Samples

curl -X DELETE \
 -H "Accept: */*" \
 "https://localhost:8080/api/transactions/{id}"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.RestTransactionControllerApi;

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

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

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

        try {
            Transaction result = apiInstance.removeTransaction(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling RestTransactionControllerApi#removeTransaction");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.RestTransactionControllerApi;

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

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


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

[apiInstance removeTransactionWith:id
              completionHandler: ^(Transaction output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var OpenApiDefinition = require('open_api_definition');

// Create an instance of the API class
var api = new OpenApiDefinition.RestTransactionControllerApi()
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.removeTransaction(id, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

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

            try {
                Transaction result = apiInstance.removeTransaction(id);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling RestTransactionControllerApi.removeTransaction: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

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

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

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

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

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

try:
    api_response = api_instance.remove_transaction(id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling RestTransactionControllerApi->removeTransaction: %s\n" % e)
extern crate RestTransactionControllerApi;

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

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

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

Scopes

Parameters

Path parameters
Name Description
id*
Long (int64)
Required

Responses

Status: 200 - OK

{
id:
integer (int64)
type:
string
user:
{
id:
integer (int64)
username:
string
email:
string
name:
string
lastName:
string
password:
string
address:
string
mobileNumber:
integer (int32)
birthdate:
string
role:
string
usedCoupon:
{
id:
integer (int64)
code:
string
type:
string
startDate:
string
dateOfExpiry:
string
minimum:
number (float)
discount:
number (float)
affectedProducts:
[
{
id:
integer (int64)
name:
string
description:
string
price:
number (double)
stock:
integer (int64)
size:
string
Enum: XS, S, M, L, XL
images:
[
string
]
]
date:
string
totalPrice:
number (double)
products:
[
{
id:
integer (int64)
name:
string
description:
string
price:
number (double)
stock:
integer (int64)
size:
string
Enum: XS, S, M, L, XL
images:
[
string
]
]

RestUserController

create


/api/users/

Usage and SDK Samples

curl -X POST \
 -H "Accept: */*" \
 -H "Content-Type: application/json" \
 "https://localhost:8080/api/users/" \
 -d '{
  "lastName" : "lastName",
  "password" : "password",
  "address" : "address",
  "birthdate" : "birthdate",
  "role" : "role",
  "mobileNumber" : 6,
  "name" : "name",
  "id" : 0,
  "email" : "email",
  "username" : "username"
}'
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.RestUserControllerApi;

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

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

        // Create an instance of the API class
        RestUserControllerApi apiInstance = new RestUserControllerApi();
        ShopUser shopUser = ; // ShopUser | 

        try {
            ShopUser result = apiInstance.create(shopUser);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling RestUserControllerApi#create");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.RestUserControllerApi;

public class RestUserControllerApiExample {
    public static void main(String[] args) {
        RestUserControllerApi apiInstance = new RestUserControllerApi();
        ShopUser shopUser = ; // ShopUser | 

        try {
            ShopUser result = apiInstance.create(shopUser);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling RestUserControllerApi#create");
            e.printStackTrace();
        }
    }
}


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

[apiInstance createWith:shopUser
              completionHandler: ^(ShopUser output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var OpenApiDefinition = require('open_api_definition');

// Create an instance of the API class
var api = new OpenApiDefinition.RestUserControllerApi()
var shopUser = ; // {ShopUser} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.create(shopUser, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

            // Create an instance of the API class
            var apiInstance = new RestUserControllerApi();
            var shopUser = new ShopUser(); // ShopUser | 

            try {
                ShopUser result = apiInstance.create(shopUser);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling RestUserControllerApi.create: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\RestUserControllerApi();
$shopUser = ; // ShopUser | 

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::RestUserControllerApi->new();
my $shopUser = WWW::OPenAPIClient::Object::ShopUser->new(); # ShopUser | 

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

# Create an instance of the API class
api_instance = openapi_client.RestUserControllerApi()
shopUser =  # ShopUser | 

try:
    api_response = api_instance.create(shopUser)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling RestUserControllerApi->create: %s\n" % e)
extern crate RestUserControllerApi;

pub fn main() {
    let shopUser = ; // ShopUser

    let mut context = RestUserControllerApi::Context::default();
    let result = client.create(shopUser, &context).wait();

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

Scopes

Parameters

Body parameters
Name Description
shopUser *

{
id:
integer (int64)
username:
string
email:
string
name:
string
lastName:
string
password:
string
address:
string
mobileNumber:
integer (int32)
birthdate:
string
role:
string

Responses

Status: 200 - OK

{
id:
integer (int64)
username:
string
email:
string
name:
string
lastName:
string
password:
string
address:
string
mobileNumber:
integer (int32)
birthdate:
string
role:
string

delete


/api/users/{id}

Usage and SDK Samples

curl -X DELETE \
 -H "Accept: */*" \
 "https://localhost:8080/api/users/{id}"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.RestUserControllerApi;

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

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

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

        try {
            ShopUser result = apiInstance.delete(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling RestUserControllerApi#delete");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.RestUserControllerApi;

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

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


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

[apiInstance deleteWith:id
              completionHandler: ^(ShopUser output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var OpenApiDefinition = require('open_api_definition');

// Create an instance of the API class
var api = new OpenApiDefinition.RestUserControllerApi()
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.delete(id, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

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

            try {
                ShopUser result = apiInstance.delete(id);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling RestUserControllerApi.delete: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

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

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

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

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

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

try:
    api_response = api_instance.delete(id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling RestUserControllerApi->delete: %s\n" % e)
extern crate RestUserControllerApi;

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

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

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

Scopes

Parameters

Path parameters
Name Description
id*
Long (int64)
Required

Responses

Status: 200 - OK

{
id:
integer (int64)
username:
string
email:
string
name:
string
lastName:
string
password:
string
address:
string
mobileNumber:
integer (int32)
birthdate:
string
role:
string

get


/api/users/

Usage and SDK Samples

curl -X GET \
 -H "Accept: */*" \
 "https://localhost:8080/api/users/?page=56"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.RestUserControllerApi;

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

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

        // Create an instance of the API class
        RestUserControllerApi apiInstance = new RestUserControllerApi();
        Integer page = 56; // Integer | 

        try {
            array[ShopUser] result = apiInstance.get(page);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling RestUserControllerApi#get");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.RestUserControllerApi;

public class RestUserControllerApiExample {
    public static void main(String[] args) {
        RestUserControllerApi apiInstance = new RestUserControllerApi();
        Integer page = 56; // Integer | 

        try {
            array[ShopUser] result = apiInstance.get(page);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling RestUserControllerApi#get");
            e.printStackTrace();
        }
    }
}


// Create an instance of the API class
RestUserControllerApi *apiInstance = [[RestUserControllerApi alloc] init];
Integer *page = 56; //  (optional) (default to null)

[apiInstance getWith:page
              completionHandler: ^(array[ShopUser] output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var OpenApiDefinition = require('open_api_definition');

// Create an instance of the API class
var api = new OpenApiDefinition.RestUserControllerApi()
var opts = {
  'page': 56 // {Integer} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.get(opts, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

            // Create an instance of the API class
            var apiInstance = new RestUserControllerApi();
            var page = 56;  // Integer |  (optional)  (default to null)

            try {
                array[ShopUser] result = apiInstance.get(page);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling RestUserControllerApi.get: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\RestUserControllerApi();
$page = 56; // Integer | 

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::RestUserControllerApi->new();
my $page = 56; # Integer | 

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

# Create an instance of the API class
api_instance = openapi_client.RestUserControllerApi()
page = 56 # Integer |  (optional) (default to null)

try:
    api_response = api_instance.get(page=page)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling RestUserControllerApi->get: %s\n" % e)
extern crate RestUserControllerApi;

pub fn main() {
    let page = 56; // Integer

    let mut context = RestUserControllerApi::Context::default();
    let result = client.get(page, &context).wait();

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

Scopes

Parameters

Query parameters
Name Description
page
Integer (int32)

Responses

Status: 200 - OK

[
{
id:
integer (int64)
username:
string
email:
string
name:
string
lastName:
string
password:
string
address:
string
mobileNumber:
integer (int32)
birthdate:
string
role:
string
]

updateAdmin


/api/users/{id}

Usage and SDK Samples

curl -X PUT \
 -H "Accept: */*" \
 -H "Content-Type: application/json" \
 "https://localhost:8080/api/users/{id}" \
 -d '{
  "lastName" : "lastName",
  "password" : "password",
  "address" : "address",
  "birthdate" : "birthdate",
  "role" : "role",
  "mobileNumber" : 6,
  "name" : "name",
  "id" : 0,
  "email" : "email",
  "username" : "username"
}'
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.RestUserControllerApi;

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

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

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

        try {
            ShopUser result = apiInstance.updateAdmin(id, shopUser);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling RestUserControllerApi#updateAdmin");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.RestUserControllerApi;

public class RestUserControllerApiExample {
    public static void main(String[] args) {
        RestUserControllerApi apiInstance = new RestUserControllerApi();
        Long id = 789; // Long | 
        ShopUser shopUser = ; // ShopUser | 

        try {
            ShopUser result = apiInstance.updateAdmin(id, shopUser);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling RestUserControllerApi#updateAdmin");
            e.printStackTrace();
        }
    }
}


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

[apiInstance updateAdminWith:id
    shopUser:shopUser
              completionHandler: ^(ShopUser output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var OpenApiDefinition = require('open_api_definition');

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

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.updateAdmin(id, shopUser, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

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

            try {
                ShopUser result = apiInstance.updateAdmin(id, shopUser);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling RestUserControllerApi.updateAdmin: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

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

try {
    $result = $api_instance->updateAdmin($id, $shopUser);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling RestUserControllerApi->updateAdmin: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::RestUserControllerApi;

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

eval {
    my $result = $api_instance->updateAdmin(id => $id, shopUser => $shopUser);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling RestUserControllerApi->updateAdmin: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

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

try:
    api_response = api_instance.update_admin(id, shopUser)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling RestUserControllerApi->updateAdmin: %s\n" % e)
extern crate RestUserControllerApi;

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

    let mut context = RestUserControllerApi::Context::default();
    let result = client.updateAdmin(id, shopUser, &context).wait();

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

Scopes

Parameters

Path parameters
Name Description
id*
Long (int64)
Required
Body parameters
Name Description
shopUser *

{
id:
integer (int64)
username:
string
email:
string
name:
string
lastName:
string
password:
string
address:
string
mobileNumber:
integer (int32)
birthdate:
string
role:
string

Responses

Status: 200 - OK

{
id:
integer (int64)
username:
string
email:
string
name:
string
lastName:
string
password:
string
address:
string
mobileNumber:
integer (int32)
birthdate:
string
role:
string

updateUser


/api/users/userInfo

Usage and SDK Samples

curl -X PUT \
 -H "Accept: */*" \
 -H "Content-Type: application/json" \
 "https://localhost:8080/api/users/userInfo" \
 -d '{
  "lastName" : "lastName",
  "password" : "password",
  "address" : "address",
  "birthdate" : "birthdate",
  "role" : "role",
  "mobileNumber" : 6,
  "name" : "name",
  "id" : 0,
  "email" : "email",
  "username" : "username"
}'
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.RestUserControllerApi;

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

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

        // Create an instance of the API class
        RestUserControllerApi apiInstance = new RestUserControllerApi();
        ShopUser shopUser = ; // ShopUser | 

        try {
            ShopUser result = apiInstance.updateUser(shopUser);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling RestUserControllerApi#updateUser");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.RestUserControllerApi;

public class RestUserControllerApiExample {
    public static void main(String[] args) {
        RestUserControllerApi apiInstance = new RestUserControllerApi();
        ShopUser shopUser = ; // ShopUser | 

        try {
            ShopUser result = apiInstance.updateUser(shopUser);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling RestUserControllerApi#updateUser");
            e.printStackTrace();
        }
    }
}


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

[apiInstance updateUserWith:shopUser
              completionHandler: ^(ShopUser output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var OpenApiDefinition = require('open_api_definition');

// Create an instance of the API class
var api = new OpenApiDefinition.RestUserControllerApi()
var shopUser = ; // {ShopUser} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.updateUser(shopUser, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

            // Create an instance of the API class
            var apiInstance = new RestUserControllerApi();
            var shopUser = new ShopUser(); // ShopUser | 

            try {
                ShopUser result = apiInstance.updateUser(shopUser);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling RestUserControllerApi.updateUser: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\RestUserControllerApi();
$shopUser = ; // ShopUser | 

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::RestUserControllerApi->new();
my $shopUser = WWW::OPenAPIClient::Object::ShopUser->new(); # ShopUser | 

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

# Create an instance of the API class
api_instance = openapi_client.RestUserControllerApi()
shopUser =  # ShopUser | 

try:
    api_response = api_instance.update_user(shopUser)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling RestUserControllerApi->updateUser: %s\n" % e)
extern crate RestUserControllerApi;

pub fn main() {
    let shopUser = ; // ShopUser

    let mut context = RestUserControllerApi::Context::default();
    let result = client.updateUser(shopUser, &context).wait();

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

Scopes

Parameters

Body parameters
Name Description
shopUser *

{
id:
integer (int64)
username:
string
email:
string
name:
string
lastName:
string
password:
string
address:
string
mobileNumber:
integer (int32)
birthdate:
string
role:
string

Responses

Status: 200 - OK

{
id:
integer (int64)
username:
string
email:
string
name:
string
lastName:
string
password:
string
address:
string
mobileNumber:
integer (int32)
birthdate:
string
role:
string

updateUserPass


/api/users/password

Usage and SDK Samples

curl -X PUT \
 -H "Accept: */*" \
 -H "Content-Type: application/json" \
 "https://localhost:8080/api/users/password" \
 -d '{
  "newPass" : "newPass",
  "newConfPass" : "newConfPass",
  "oldPass" : "oldPass"
}'
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.RestUserControllerApi;

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

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

        // Create an instance of the API class
        RestUserControllerApi apiInstance = new RestUserControllerApi();
        PassChange passChange = ; // PassChange | 

        try {
            ShopUser result = apiInstance.updateUserPass(passChange);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling RestUserControllerApi#updateUserPass");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.RestUserControllerApi;

public class RestUserControllerApiExample {
    public static void main(String[] args) {
        RestUserControllerApi apiInstance = new RestUserControllerApi();
        PassChange passChange = ; // PassChange | 

        try {
            ShopUser result = apiInstance.updateUserPass(passChange);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling RestUserControllerApi#updateUserPass");
            e.printStackTrace();
        }
    }
}


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

[apiInstance updateUserPassWith:passChange
              completionHandler: ^(ShopUser output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var OpenApiDefinition = require('open_api_definition');

// Create an instance of the API class
var api = new OpenApiDefinition.RestUserControllerApi()
var passChange = ; // {PassChange} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.updateUserPass(passChange, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

            // Create an instance of the API class
            var apiInstance = new RestUserControllerApi();
            var passChange = new PassChange(); // PassChange | 

            try {
                ShopUser result = apiInstance.updateUserPass(passChange);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling RestUserControllerApi.updateUserPass: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\RestUserControllerApi();
$passChange = ; // PassChange | 

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::RestUserControllerApi->new();
my $passChange = WWW::OPenAPIClient::Object::PassChange->new(); # PassChange | 

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

# Create an instance of the API class
api_instance = openapi_client.RestUserControllerApi()
passChange =  # PassChange | 

try:
    api_response = api_instance.update_user_pass(passChange)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling RestUserControllerApi->updateUserPass: %s\n" % e)
extern crate RestUserControllerApi;

pub fn main() {
    let passChange = ; // PassChange

    let mut context = RestUserControllerApi::Context::default();
    let result = client.updateUserPass(passChange, &context).wait();

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

Scopes

Parameters

Body parameters
Name Description
passChange *

{
oldPass:
string
newPass:
string
newConfPass:
string

Responses

Status: 200 - OK

{
id:
integer (int64)
username:
string
email:
string
name:
string
lastName:
string
password:
string
address:
string
mobileNumber:
integer (int32)
birthdate:
string
role:
string

TransactionRestController

postCart


/cart

Usage and SDK Samples

curl -X POST \
 -H "Accept: */*" \
 "https://localhost:8080/cart?action=action_example&productId=789&quantity=56&couponCode=couponCode_example"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.TransactionRestControllerApi;

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

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

        // Create an instance of the API class
        TransactionRestControllerApi apiInstance = new TransactionRestControllerApi();
        String action = action_example; // String | 
        Long productId = 789; // Long | 
        Integer quantity = 56; // Integer | 
        String couponCode = couponCode_example; // String | 

        try {
            TransactionView result = apiInstance.postCart(action, productId, quantity, couponCode);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling TransactionRestControllerApi#postCart");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.TransactionRestControllerApi;

public class TransactionRestControllerApiExample {
    public static void main(String[] args) {
        TransactionRestControllerApi apiInstance = new TransactionRestControllerApi();
        String action = action_example; // String | 
        Long productId = 789; // Long | 
        Integer quantity = 56; // Integer | 
        String couponCode = couponCode_example; // String | 

        try {
            TransactionView result = apiInstance.postCart(action, productId, quantity, couponCode);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling TransactionRestControllerApi#postCart");
            e.printStackTrace();
        }
    }
}


// Create an instance of the API class
TransactionRestControllerApi *apiInstance = [[TransactionRestControllerApi alloc] init];
String *action = action_example; //  (default to null)
Long *productId = 789; //  (optional) (default to null)
Integer *quantity = 56; //  (optional) (default to null)
String *couponCode = couponCode_example; //  (optional) (default to null)

[apiInstance postCartWith:action
    productId:productId
    quantity:quantity
    couponCode:couponCode
              completionHandler: ^(TransactionView output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var OpenApiDefinition = require('open_api_definition');

// Create an instance of the API class
var api = new OpenApiDefinition.TransactionRestControllerApi()
var action = action_example; // {String} 
var opts = {
  'productId': 789, // {Long} 
  'quantity': 56, // {Integer} 
  'couponCode': couponCode_example // {String} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.postCart(action, opts, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

            // Create an instance of the API class
            var apiInstance = new TransactionRestControllerApi();
            var action = action_example;  // String |  (default to null)
            var productId = 789;  // Long |  (optional)  (default to null)
            var quantity = 56;  // Integer |  (optional)  (default to null)
            var couponCode = couponCode_example;  // String |  (optional)  (default to null)

            try {
                TransactionView result = apiInstance.postCart(action, productId, quantity, couponCode);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling TransactionRestControllerApi.postCart: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\TransactionRestControllerApi();
$action = action_example; // String | 
$productId = 789; // Long | 
$quantity = 56; // Integer | 
$couponCode = couponCode_example; // String | 

try {
    $result = $api_instance->postCart($action, $productId, $quantity, $couponCode);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling TransactionRestControllerApi->postCart: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::TransactionRestControllerApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::TransactionRestControllerApi->new();
my $action = action_example; # String | 
my $productId = 789; # Long | 
my $quantity = 56; # Integer | 
my $couponCode = couponCode_example; # String | 

eval {
    my $result = $api_instance->postCart(action => $action, productId => $productId, quantity => $quantity, couponCode => $couponCode);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling TransactionRestControllerApi->postCart: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Create an instance of the API class
api_instance = openapi_client.TransactionRestControllerApi()
action = action_example # String |  (default to null)
productId = 789 # Long |  (optional) (default to null)
quantity = 56 # Integer |  (optional) (default to null)
couponCode = couponCode_example # String |  (optional) (default to null)

try:
    api_response = api_instance.post_cart(action, productId=productId, quantity=quantity, couponCode=couponCode)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling TransactionRestControllerApi->postCart: %s\n" % e)
extern crate TransactionRestControllerApi;

pub fn main() {
    let action = action_example; // String
    let productId = 789; // Long
    let quantity = 56; // Integer
    let couponCode = couponCode_example; // String

    let mut context = TransactionRestControllerApi::Context::default();
    let result = client.postCart(action, productId, quantity, couponCode, &context).wait();

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

Scopes

Parameters

Query parameters
Name Description
action*
String
Required
productId
Long (int64)
quantity
Integer (int32)
couponCode
String

Responses

Status: 200 - OK

{
id:
integer (int64)
transactionEntries:
[
{
product:
{
id:
integer (int64)
name:
string
description:
string
price:
number (double)
stock:
integer (int64)
size:
string
Enum: XS, S, M, L, XL
images:
[
string
]
quantity:
integer (int32)
totalPrice:
number (double)
]
date:
string
type:
string
coupon:
{
id:
integer (int64)
code:
string
type:
string
startDate:
string
dateOfExpiry:
string
minimum:
number (double)
discount:
number (double)
affectedProducts:
[
{
id:
integer (int64)
name:
string
description:
string
price:
number (double)
stock:
integer (int64)
size:
string
Enum: XS, S, M, L, XL
images:
[
string
]
]
totalPrice:
number (double)
discount:
number (double)

postWishlist


/wishlist

Usage and SDK Samples

curl -X POST \
 -H "Accept: */*" \
 "https://localhost:8080/wishlist?action=action_example&productId=789&productName=productName_example"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.TransactionRestControllerApi;

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

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

        // Create an instance of the API class
        TransactionRestControllerApi apiInstance = new TransactionRestControllerApi();
        String action = action_example; // String | 
        Long productId = 789; // Long | 
        String productName = productName_example; // String | 

        try {
            TransactionView result = apiInstance.postWishlist(action, productId, productName);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling TransactionRestControllerApi#postWishlist");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.TransactionRestControllerApi;

public class TransactionRestControllerApiExample {
    public static void main(String[] args) {
        TransactionRestControllerApi apiInstance = new TransactionRestControllerApi();
        String action = action_example; // String | 
        Long productId = 789; // Long | 
        String productName = productName_example; // String | 

        try {
            TransactionView result = apiInstance.postWishlist(action, productId, productName);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling TransactionRestControllerApi#postWishlist");
            e.printStackTrace();
        }
    }
}


// Create an instance of the API class
TransactionRestControllerApi *apiInstance = [[TransactionRestControllerApi alloc] init];
String *action = action_example; //  (default to null)
Long *productId = 789; //  (optional) (default to null)
String *productName = productName_example; //  (optional) (default to null)

[apiInstance postWishlistWith:action
    productId:productId
    productName:productName
              completionHandler: ^(TransactionView output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var OpenApiDefinition = require('open_api_definition');

// Create an instance of the API class
var api = new OpenApiDefinition.TransactionRestControllerApi()
var action = action_example; // {String} 
var opts = {
  'productId': 789, // {Long} 
  'productName': productName_example // {String} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.postWishlist(action, opts, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

            // Create an instance of the API class
            var apiInstance = new TransactionRestControllerApi();
            var action = action_example;  // String |  (default to null)
            var productId = 789;  // Long |  (optional)  (default to null)
            var productName = productName_example;  // String |  (optional)  (default to null)

            try {
                TransactionView result = apiInstance.postWishlist(action, productId, productName);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling TransactionRestControllerApi.postWishlist: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\TransactionRestControllerApi();
$action = action_example; // String | 
$productId = 789; // Long | 
$productName = productName_example; // String | 

try {
    $result = $api_instance->postWishlist($action, $productId, $productName);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling TransactionRestControllerApi->postWishlist: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::TransactionRestControllerApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::TransactionRestControllerApi->new();
my $action = action_example; # String | 
my $productId = 789; # Long | 
my $productName = productName_example; # String | 

eval {
    my $result = $api_instance->postWishlist(action => $action, productId => $productId, productName => $productName);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling TransactionRestControllerApi->postWishlist: $@\n";
}
from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Create an instance of the API class
api_instance = openapi_client.TransactionRestControllerApi()
action = action_example # String |  (default to null)
productId = 789 # Long |  (optional) (default to null)
productName = productName_example # String |  (optional) (default to null)

try:
    api_response = api_instance.post_wishlist(action, productId=productId, productName=productName)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling TransactionRestControllerApi->postWishlist: %s\n" % e)
extern crate TransactionRestControllerApi;

pub fn main() {
    let action = action_example; // String
    let productId = 789; // Long
    let productName = productName_example; // String

    let mut context = TransactionRestControllerApi::Context::default();
    let result = client.postWishlist(action, productId, productName, &context).wait();

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

Scopes

Parameters

Query parameters
Name Description
action*
String
Required
productId
Long (int64)
productName
String

Responses

Status: 200 - OK

{
id:
integer (int64)
transactionEntries:
[
{
product:
{
id:
integer (int64)
name:
string
description:
string
price:
number (double)
stock:
integer (int64)
size:
string
Enum: XS, S, M, L, XL
images:
[
string
]
quantity:
integer (int32)
totalPrice:
number (double)
]
date:
string
type:
string
coupon:
{
id:
integer (int64)
code:
string
type:
string
startDate:
string
dateOfExpiry:
string
minimum:
number (double)
discount:
number (double)
affectedProducts:
[
{
id:
integer (int64)
name:
string
description:
string
price:
number (double)
stock:
integer (int64)
size:
string
Enum: XS, S, M, L, XL
images:
[
string
]
]
totalPrice:
number (double)
discount:
number (double)

productInWishlist


/wishlist/{productId}

Usage and SDK Samples

curl -X GET \
 -H "Accept: */*" \
 "https://localhost:8080/wishlist/{productId}"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.TransactionRestControllerApi;

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

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

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

        try {
            Product result = apiInstance.productInWishlist(productId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling TransactionRestControllerApi#productInWishlist");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.TransactionRestControllerApi;

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

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


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

[apiInstance productInWishlistWith:productId
              completionHandler: ^(Product output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var OpenApiDefinition = require('open_api_definition');

// Create an instance of the API class
var api = new OpenApiDefinition.TransactionRestControllerApi()
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.productInWishlist(productId, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

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

            try {
                Product result = apiInstance.productInWishlist(productId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling TransactionRestControllerApi.productInWishlist: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

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

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

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

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

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

try:
    api_response = api_instance.product_in_wishlist(productId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling TransactionRestControllerApi->productInWishlist: %s\n" % e)
extern crate TransactionRestControllerApi;

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

    let mut context = TransactionRestControllerApi::Context::default();
    let result = client.productInWishlist(productId, &context).wait();

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

Scopes

Parameters

Path parameters
Name Description
productId*
Long (int64)
Required

Responses

Status: 200 - OK

{
id:
integer (int64)
name:
string
description:
string
price:
number (double)
stock:
integer (int64)
size:
string
Enum: XS, S, M, L, XL
images:
[
string
]

purchaseHistory


/api/userHistory

Usage and SDK Samples

curl -X GET \
 -H "Accept: */*" \
 "https://localhost:8080/api/userHistory?page=56"
import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.TransactionRestControllerApi;

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

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

        // Create an instance of the API class
        TransactionRestControllerApi apiInstance = new TransactionRestControllerApi();
        Integer page = 56; // Integer | 

        try {
            array[Transaction] result = apiInstance.purchaseHistory(page);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling TransactionRestControllerApi#purchaseHistory");
            e.printStackTrace();
        }
    }
}
import org.openapitools.client.api.TransactionRestControllerApi;

public class TransactionRestControllerApiExample {
    public static void main(String[] args) {
        TransactionRestControllerApi apiInstance = new TransactionRestControllerApi();
        Integer page = 56; // Integer | 

        try {
            array[Transaction] result = apiInstance.purchaseHistory(page);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling TransactionRestControllerApi#purchaseHistory");
            e.printStackTrace();
        }
    }
}


// Create an instance of the API class
TransactionRestControllerApi *apiInstance = [[TransactionRestControllerApi alloc] init];
Integer *page = 56; //  (optional) (default to null)

[apiInstance purchaseHistoryWith:page
              completionHandler: ^(array[Transaction] output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];
var OpenApiDefinition = require('open_api_definition');

// Create an instance of the API class
var api = new OpenApiDefinition.TransactionRestControllerApi()
var opts = {
  'page': 56 // {Integer} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.purchaseHistory(opts, callback);
using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

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

            // Create an instance of the API class
            var apiInstance = new TransactionRestControllerApi();
            var page = 56;  // Integer |  (optional)  (default to null)

            try {
                array[Transaction] result = apiInstance.purchaseHistory(page);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling TransactionRestControllerApi.purchaseHistory: " + e.Message );
            }
        }
    }
}
<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\TransactionRestControllerApi();
$page = 56; // Integer | 

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::TransactionRestControllerApi->new();
my $page = 56; # Integer | 

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

# Create an instance of the API class
api_instance = openapi_client.TransactionRestControllerApi()
page = 56 # Integer |  (optional) (default to null)

try:
    api_response = api_instance.purchase_history(page=page)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling TransactionRestControllerApi->purchaseHistory: %s\n" % e)
extern crate TransactionRestControllerApi;

pub fn main() {
    let page = 56; // Integer

    let mut context = TransactionRestControllerApi::Context::default();
    let result = client.purchaseHistory(page, &context).wait();

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

Scopes

Parameters

Query parameters
Name Description
page
Integer (int32)

Responses

Status: 200 - OK

[
{
id:
integer (int64)
type:
string
user:
{
id:
integer (int64)
username:
string
email:
string
name:
string
lastName:
string
password:
string
address:
string
mobileNumber:
integer (int32)
birthdate:
string
role:
string
usedCoupon:
{
id:
integer (int64)
code:
string
type:
string
startDate:
string
dateOfExpiry:
string
minimum:
number (float)
discount:
number (float)
affectedProducts:
[
{
id:
integer (int64)
name:
string
description:
string
price:
number (double)
stock:
integer (int64)
size:
string
Enum: XS, S, M, L, XL
images:
[
string
]
]
date:
string
totalPrice:
number (double)
products:
[
{
id:
integer (int64)
name:
string
description:
string
price:
number (double)
stock:
integer (int64)
size:
string
Enum: XS, S, M, L, XL
images:
[
string
]
]
]