OpenAPI definition

AdminCategoryController

getImage2

/AdminCategories/image/{id}

Usage and SDK Samples

curl -X GET \
 -H "Accept: */*" \
 "https://localhost:8443/AdminCategories/image/{id}"

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

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

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

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

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

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

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

import org.openapitools.client.api.AdminCategoryControllerApi;

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

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



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

[apiInstance getImage2With:id
              completionHandler: ^(byte[] output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenApiDefinition = require('open_api_definition');

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

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

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

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

            try {
                byte[] result = apiInstance.getImage2(id);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling AdminCategoryControllerApi.getImage2: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

eval {
    my $result = $api_instance->getImage2(id => $id);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AdminCategoryControllerApi->getImage2: $@\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.AdminCategoryControllerApi()
id = 789 # Long |  (default to null)

try:
    api_response = api_instance.get_image2(id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AdminCategoryControllerApi->getImage2: %s\n" % e)

extern crate AdminCategoryControllerApi;

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

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

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

Scopes

Parameters

Path parameters

Name	Description
id*	Long (int64) Required

Responses

Schema

AdminProductController

getProductImage

/AdminProducts/image/{id}

Usage and SDK Samples

curl -X GET \
 -H "Accept: */*" \
 "https://localhost:8443/AdminProducts/image/{id}"

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

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

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

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

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

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

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

import org.openapitools.client.api.AdminProductControllerApi;

public class AdminProductControllerApiExample {
    public static void main(String[] args) {
        AdminProductControllerApi apiInstance = new AdminProductControllerApi();
        Integer id = 56; // Integer | 

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



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

[apiInstance getProductImageWith:id
              completionHandler: ^(byte[] output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenApiDefinition = require('open_api_definition');

// Create an instance of the API class
var api = new OpenApiDefinition.AdminProductControllerApi()
var id = 56; // {Integer} 

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

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

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

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

            try {
                byte[] result = apiInstance.getProductImage(id);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling AdminProductControllerApi.getProductImage: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

eval {
    my $result = $api_instance->getProductImage(id => $id);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AdminProductControllerApi->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.AdminProductControllerApi()
id = 56 # Integer |  (default to null)

try:
    api_response = api_instance.get_product_image(id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AdminProductControllerApi->getProductImage: %s\n" % e)

extern crate AdminProductControllerApi;

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

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

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

Scopes

Parameters

Path parameters

Name	Description
id*	Integer (int32) Required

Responses

Schema

CartController

obtenerCarrito

/api/carrito

Usage and SDK Samples

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

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

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

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

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

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();


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

import org.openapitools.client.api.CartControllerApi;

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

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



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

[apiInstance obtenerCarritoWithCompletionHandler: 
              ^(array[CartItem] 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.CartControllerApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.obtenerCarrito(callback);

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

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

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

            try {
                array[CartItem] result = apiInstance.obtenerCarrito();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling CartControllerApi.obtenerCarrito: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

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

try:
    api_response = api_instance.obtener_carrito()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling CartControllerApi->obtenerCarrito: %s\n" % e)

extern crate CartControllerApi;

pub fn main() {

    let mut context = CartControllerApi::Context::default();
    let result = client.obtenerCarrito(&context).wait();

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

Scopes

Parameters

Responses

Schema

CategoryRestController

createCategory

/api/categories/

Usage and SDK Samples

curl -X POST \
 -H "Accept: */*" \
 -H "Content-Type: application/json" \
 "https://localhost:8443/api/categories/" \
 -d '{
  "image" : {
    "id" : 6
  },
  "name" : "name",
  "id" : 0,
  "products" : [ {
    "precio" : 1.4658129805029452,
    "id" : 6,
    "nombre" : "nombre"
  }, {
    "precio" : 1.4658129805029452,
    "id" : 6,
    "nombre" : "nombre"
  } ]
}'

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

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

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

        // Create an instance of the API class
        CategoryRestControllerApi apiInstance = new CategoryRestControllerApi();
        CategoryDetailDTO categoryDetailDTO = ; // CategoryDetailDTO | 

        try {
            CategoryDetailDTO result = apiInstance.createCategory(categoryDetailDTO);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CategoryRestControllerApi#createCategory");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final CategoryDetailDTO categoryDetailDTO = new CategoryDetailDTO(); // CategoryDetailDTO | 

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

import org.openapitools.client.api.CategoryRestControllerApi;

public class CategoryRestControllerApiExample {
    public static void main(String[] args) {
        CategoryRestControllerApi apiInstance = new CategoryRestControllerApi();
        CategoryDetailDTO categoryDetailDTO = ; // CategoryDetailDTO | 

        try {
            CategoryDetailDTO result = apiInstance.createCategory(categoryDetailDTO);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CategoryRestControllerApi#createCategory");
            e.printStackTrace();
        }
    }
}



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

[apiInstance createCategoryWith:categoryDetailDTO
              completionHandler: ^(CategoryDetailDTO 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.CategoryRestControllerApi()
var categoryDetailDTO = ; // {CategoryDetailDTO} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new CategoryRestControllerApi();
            var categoryDetailDTO = new CategoryDetailDTO(); // CategoryDetailDTO | 

            try {
                CategoryDetailDTO result = apiInstance.createCategory(categoryDetailDTO);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling CategoryRestControllerApi.createCategory: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\CategoryRestControllerApi();
$categoryDetailDTO = ; // CategoryDetailDTO | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::CategoryRestControllerApi->new();
my $categoryDetailDTO = WWW::OPenAPIClient::Object::CategoryDetailDTO->new(); # CategoryDetailDTO | 

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

try:
    api_response = api_instance.create_category(categoryDetailDTO)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling CategoryRestControllerApi->createCategory: %s\n" % e)

extern crate CategoryRestControllerApi;

pub fn main() {
    let categoryDetailDTO = ; // CategoryDetailDTO

    let mut context = CategoryRestControllerApi::Context::default();
    let result = client.createCategory(categoryDetailDTO, &context).wait();

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

Scopes

Parameters

Body parameters

Name	Description
categoryDetailDTO *

Responses

Schema

deletecategory

/api/categories/{id}

Usage and SDK Samples

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

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

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

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

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

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

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

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

import org.openapitools.client.api.CategoryRestControllerApi;

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

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



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

[apiInstance deletecategoryWith:id
              completionHandler: ^(CategoryDetailDTO 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.CategoryRestControllerApi()
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.deletecategory(id, callback);

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

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

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

            try {
                CategoryDetailDTO result = apiInstance.deletecategory(id);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling CategoryRestControllerApi.deletecategory: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

eval {
    my $result = $api_instance->deletecategory(id => $id);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling CategoryRestControllerApi->deletecategory: $@\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.CategoryRestControllerApi()
id = 789 # Long |  (default to null)

try:
    api_response = api_instance.deletecategory(id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling CategoryRestControllerApi->deletecategory: %s\n" % e)

extern crate CategoryRestControllerApi;

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

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

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

Scopes

Parameters

Path parameters

Name	Description
id*	Long (int64) Required

Responses

Schema

getCategories

/api/categories/

Usage and SDK Samples

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

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

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

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

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

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

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

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

import org.openapitools.client.api.CategoryRestControllerApi;

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

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



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

[apiInstance getCategoriesWith:pageable
              completionHandler: ^(PagedModelCategoryBasicDTO 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.CategoryRestControllerApi()
var pageable = ; // {Pageable} 

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

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

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

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

            try {
                PagedModelCategoryBasicDTO result = apiInstance.getCategories(pageable);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling CategoryRestControllerApi.getCategories: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

eval {
    my $result = $api_instance->getCategories(pageable => $pageable);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling CategoryRestControllerApi->getCategories: $@\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.CategoryRestControllerApi()
pageable =  # Pageable |  (default to null)

try:
    api_response = api_instance.get_categories(pageable)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling CategoryRestControllerApi->getCategories: %s\n" % e)

extern crate CategoryRestControllerApi;

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

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

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

Scopes

Parameters

Query parameters

Name	Description
pageable*	Pageable Required

Responses

Schema

getCategory

/api/categories/{id}

Usage and SDK Samples

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

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

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

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

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

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

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

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

import org.openapitools.client.api.CategoryRestControllerApi;

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

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



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

[apiInstance getCategoryWith:id
              completionHandler: ^(CategoryDetailDTO 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.CategoryRestControllerApi()
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.getCategory(id, callback);

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

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

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

            try {
                CategoryDetailDTO result = apiInstance.getCategory(id);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling CategoryRestControllerApi.getCategory: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

eval {
    my $result = $api_instance->getCategory(id => $id);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling CategoryRestControllerApi->getCategory: $@\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.CategoryRestControllerApi()
id = 789 # Long |  (default to null)

try:
    api_response = api_instance.get_category(id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling CategoryRestControllerApi->getCategory: %s\n" % e)

extern crate CategoryRestControllerApi;

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

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

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

Scopes

Parameters

Path parameters

Name	Description
id*	Long (int64) Required

Responses

Schema

replaceCategory

/api/categories/{id}

Usage and SDK Samples

curl -X PUT \
 -H "Accept: */*" \
 -H "Content-Type: application/json" \
 "https://localhost:8443/api/categories/{id}" \
 -d '{
  "image" : {
    "id" : 6
  },
  "name" : "name",
  "id" : 0,
  "products" : [ {
    "precio" : 1.4658129805029452,
    "id" : 6,
    "nombre" : "nombre"
  }, {
    "precio" : 1.4658129805029452,
    "id" : 6,
    "nombre" : "nombre"
  } ]
}'

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

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

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

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

        try {
            CategoryDetailDTO result = apiInstance.replaceCategory(id, categoryDetailDTO);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CategoryRestControllerApi#replaceCategory");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

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

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

import org.openapitools.client.api.CategoryRestControllerApi;

public class CategoryRestControllerApiExample {
    public static void main(String[] args) {
        CategoryRestControllerApi apiInstance = new CategoryRestControllerApi();
        Long id = 789; // Long | 
        CategoryDetailDTO categoryDetailDTO = ; // CategoryDetailDTO | 

        try {
            CategoryDetailDTO result = apiInstance.replaceCategory(id, categoryDetailDTO);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CategoryRestControllerApi#replaceCategory");
            e.printStackTrace();
        }
    }
}



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

[apiInstance replaceCategoryWith:id
    categoryDetailDTO:categoryDetailDTO
              completionHandler: ^(CategoryDetailDTO 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.CategoryRestControllerApi()
var id = 789; // {Long} 
var categoryDetailDTO = ; // {CategoryDetailDTO} 

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

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

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

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

            try {
                CategoryDetailDTO result = apiInstance.replaceCategory(id, categoryDetailDTO);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling CategoryRestControllerApi.replaceCategory: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

eval {
    my $result = $api_instance->replaceCategory(id => $id, categoryDetailDTO => $categoryDetailDTO);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling CategoryRestControllerApi->replaceCategory: $@\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.CategoryRestControllerApi()
id = 789 # Long |  (default to null)
categoryDetailDTO =  # CategoryDetailDTO | 

try:
    api_response = api_instance.replace_category(id, categoryDetailDTO)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling CategoryRestControllerApi->replaceCategory: %s\n" % e)

extern crate CategoryRestControllerApi;

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

    let mut context = CategoryRestControllerApi::Context::default();
    let result = client.replaceCategory(id, categoryDetailDTO, &context).wait();

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

Scopes

Parameters

Path parameters

Name	Description
id*	Long (int64) Required

Body parameters

Name	Description
categoryDetailDTO *

Responses

Schema

DocumentRestController

downloadDni

/api/documents/{id}/file

Usage and SDK Samples

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

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

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

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

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

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

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

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

import org.openapitools.client.api.DocumentRestControllerApi;

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

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



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

[apiInstance downloadDniWith:id
              completionHandler: ^(File 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.DocumentRestControllerApi()
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.downloadDni(id, callback);

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

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

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

            try {
                File result = apiInstance.downloadDni(id);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DocumentRestControllerApi.downloadDni: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

eval {
    my $result = $api_instance->downloadDni(id => $id);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DocumentRestControllerApi->downloadDni: $@\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.DocumentRestControllerApi()
id = 789 # Long |  (default to null)

try:
    api_response = api_instance.download_dni(id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DocumentRestControllerApi->downloadDni: %s\n" % e)

extern crate DocumentRestControllerApi;

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

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

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

Scopes

Parameters

Path parameters

Name	Description
id*	Long (int64) Required

Responses

Schema

uploadUserDni

/api/documents/users/{id}/dni

Usage and SDK Samples

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

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

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

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

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

        try {
            DocumentDTO result = apiInstance.uploadUserDni(id, uploadUserDniRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DocumentRestControllerApi#uploadUserDni");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

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

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

import org.openapitools.client.api.DocumentRestControllerApi;

public class DocumentRestControllerApiExample {
    public static void main(String[] args) {
        DocumentRestControllerApi apiInstance = new DocumentRestControllerApi();
        Long id = 789; // Long | 
        UploadUserDniRequest uploadUserDniRequest = ; // UploadUserDniRequest | 

        try {
            DocumentDTO result = apiInstance.uploadUserDni(id, uploadUserDniRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling DocumentRestControllerApi#uploadUserDni");
            e.printStackTrace();
        }
    }
}



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

[apiInstance uploadUserDniWith:id
    uploadUserDniRequest:uploadUserDniRequest
              completionHandler: ^(DocumentDTO 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.DocumentRestControllerApi()
var id = 789; // {Long} 
var opts = {
  'uploadUserDniRequest':  // {UploadUserDniRequest} 
};

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

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

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

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

            try {
                DocumentDTO result = apiInstance.uploadUserDni(id, uploadUserDniRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling DocumentRestControllerApi.uploadUserDni: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

eval {
    my $result = $api_instance->uploadUserDni(id => $id, uploadUserDniRequest => $uploadUserDniRequest);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling DocumentRestControllerApi->uploadUserDni: $@\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.DocumentRestControllerApi()
id = 789 # Long |  (default to null)
uploadUserDniRequest =  # UploadUserDniRequest |  (optional)

try:
    api_response = api_instance.upload_user_dni(id, uploadUserDniRequest=uploadUserDniRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling DocumentRestControllerApi->uploadUserDni: %s\n" % e)

extern crate DocumentRestControllerApi;

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

    let mut context = DocumentRestControllerApi::Context::default();
    let result = client.uploadUserDni(id, uploadUserDniRequest, &context).wait();

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

Scopes

Parameters

Path parameters

Name	Description
id*	Long (int64) Required

Body parameters

Name	Description
uploadUserDniRequest

Responses

Schema

ImageController

getImage

/image/{id}

Usage and SDK Samples

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

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

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

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

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

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

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

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

import org.openapitools.client.api.ImageControllerApi;

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

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



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

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

var OpenApiDefinition = require('open_api_definition');

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

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

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

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

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

            try {
                byte[] result = apiInstance.getImage(id);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ImageControllerApi.getImage: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

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

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

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

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

extern crate ImageControllerApi;

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

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

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

Scopes

Parameters

Path parameters

Name	Description
id*	Long (int64) Required

Responses

Schema

ImageRestController

createCategoryImage

/api/images/categories/{id}/images

Usage and SDK Samples

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

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

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

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

        // Create an instance of the API class
        ImageRestControllerApi apiInstance = new ImageRestControllerApi();
        Integer id = 56; // Integer | 
        ReplaceImageRequest replaceImageRequest = ; // ReplaceImageRequest | 

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final Integer id = new Integer(); // Integer | 
final ReplaceImageRequest replaceImageRequest = new ReplaceImageRequest(); // ReplaceImageRequest | 

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

import org.openapitools.client.api.ImageRestControllerApi;

public class ImageRestControllerApiExample {
    public static void main(String[] args) {
        ImageRestControllerApi apiInstance = new ImageRestControllerApi();
        Integer id = 56; // Integer | 
        ReplaceImageRequest replaceImageRequest = ; // ReplaceImageRequest | 

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



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

[apiInstance createCategoryImageWith:id
    replaceImageRequest:replaceImageRequest
              completionHandler: ^(ImageDTO output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenApiDefinition = require('open_api_definition');

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

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

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

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

            // Create an instance of the API class
            var apiInstance = new ImageRestControllerApi();
            var id = 56;  // Integer |  (default to null)
            var replaceImageRequest = new ReplaceImageRequest(); // ReplaceImageRequest |  (optional) 

            try {
                ImageDTO result = apiInstance.createCategoryImage(id, replaceImageRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ImageRestControllerApi.createCategoryImage: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ImageRestControllerApi();
$id = 56; // Integer | 
$replaceImageRequest = ; // ReplaceImageRequest | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ImageRestControllerApi->new();
my $id = 56; # Integer | 
my $replaceImageRequest = WWW::OPenAPIClient::Object::ReplaceImageRequest->new(); # ReplaceImageRequest | 

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

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

# Create an instance of the API class
api_instance = openapi_client.ImageRestControllerApi()
id = 56 # Integer |  (default to null)
replaceImageRequest =  # ReplaceImageRequest |  (optional)

try:
    api_response = api_instance.create_category_image(id, replaceImageRequest=replaceImageRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ImageRestControllerApi->createCategoryImage: %s\n" % e)

extern crate ImageRestControllerApi;

pub fn main() {
    let id = 56; // Integer
    let replaceImageRequest = ; // ReplaceImageRequest

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

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

Scopes

Parameters

Path parameters

Name	Description
id*	Integer (int32) Required

Body parameters

Name	Description
replaceImageRequest

Responses

Schema

createProductImage

/api/images/{id}/images

Usage and SDK Samples

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

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

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

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

        // Create an instance of the API class
        ImageRestControllerApi apiInstance = new ImageRestControllerApi();
        Integer id = 56; // Integer | 
        ReplaceImageRequest replaceImageRequest = ; // ReplaceImageRequest | 

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final Integer id = new Integer(); // Integer | 
final ReplaceImageRequest replaceImageRequest = new ReplaceImageRequest(); // ReplaceImageRequest | 

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

import org.openapitools.client.api.ImageRestControllerApi;

public class ImageRestControllerApiExample {
    public static void main(String[] args) {
        ImageRestControllerApi apiInstance = new ImageRestControllerApi();
        Integer id = 56; // Integer | 
        ReplaceImageRequest replaceImageRequest = ; // ReplaceImageRequest | 

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



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

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

var OpenApiDefinition = require('open_api_definition');

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

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

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

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

            // Create an instance of the API class
            var apiInstance = new ImageRestControllerApi();
            var id = 56;  // Integer |  (default to null)
            var replaceImageRequest = new ReplaceImageRequest(); // ReplaceImageRequest |  (optional) 

            try {
                ImageDTO result = apiInstance.createProductImage(id, replaceImageRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ImageRestControllerApi.createProductImage: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ImageRestControllerApi();
$id = 56; // Integer | 
$replaceImageRequest = ; // ReplaceImageRequest | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ImageRestControllerApi->new();
my $id = 56; # Integer | 
my $replaceImageRequest = WWW::OPenAPIClient::Object::ReplaceImageRequest->new(); # ReplaceImageRequest | 

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

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

# Create an instance of the API class
api_instance = openapi_client.ImageRestControllerApi()
id = 56 # Integer |  (default to null)
replaceImageRequest =  # ReplaceImageRequest |  (optional)

try:
    api_response = api_instance.create_product_image(id, replaceImageRequest=replaceImageRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ImageRestControllerApi->createProductImage: %s\n" % e)

extern crate ImageRestControllerApi;

pub fn main() {
    let id = 56; // Integer
    let replaceImageRequest = ; // ReplaceImageRequest

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

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

Scopes

Parameters

Path parameters

Name	Description
id*	Integer (int32) Required

Body parameters

Name	Description
replaceImageRequest

Responses

Schema

createUserImage

/api/images/users/{id}/image

Usage and SDK Samples

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

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

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

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

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

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

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

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

import org.openapitools.client.api.ImageRestControllerApi;

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

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



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

[apiInstance createUserImageWith:id
    replaceImageRequest:replaceImageRequest
              completionHandler: ^(ImageDTO output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenApiDefinition = require('open_api_definition');

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

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

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

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

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

            try {
                ImageDTO result = apiInstance.createUserImage(id, replaceImageRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ImageRestControllerApi.createUserImage: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

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

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

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

try:
    api_response = api_instance.create_user_image(id, replaceImageRequest=replaceImageRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ImageRestControllerApi->createUserImage: %s\n" % e)

extern crate ImageRestControllerApi;

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

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

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

Scopes

Parameters

Path parameters

Name	Description
id*	Long (int64) Required

Body parameters

Name	Description
replaceImageRequest

Responses

Schema

deleteCategoryImage

/api/images/categories/{categoryId}/images/{imageId}

Usage and SDK Samples

curl -X DELETE \
 -H "Accept: */*" \
 "https://localhost:8443/api/images/categories/{categoryId}/images/{imageId}"

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

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

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

        // Create an instance of the API class
        ImageRestControllerApi apiInstance = new ImageRestControllerApi();
        Integer categoryId = 56; // Integer | 
        Long imageId = 789; // Long | 

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final Integer categoryId = new Integer(); // Integer | 
final Long imageId = new Long(); // Long | 

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

import org.openapitools.client.api.ImageRestControllerApi;

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

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



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

[apiInstance deleteCategoryImageWith:categoryId
    imageId:imageId
              completionHandler: ^(ImageDTO output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenApiDefinition = require('open_api_definition');

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

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

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

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

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

            try {
                ImageDTO result = apiInstance.deleteCategoryImage(categoryId, imageId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ImageRestControllerApi.deleteCategoryImage: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

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

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

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

try:
    api_response = api_instance.delete_category_image(categoryId, imageId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ImageRestControllerApi->deleteCategoryImage: %s\n" % e)

extern crate ImageRestControllerApi;

pub fn main() {
    let categoryId = 56; // Integer
    let imageId = 789; // Long

    let mut context = ImageRestControllerApi::Context::default();
    let result = client.deleteCategoryImage(categoryId, imageId, &context).wait();

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

Scopes

Parameters

Path parameters

Name	Description
categoryId*	Integer (int32) Required
imageId*	Long (int64) Required

Responses

Schema

deleteProductImage

/api/images/{productId}/images/{imageId}

Usage and SDK Samples

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

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

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

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

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

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

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

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

import org.openapitools.client.api.ImageRestControllerApi;

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

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



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

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

var OpenApiDefinition = require('open_api_definition');

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

extern crate ImageRestControllerApi;

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

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

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

Scopes

Parameters

Path parameters

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

Responses

Schema

deleteUserImage

/api/images/users/{userId}/image/{imageId}

Usage and SDK Samples

curl -X DELETE \
 -H "Accept: */*" \
 "https://localhost:8443/api/images/users/{userId}/image/{imageId}"

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

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

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

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

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

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

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

import org.openapitools.client.api.ImageRestControllerApi;

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

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



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

[apiInstance deleteUserImageWith:userId
    imageId:imageId
              completionHandler: ^(ImageDTO output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenApiDefinition = require('open_api_definition');

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

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

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

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

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

            try {
                ImageDTO result = apiInstance.deleteUserImage(userId, imageId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ImageRestControllerApi.deleteUserImage: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

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

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

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

try:
    api_response = api_instance.delete_user_image(userId, imageId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ImageRestControllerApi->deleteUserImage: %s\n" % e)

extern crate ImageRestControllerApi;

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

    let mut context = ImageRestControllerApi::Context::default();
    let result = client.deleteUserImage(userId, imageId, &context).wait();

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

Scopes

Parameters

Path parameters

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

Responses

Schema

getImage1

/api/images/{id}

Usage and SDK Samples

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

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

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

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

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

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

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

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

import org.openapitools.client.api.ImageRestControllerApi;

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

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



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

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

var OpenApiDefinition = require('open_api_definition');

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

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

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

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

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

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

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

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

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

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

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

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

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

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

try:
    api_response = api_instance.get_image1(id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ImageRestControllerApi->getImage1: %s\n" % e)

extern crate ImageRestControllerApi;

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

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

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

Scopes

Parameters

Path parameters

Name	Description
id*	Long (int64) Required

Responses

Schema

getImageMedia

/api/images/{id}/images

Usage and SDK Samples

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

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

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

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

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

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

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

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

import org.openapitools.client.api.ImageRestControllerApi;

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

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



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

[apiInstance getImageMediaWith:id
              completionHandler: ^(byte[] output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenApiDefinition = require('open_api_definition');

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

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

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

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

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

            try {
                byte[] result = apiInstance.getImageMedia(id);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ImageRestControllerApi.getImageMedia: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

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

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

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

try:
    api_response = api_instance.get_image_media(id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ImageRestControllerApi->getImageMedia: %s\n" % e)

extern crate ImageRestControllerApi;

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

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

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

Scopes

Parameters

Path parameters

Name	Description
id*	Long (int64) Required

Responses

Schema

replaceImage

/api/images/{id}/images

Usage and SDK Samples

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

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

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

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

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

        try {
            apiInstance.replaceImage(id, replaceImageRequest);
        } catch (ApiException e) {
            System.err.println("Exception when calling ImageRestControllerApi#replaceImage");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

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

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

import org.openapitools.client.api.ImageRestControllerApi;

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

        try {
            apiInstance.replaceImage(id, replaceImageRequest);
        } catch (ApiException e) {
            System.err.println("Exception when calling ImageRestControllerApi#replaceImage");
            e.printStackTrace();
        }
    }
}



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

[apiInstance replaceImageWith:id
    replaceImageRequest:replaceImageRequest
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenApiDefinition = require('open_api_definition');

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

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

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

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

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

            try {
                apiInstance.replaceImage(id, replaceImageRequest);
            } catch (Exception e) {
                Debug.Print("Exception when calling ImageRestControllerApi.replaceImage: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

eval {
    $api_instance->replaceImage(id => $id, replaceImageRequest => $replaceImageRequest);
};
if ($@) {
    warn "Exception when calling ImageRestControllerApi->replaceImage: $@\n";
}

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

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

try:
    api_instance.replace_image(id, replaceImageRequest=replaceImageRequest)
except ApiException as e:
    print("Exception when calling ImageRestControllerApi->replaceImage: %s\n" % e)

extern crate ImageRestControllerApi;

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

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

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

Scopes

Parameters

Path parameters

Name	Description
id*	Long (int64) Required

Body parameters

Name	Description
replaceImageRequest

Responses

replaceUserImage

/api/images/users/{id}/image

Usage and SDK Samples

curl -X PUT \
 -H "Content-Type: application/json" \
 "https://localhost:8443/api/images/users/{id}/image" \
 -d ''

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

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

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

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

        try {
            apiInstance.replaceUserImage(id, replaceImageRequest);
        } catch (ApiException e) {
            System.err.println("Exception when calling ImageRestControllerApi#replaceUserImage");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

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

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

import org.openapitools.client.api.ImageRestControllerApi;

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

        try {
            apiInstance.replaceUserImage(id, replaceImageRequest);
        } catch (ApiException e) {
            System.err.println("Exception when calling ImageRestControllerApi#replaceUserImage");
            e.printStackTrace();
        }
    }
}



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

[apiInstance replaceUserImageWith:id
    replaceImageRequest:replaceImageRequest
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenApiDefinition = require('open_api_definition');

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

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

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

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

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

            try {
                apiInstance.replaceUserImage(id, replaceImageRequest);
            } catch (Exception e) {
                Debug.Print("Exception when calling ImageRestControllerApi.replaceUserImage: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

eval {
    $api_instance->replaceUserImage(id => $id, replaceImageRequest => $replaceImageRequest);
};
if ($@) {
    warn "Exception when calling ImageRestControllerApi->replaceUserImage: $@\n";
}

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

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

try:
    api_instance.replace_user_image(id, replaceImageRequest=replaceImageRequest)
except ApiException as e:
    print("Exception when calling ImageRestControllerApi->replaceUserImage: %s\n" % e)

extern crate ImageRestControllerApi;

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

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

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

Scopes

Parameters

Path parameters

Name	Description
id*	Long (int64) Required

Body parameters

Name	Description
replaceImageRequest

Responses

LoginController

logOut

/api/auth/logout

Usage and SDK Samples

curl -X POST \
 -H "Accept: */*" \
 "https://localhost:8443/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 'package:openapi/api.dart';

final api_instance = DefaultApi();


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

import org.openapitools.client.api.LoginControllerApi;

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

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



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

[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

Schema

login

/api/auth/login

Usage and SDK Samples

curl -X POST \
 -H "Accept: */*" \
 -H "Content-Type: application/json" \
 "https://localhost:8443/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 | 

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

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

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

import org.openapitools.client.api.LoginControllerApi;

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

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



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

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

var OpenApiDefinition = require('open_api_definition');

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

extern crate LoginControllerApi;

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

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

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

Scopes

Parameters

Body parameters

Name	Description
loginRequest *

Responses

refreshToken

/api/auth/refresh

Usage and SDK Samples

curl -X POST \
 -H "Accept: */*" \
 "https://localhost:8443/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 'package:openapi/api.dart';

final api_instance = DefaultApi();

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

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

import org.openapitools.client.api.LoginControllerApi;

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

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



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

[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

Schema

OrderRestController

createOrder

/api/orders/

Usage and SDK Samples

curl -X POST \
 -H "Accept: */*" \
 -H "Content-Type: application/json" \
 "https://localhost:8443/api/orders/" \
 -d '{
  "fecha" : "2000-01-23T04:56:07.000+00:00",
  "total" : 6.027456183070403,
  "nickname" : "nickname",
  "id" : 0,
  "items" : [ {
    "precio" : 2.3021358869347655,
    "productId" : 5,
    "subtotal" : 7.061401241503109,
    "imageUrl" : "imageUrl",
    "id" : 1,
    "cantidad" : 5,
    "productName" : "productName"
  }, {
    "precio" : 2.3021358869347655,
    "productId" : 5,
    "subtotal" : 7.061401241503109,
    "imageUrl" : "imageUrl",
    "id" : 1,
    "cantidad" : 5,
    "productName" : "productName"
  } ],
  "email" : "email"
}'

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

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

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

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

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final OrderDetailDTO orderDetailDTO = new OrderDetailDTO(); // OrderDetailDTO | 

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

import org.openapitools.client.api.OrderRestControllerApi;

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

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



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

[apiInstance createOrderWith:orderDetailDTO
              completionHandler: ^(OrderDetailDTO output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenApiDefinition = require('open_api_definition');

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

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

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

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

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

            try {
                OrderDetailDTO result = apiInstance.createOrder(orderDetailDTO);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling OrderRestControllerApi.createOrder: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

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

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

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

try:
    api_response = api_instance.create_order(orderDetailDTO)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling OrderRestControllerApi->createOrder: %s\n" % e)

extern crate OrderRestControllerApi;

pub fn main() {
    let orderDetailDTO = ; // OrderDetailDTO

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

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

Scopes

Parameters

Body parameters

Name	Description
orderDetailDTO *

Responses

Schema

deleteOrder

/api/orders/{id}

Usage and SDK Samples

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

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

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

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

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

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

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

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

import org.openapitools.client.api.OrderRestControllerApi;

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

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



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

[apiInstance deleteOrderWith:id
              completionHandler: ^(OrderDetailDTO output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenApiDefinition = require('open_api_definition');

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

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

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

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

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

            try {
                OrderDetailDTO result = apiInstance.deleteOrder(id);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling OrderRestControllerApi.deleteOrder: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

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

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

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

try:
    api_response = api_instance.delete_order(id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling OrderRestControllerApi->deleteOrder: %s\n" % e)

extern crate OrderRestControllerApi;

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

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

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

Scopes

Parameters

Path parameters

Name	Description
id*	Long (int64) Required

Responses

Schema

getOrder

/api/orders/{id}

Usage and SDK Samples

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

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

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

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

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

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

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

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

import org.openapitools.client.api.OrderRestControllerApi;

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

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



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

[apiInstance getOrderWith:id
              completionHandler: ^(OrderDetailDTO output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenApiDefinition = require('open_api_definition');

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

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

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

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

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

            try {
                OrderDetailDTO result = apiInstance.getOrder(id);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling OrderRestControllerApi.getOrder: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

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

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

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

try:
    api_response = api_instance.get_order(id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling OrderRestControllerApi->getOrder: %s\n" % e)

extern crate OrderRestControllerApi;

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

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

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

Scopes

Parameters

Path parameters

Name	Description
id*	Long (int64) Required

Responses

Schema

getOrders

/api/orders/

Usage and SDK Samples

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

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

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

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

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

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

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

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

import org.openapitools.client.api.OrderRestControllerApi;

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

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



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

[apiInstance getOrdersWith:pageable
              completionHandler: ^(PagedModelOrderBasicDTO output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenApiDefinition = require('open_api_definition');

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

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

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

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

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

            try {
                PagedModelOrderBasicDTO result = apiInstance.getOrders(pageable);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling OrderRestControllerApi.getOrders: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

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

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

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

try:
    api_response = api_instance.get_orders(pageable)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling OrderRestControllerApi->getOrders: %s\n" % e)

extern crate OrderRestControllerApi;

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

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

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

Scopes

Parameters

Query parameters

Name	Description
pageable*	Pageable Required

Responses

Schema

ProductRestController

createProduct1

/api/products/

Usage and SDK Samples

curl -X POST \
 -H "Accept: */*" \
 -H "Content-Type: application/json" \
 "https://localhost:8443/api/products/" \
 -d '{
  "descripcion" : "descripcion",
  "image" : {
    "id" : 6
  },
  "precio" : 6.027456183070403,
  "reviews" : [ {
    "fecha" : "2000-01-23",
    "usuario" : "usuario",
    "id" : 5,
    "comentario" : "comentario",
    "estrellas" : 5
  }, {
    "fecha" : "2000-01-23",
    "usuario" : "usuario",
    "id" : 5,
    "comentario" : "comentario",
    "estrellas" : 5
  } ],
  "id" : 0,
  "category" : {
    "name" : "name",
    "id" : 1
  },
  "nombre" : "nombre"
}'

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();
        ProductDetailDTO productDetailDTO = ; // ProductDetailDTO | 

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final ProductDetailDTO productDetailDTO = new ProductDetailDTO(); // ProductDetailDTO | 

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

import org.openapitools.client.api.ProductRestControllerApi;

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

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



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

[apiInstance createProduct1With:productDetailDTO
              completionHandler: ^(ProductDetailDTO 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 productDetailDTO = ; // {ProductDetailDTO} 

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

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

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

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

            try {
                ProductDetailDTO result = apiInstance.createProduct1(productDetailDTO);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ProductRestControllerApi.createProduct1: " + e.Message );
            }
        }
    }
}

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

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

try {
    $result = $api_instance->createProduct1($productDetailDTO);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ProductRestControllerApi->createProduct1: ', $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 $productDetailDTO = WWW::OPenAPIClient::Object::ProductDetailDTO->new(); # ProductDetailDTO | 

eval {
    my $result = $api_instance->createProduct1(productDetailDTO => $productDetailDTO);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ProductRestControllerApi->createProduct1: $@\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()
productDetailDTO =  # ProductDetailDTO | 

try:
    api_response = api_instance.create_product1(productDetailDTO)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ProductRestControllerApi->createProduct1: %s\n" % e)

extern crate ProductRestControllerApi;

pub fn main() {
    let productDetailDTO = ; // ProductDetailDTO

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

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

Scopes

Parameters

Body parameters

Name	Description
productDetailDTO *

Responses

Schema

deleteProduct

/api/products/{id}

Usage and SDK Samples

curl -X DELETE \
 -H "Accept: */*" \
 "https://localhost:8443/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();
        Integer id = 56; // Integer | 

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

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

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

import org.openapitools.client.api.ProductRestControllerApi;

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

        try {
            ProductDetailDTO 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];
Integer *id = 56; //  (default to null)

[apiInstance deleteProductWith:id
              completionHandler: ^(ProductDetailDTO 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 = 56; // {Integer} 

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 = 56;  // Integer |  (default to null)

            try {
                ProductDetailDTO 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 = 56; // Integer | 

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 = 56; # Integer | 

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 = 56 # Integer |  (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 = 56; // Integer

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

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

Scopes

Parameters

Path parameters

Name	Description
id*	Integer (int32) Required

Responses

Schema

getProducts

/api/products/

Usage and SDK Samples

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

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

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

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

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

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

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

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

import org.openapitools.client.api.ProductRestControllerApi;

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

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



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

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

var OpenApiDefinition = require('open_api_definition');

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

extern crate ProductRestControllerApi;

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

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

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

Scopes

Parameters

Query parameters

Name	Description
pageable*	Pageable Required

Responses

Schema

getproduct

/api/products/{id}

Usage and SDK Samples

curl -X GET \
 -H "Accept: */*" \
 "https://localhost:8443/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();
        Integer id = 56; // Integer | 

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

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

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

import org.openapitools.client.api.ProductRestControllerApi;

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

        try {
            ProductDetailDTO result = apiInstance.getproduct(id);
            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];
Integer *id = 56; //  (default to null)

[apiInstance getproductWith:id
              completionHandler: ^(ProductDetailDTO 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 = 56; // {Integer} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getproduct(id, 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 id = 56;  // Integer |  (default to null)

            try {
                ProductDetailDTO result = apiInstance.getproduct(id);
                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();
$id = 56; // Integer | 

try {
    $result = $api_instance->getproduct($id);
    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 $id = 56; # Integer | 

eval {
    my $result = $api_instance->getproduct(id => $id);
    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()
id = 56 # Integer |  (default to null)

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

extern crate ProductRestControllerApi;

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

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

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

Scopes

Parameters

Path parameters

Name	Description
id*	Integer (int32) Required

Responses

Schema

replaceProduct

/api/products/{id}

Usage and SDK Samples

curl -X PUT \
 -H "Accept: */*" \
 -H "Content-Type: application/json" \
 "https://localhost:8443/api/products/{id}" \
 -d '{
  "descripcion" : "descripcion",
  "image" : {
    "id" : 6
  },
  "precio" : 6.027456183070403,
  "reviews" : [ {
    "fecha" : "2000-01-23",
    "usuario" : "usuario",
    "id" : 5,
    "comentario" : "comentario",
    "estrellas" : 5
  }, {
    "fecha" : "2000-01-23",
    "usuario" : "usuario",
    "id" : 5,
    "comentario" : "comentario",
    "estrellas" : 5
  } ],
  "id" : 0,
  "category" : {
    "name" : "name",
    "id" : 1
  },
  "nombre" : "nombre"
}'

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();
        Integer id = 56; // Integer | 
        ProductDetailDTO productDetailDTO = ; // ProductDetailDTO | 

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final Integer id = new Integer(); // Integer | 
final ProductDetailDTO productDetailDTO = new ProductDetailDTO(); // ProductDetailDTO | 

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

import org.openapitools.client.api.ProductRestControllerApi;

public class ProductRestControllerApiExample {
    public static void main(String[] args) {
        ProductRestControllerApi apiInstance = new ProductRestControllerApi();
        Integer id = 56; // Integer | 
        ProductDetailDTO productDetailDTO = ; // ProductDetailDTO | 

        try {
            ProductDetailDTO result = apiInstance.replaceProduct(id, productDetailDTO);
            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];
Integer *id = 56; //  (default to null)
ProductDetailDTO *productDetailDTO = ; // 

[apiInstance replaceProductWith:id
    productDetailDTO:productDetailDTO
              completionHandler: ^(ProductDetailDTO 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 = 56; // {Integer} 
var productDetailDTO = ; // {ProductDetailDTO} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.replaceProduct(id, productDetailDTO, 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 = 56;  // Integer |  (default to null)
            var productDetailDTO = new ProductDetailDTO(); // ProductDetailDTO | 

            try {
                ProductDetailDTO result = apiInstance.replaceProduct(id, productDetailDTO);
                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 = 56; // Integer | 
$productDetailDTO = ; // ProductDetailDTO | 

try {
    $result = $api_instance->replaceProduct($id, $productDetailDTO);
    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 = 56; # Integer | 
my $productDetailDTO = WWW::OPenAPIClient::Object::ProductDetailDTO->new(); # ProductDetailDTO | 

eval {
    my $result = $api_instance->replaceProduct(id => $id, productDetailDTO => $productDetailDTO);
    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 = 56 # Integer |  (default to null)
productDetailDTO =  # ProductDetailDTO | 

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

extern crate ProductRestControllerApi;

pub fn main() {
    let id = 56; // Integer
    let productDetailDTO = ; // ProductDetailDTO

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

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

Scopes

Parameters

Path parameters

Name	Description
id*	Integer (int32) Required

Body parameters

Name	Description
productDetailDTO *

Responses

Schema

ReviewRestController

createReview

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

Usage and SDK Samples

curl -X POST \
 -H "Accept: */*" \
 -H "Content-Type: application/json" \
 "https://localhost:8443/api/reviews/products/{productId}/reviews" \
 -d '{
  "fecha" : "2000-01-23",
  "product" : {
    "descripcion" : "descripcion",
    "image" : {
      "data" : "data",
      "id" : 9
    },
    "precio" : 5.962133916683182,
    "reviews" : [ null, null ],
    "precioOriginal" : 5.637376656633329,
    "id" : 1,
    "precioOferta" : 2.3021358869347655,
    "category" : {
      "image" : {
        "data" : "data",
        "id" : 9
      },
      "name" : "name",
      "id" : 7,
      "products" : [ null, null ]
    },
    "nombre" : "nombre",
    "promotion" : true
  },
  "usuario" : "usuario",
  "id" : 0,
  "comentario" : "comentario",
  "estrellas" : 6
}'

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

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

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

        // Create an instance of the API class
        ReviewRestControllerApi apiInstance = new ReviewRestControllerApi();
        Integer productId = 56; // Integer | 
        Review review = ; // Review | 

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final Integer productId = new Integer(); // Integer | 
final Review review = new Review(); // Review | 

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

import org.openapitools.client.api.ReviewRestControllerApi;

public class ReviewRestControllerApiExample {
    public static void main(String[] args) {
        ReviewRestControllerApi apiInstance = new ReviewRestControllerApi();
        Integer productId = 56; // Integer | 
        Review review = ; // Review | 

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



// Create an instance of the API class
ReviewRestControllerApi *apiInstance = [[ReviewRestControllerApi alloc] init];
Integer *productId = 56; //  (default to null)
Review *review = ; // 

[apiInstance createReviewWith:productId
    review:review
              completionHandler: ^(Review output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenApiDefinition = require('open_api_definition');

// Create an instance of the API class
var api = new OpenApiDefinition.ReviewRestControllerApi()
var productId = 56; // {Integer} 
var review = ; // {Review} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new ReviewRestControllerApi();
            var productId = 56;  // Integer |  (default to null)
            var review = new Review(); // Review | 

            try {
                Review result = apiInstance.createReview(productId, review);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ReviewRestControllerApi.createReview: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ReviewRestControllerApi();
$productId = 56; // Integer | 
$review = ; // Review | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ReviewRestControllerApi->new();
my $productId = 56; # Integer | 
my $review = WWW::OPenAPIClient::Object::Review->new(); # Review | 

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

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

# Create an instance of the API class
api_instance = openapi_client.ReviewRestControllerApi()
productId = 56 # Integer |  (default to null)
review =  # Review | 

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

extern crate ReviewRestControllerApi;

pub fn main() {
    let productId = 56; // Integer
    let review = ; // Review

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

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

Scopes

Parameters

Path parameters

Name	Description
productId*	Integer (int32) Required

Body parameters

Name	Description
review *

Responses

Schema

deleteReview

/api/reviews/reviews/{reviewId}

Usage and SDK Samples

curl -X DELETE \
 "https://localhost:8443/api/reviews/reviews/{reviewId}"

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

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

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

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

        try {
            apiInstance.deleteReview(reviewId);
        } catch (ApiException e) {
            System.err.println("Exception when calling ReviewRestControllerApi#deleteReview");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

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

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

import org.openapitools.client.api.ReviewRestControllerApi;

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

        try {
            apiInstance.deleteReview(reviewId);
        } catch (ApiException e) {
            System.err.println("Exception when calling ReviewRestControllerApi#deleteReview");
            e.printStackTrace();
        }
    }
}



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

[apiInstance deleteReviewWith:reviewId
              completionHandler: ^(NSError* error) {
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenApiDefinition = require('open_api_definition');

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

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

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

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

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

            try {
                apiInstance.deleteReview(reviewId);
            } catch (Exception e) {
                Debug.Print("Exception when calling ReviewRestControllerApi.deleteReview: " + e.Message );
            }
        }
    }
}

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

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

try {
    $api_instance->deleteReview($reviewId);
} catch (Exception $e) {
    echo 'Exception when calling ReviewRestControllerApi->deleteReview: ', $e->getMessage(), PHP_EOL;
}
?>

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

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

eval {
    $api_instance->deleteReview(reviewId => $reviewId);
};
if ($@) {
    warn "Exception when calling ReviewRestControllerApi->deleteReview: $@\n";
}

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

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

try:
    api_instance.delete_review(reviewId)
except ApiException as e:
    print("Exception when calling ReviewRestControllerApi->deleteReview: %s\n" % e)

extern crate ReviewRestControllerApi;

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

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

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

Scopes

Parameters

Path parameters

Name	Description
reviewId*	Long (int64) Required

Responses

getReview

/api/reviews/{id}

Usage and SDK Samples

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

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

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

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

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

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

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

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

import org.openapitools.client.api.ReviewRestControllerApi;

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

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



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

[apiInstance getReviewWith:id
              completionHandler: ^(ReviewDetailDTO output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenApiDefinition = require('open_api_definition');

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

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

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

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

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

            try {
                ReviewDetailDTO result = apiInstance.getReview(id);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ReviewRestControllerApi.getReview: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

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

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

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

try:
    api_response = api_instance.get_review(id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ReviewRestControllerApi->getReview: %s\n" % e)

extern crate ReviewRestControllerApi;

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

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

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

Scopes

Parameters

Path parameters

Name	Description
id*	Long (int64) Required

Responses

Schema

getReviews

/api/reviews/

Usage and SDK Samples

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

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

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

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

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

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

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

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

import org.openapitools.client.api.ReviewRestControllerApi;

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

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



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

[apiInstance getReviewsWith:pageable
              completionHandler: ^(PagedModelReviewDetailDTO output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenApiDefinition = require('open_api_definition');

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

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

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

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

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

            try {
                PagedModelReviewDetailDTO result = apiInstance.getReviews(pageable);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ReviewRestControllerApi.getReviews: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

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

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

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

try:
    api_response = api_instance.get_reviews(pageable)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ReviewRestControllerApi->getReviews: %s\n" % e)

extern crate ReviewRestControllerApi;

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

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

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

Scopes

Parameters

Query parameters

Name	Description
pageable*	Pageable Required

Responses

Schema

updateReview

/api/reviews/reviews/{reviewId}

Usage and SDK Samples

curl -X PUT \
 -H "Accept: */*" \
 -H "Content-Type: application/json" \
 "https://localhost:8443/api/reviews/reviews/{reviewId}" \
 -d '{
  "fecha" : "2000-01-23",
  "product" : {
    "descripcion" : "descripcion",
    "image" : {
      "data" : "data",
      "id" : 9
    },
    "precio" : 5.962133916683182,
    "reviews" : [ null, null ],
    "precioOriginal" : 5.637376656633329,
    "id" : 1,
    "precioOferta" : 2.3021358869347655,
    "category" : {
      "image" : {
        "data" : "data",
        "id" : 9
      },
      "name" : "name",
      "id" : 7,
      "products" : [ null, null ]
    },
    "nombre" : "nombre",
    "promotion" : true
  },
  "usuario" : "usuario",
  "id" : 0,
  "comentario" : "comentario",
  "estrellas" : 6
}'

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

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

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

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

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final Long reviewId = new Long(); // Long | 
final Review review = new Review(); // Review | 

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

import org.openapitools.client.api.ReviewRestControllerApi;

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

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



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

[apiInstance updateReviewWith:reviewId
    review:review
              completionHandler: ^(Review output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenApiDefinition = require('open_api_definition');

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

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

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

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

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

            try {
                Review result = apiInstance.updateReview(reviewId, review);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ReviewRestControllerApi.updateReview: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

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

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

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

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

extern crate ReviewRestControllerApi;

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

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

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

Scopes

Parameters

Path parameters

Name	Description
reviewId*	Long (int64) Required

Body parameters

Name	Description
review *

Responses

Schema

UserController

verUsuariosRegistrados

/ver-usuarios

Usage and SDK Samples

curl -X GET \
 -H "Accept: */*" \
 "https://localhost:8443/ver-usuarios"

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.UserControllerApi;

import java.io.File;
import java.util.*;

public class UserControllerApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        UserControllerApi apiInstance = new UserControllerApi();

        try {
            array[User] result = apiInstance.verUsuariosRegistrados();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling UserControllerApi#verUsuariosRegistrados");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();


try {
    final result = await api_instance.verUsuariosRegistrados();
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->verUsuariosRegistrados: $e\n');
}

import org.openapitools.client.api.UserControllerApi;

public class UserControllerApiExample {
    public static void main(String[] args) {
        UserControllerApi apiInstance = new UserControllerApi();

        try {
            array[User] result = apiInstance.verUsuariosRegistrados();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling UserControllerApi#verUsuariosRegistrados");
            e.printStackTrace();
        }
    }
}



// Create an instance of the API class
UserControllerApi *apiInstance = [[UserControllerApi alloc] init];

[apiInstance verUsuariosRegistradosWithCompletionHandler: 
              ^(array[User] 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.UserControllerApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.verUsuariosRegistrados(callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class verUsuariosRegistradosExample
    {
        public void main()
        {

            // Create an instance of the API class
            var apiInstance = new UserControllerApi();

            try {
                array[User] result = apiInstance.verUsuariosRegistrados();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling UserControllerApi.verUsuariosRegistrados: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\UserControllerApi();

try {
    $result = $api_instance->verUsuariosRegistrados();
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling UserControllerApi->verUsuariosRegistrados: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::UserControllerApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::UserControllerApi->new();

eval {
    my $result = $api_instance->verUsuariosRegistrados();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling UserControllerApi->verUsuariosRegistrados: $@\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.UserControllerApi()

try:
    api_response = api_instance.ver_usuarios_registrados()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling UserControllerApi->verUsuariosRegistrados: %s\n" % e)

extern crate UserControllerApi;

pub fn main() {

    let mut context = UserControllerApi::Context::default();
    let result = client.verUsuariosRegistrados(&context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Responses

Schema

UserRestController

createProduct

/api/users/

Usage and SDK Samples

curl -X POST \
 -H "Accept: */*" \
 -H "Content-Type: application/json" \
 "https://localhost:8443/api/users/" \
 -d '{
  "role" : "role",
  "surname" : "surname",
  "name" : "name",
  "nickname" : "nickname",
  "id" : 0,
  "profileImage" : {
    "id" : 6
  },
  "birthDate" : "2000-01-23",
  "email" : "email"
}'

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.UserRestControllerApi;

import java.io.File;
import java.util.*;

public class UserRestControllerApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        UserRestControllerApi apiInstance = new UserRestControllerApi();
        UserDetailDTO userDetailDTO = ; // UserDetailDTO | 

        try {
            UserDetailDTO result = apiInstance.createProduct(userDetailDTO);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling UserRestControllerApi#createProduct");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final UserDetailDTO userDetailDTO = new UserDetailDTO(); // UserDetailDTO | 

try {
    final result = await api_instance.createProduct(userDetailDTO);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->createProduct: $e\n');
}

import org.openapitools.client.api.UserRestControllerApi;

public class UserRestControllerApiExample {
    public static void main(String[] args) {
        UserRestControllerApi apiInstance = new UserRestControllerApi();
        UserDetailDTO userDetailDTO = ; // UserDetailDTO | 

        try {
            UserDetailDTO result = apiInstance.createProduct(userDetailDTO);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling UserRestControllerApi#createProduct");
            e.printStackTrace();
        }
    }
}



// Create an instance of the API class
UserRestControllerApi *apiInstance = [[UserRestControllerApi alloc] init];
UserDetailDTO *userDetailDTO = ; // 

[apiInstance createProductWith:userDetailDTO
              completionHandler: ^(UserDetailDTO output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenApiDefinition = require('open_api_definition');

// Create an instance of the API class
var api = new OpenApiDefinition.UserRestControllerApi()
var userDetailDTO = ; // {UserDetailDTO} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.createProduct(userDetailDTO, 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 UserRestControllerApi();
            var userDetailDTO = new UserDetailDTO(); // UserDetailDTO | 

            try {
                UserDetailDTO result = apiInstance.createProduct(userDetailDTO);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling UserRestControllerApi.createProduct: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\UserRestControllerApi();
$userDetailDTO = ; // UserDetailDTO | 

try {
    $result = $api_instance->createProduct($userDetailDTO);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling UserRestControllerApi->createProduct: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::UserRestControllerApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::UserRestControllerApi->new();
my $userDetailDTO = WWW::OPenAPIClient::Object::UserDetailDTO->new(); # UserDetailDTO | 

eval {
    my $result = $api_instance->createProduct(userDetailDTO => $userDetailDTO);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling UserRestControllerApi->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.UserRestControllerApi()
userDetailDTO =  # UserDetailDTO | 

try:
    api_response = api_instance.create_product(userDetailDTO)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling UserRestControllerApi->createProduct: %s\n" % e)

extern crate UserRestControllerApi;

pub fn main() {
    let userDetailDTO = ; // UserDetailDTO

    let mut context = UserRestControllerApi::Context::default();
    let result = client.createProduct(userDetailDTO, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Body parameters

Name	Description
userDetailDTO *

Responses

Schema

deleteProfileImage

/api/users/{id}/image

Usage and SDK Samples

curl -X DELETE \
 -H "Accept: */*" \
 "https://localhost:8443/api/users/{id}/image"

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.UserRestControllerApi;

import java.io.File;
import java.util.*;

public class UserRestControllerApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        UserRestControllerApi apiInstance = new UserRestControllerApi();
        Long id = 789; // Long | 

        try {
            ImageDTO result = apiInstance.deleteProfileImage(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling UserRestControllerApi#deleteProfileImage");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final Long id = new Long(); // Long | 

try {
    final result = await api_instance.deleteProfileImage(id);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->deleteProfileImage: $e\n');
}

import org.openapitools.client.api.UserRestControllerApi;

public class UserRestControllerApiExample {
    public static void main(String[] args) {
        UserRestControllerApi apiInstance = new UserRestControllerApi();
        Long id = 789; // Long | 

        try {
            ImageDTO result = apiInstance.deleteProfileImage(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling UserRestControllerApi#deleteProfileImage");
            e.printStackTrace();
        }
    }
}



// Create an instance of the API class
UserRestControllerApi *apiInstance = [[UserRestControllerApi alloc] init];
Long *id = 789; //  (default to null)

[apiInstance deleteProfileImageWith:id
              completionHandler: ^(ImageDTO output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenApiDefinition = require('open_api_definition');

// Create an instance of the API class
var api = new OpenApiDefinition.UserRestControllerApi()
var id = 789; // {Long} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.deleteProfileImage(id, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class deleteProfileImageExample
    {
        public void main()
        {

            // Create an instance of the API class
            var apiInstance = new UserRestControllerApi();
            var id = 789;  // Long |  (default to null)

            try {
                ImageDTO result = apiInstance.deleteProfileImage(id);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling UserRestControllerApi.deleteProfileImage: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\UserRestControllerApi();
$id = 789; // Long | 

try {
    $result = $api_instance->deleteProfileImage($id);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling UserRestControllerApi->deleteProfileImage: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::UserRestControllerApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::UserRestControllerApi->new();
my $id = 789; # Long | 

eval {
    my $result = $api_instance->deleteProfileImage(id => $id);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling UserRestControllerApi->deleteProfileImage: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Create an instance of the API class
api_instance = openapi_client.UserRestControllerApi()
id = 789 # Long |  (default to null)

try:
    api_response = api_instance.delete_profile_image(id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling UserRestControllerApi->deleteProfileImage: %s\n" % e)

extern crate UserRestControllerApi;

pub fn main() {
    let id = 789; // Long

    let mut context = UserRestControllerApi::Context::default();
    let result = client.deleteProfileImage(id, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters

Name	Description
id*	Long (int64) Required

Responses

Schema

deleteUser

/api/users/{id}

Usage and SDK Samples

curl -X DELETE \
 -H "Accept: */*" \
 "https://localhost:8443/api/users/{id}"

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.UserRestControllerApi;

import java.io.File;
import java.util.*;

public class UserRestControllerApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        UserRestControllerApi apiInstance = new UserRestControllerApi();
        Long id = 789; // Long | 

        try {
            UserDetailDTO result = apiInstance.deleteUser(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling UserRestControllerApi#deleteUser");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final Long id = new Long(); // Long | 

try {
    final result = await api_instance.deleteUser(id);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->deleteUser: $e\n');
}

import org.openapitools.client.api.UserRestControllerApi;

public class UserRestControllerApiExample {
    public static void main(String[] args) {
        UserRestControllerApi apiInstance = new UserRestControllerApi();
        Long id = 789; // Long | 

        try {
            UserDetailDTO result = apiInstance.deleteUser(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling UserRestControllerApi#deleteUser");
            e.printStackTrace();
        }
    }
}



// Create an instance of the API class
UserRestControllerApi *apiInstance = [[UserRestControllerApi alloc] init];
Long *id = 789; //  (default to null)

[apiInstance deleteUserWith:id
              completionHandler: ^(UserDetailDTO output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenApiDefinition = require('open_api_definition');

// Create an instance of the API class
var api = new OpenApiDefinition.UserRestControllerApi()
var id = 789; // {Long} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.deleteUser(id, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class deleteUserExample
    {
        public void main()
        {

            // Create an instance of the API class
            var apiInstance = new UserRestControllerApi();
            var id = 789;  // Long |  (default to null)

            try {
                UserDetailDTO result = apiInstance.deleteUser(id);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling UserRestControllerApi.deleteUser: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\UserRestControllerApi();
$id = 789; // Long | 

try {
    $result = $api_instance->deleteUser($id);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling UserRestControllerApi->deleteUser: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::UserRestControllerApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::UserRestControllerApi->new();
my $id = 789; # Long | 

eval {
    my $result = $api_instance->deleteUser(id => $id);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling UserRestControllerApi->deleteUser: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Create an instance of the API class
api_instance = openapi_client.UserRestControllerApi()
id = 789 # Long |  (default to null)

try:
    api_response = api_instance.delete_user(id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling UserRestControllerApi->deleteUser: %s\n" % e)

extern crate UserRestControllerApi;

pub fn main() {
    let id = 789; // Long

    let mut context = UserRestControllerApi::Context::default();
    let result = client.deleteUser(id, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters

Name	Description
id*	Long (int64) Required

Responses

Schema

getUser

/api/users/{id}

Usage and SDK Samples

curl -X GET \
 -H "Accept: */*" \
 "https://localhost:8443/api/users/{id}"

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.UserRestControllerApi;

import java.io.File;
import java.util.*;

public class UserRestControllerApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        UserRestControllerApi apiInstance = new UserRestControllerApi();
        Long id = 789; // Long | 

        try {
            UserDetailDTO result = apiInstance.getUser(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling UserRestControllerApi#getUser");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final Long id = new Long(); // Long | 

try {
    final result = await api_instance.getUser(id);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->getUser: $e\n');
}

import org.openapitools.client.api.UserRestControllerApi;

public class UserRestControllerApiExample {
    public static void main(String[] args) {
        UserRestControllerApi apiInstance = new UserRestControllerApi();
        Long id = 789; // Long | 

        try {
            UserDetailDTO result = apiInstance.getUser(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling UserRestControllerApi#getUser");
            e.printStackTrace();
        }
    }
}



// Create an instance of the API class
UserRestControllerApi *apiInstance = [[UserRestControllerApi alloc] init];
Long *id = 789; //  (default to null)

[apiInstance getUserWith:id
              completionHandler: ^(UserDetailDTO output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenApiDefinition = require('open_api_definition');

// Create an instance of the API class
var api = new OpenApiDefinition.UserRestControllerApi()
var id = 789; // {Long} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getUser(id, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class getUserExample
    {
        public void main()
        {

            // Create an instance of the API class
            var apiInstance = new UserRestControllerApi();
            var id = 789;  // Long |  (default to null)

            try {
                UserDetailDTO result = apiInstance.getUser(id);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling UserRestControllerApi.getUser: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\UserRestControllerApi();
$id = 789; // Long | 

try {
    $result = $api_instance->getUser($id);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling UserRestControllerApi->getUser: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::UserRestControllerApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::UserRestControllerApi->new();
my $id = 789; # Long | 

eval {
    my $result = $api_instance->getUser(id => $id);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling UserRestControllerApi->getUser: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Create an instance of the API class
api_instance = openapi_client.UserRestControllerApi()
id = 789 # Long |  (default to null)

try:
    api_response = api_instance.get_user(id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling UserRestControllerApi->getUser: %s\n" % e)

extern crate UserRestControllerApi;

pub fn main() {
    let id = 789; // Long

    let mut context = UserRestControllerApi::Context::default();
    let result = client.getUser(id, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters

Name	Description
id*	Long (int64) Required

Responses

Schema

getUsers

/api/users/

Usage and SDK Samples

curl -X GET \
 -H "Accept: */*" \
 "https://localhost:8443/api/users/?pageable="

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.UserRestControllerApi;

import java.io.File;
import java.util.*;

public class UserRestControllerApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        UserRestControllerApi apiInstance = new UserRestControllerApi();
        Pageable pageable = ; // Pageable | 

        try {
            PagedModelUserBasicDTO result = apiInstance.getUsers(pageable);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling UserRestControllerApi#getUsers");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final Pageable pageable = new Pageable(); // Pageable | 

try {
    final result = await api_instance.getUsers(pageable);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->getUsers: $e\n');
}

import org.openapitools.client.api.UserRestControllerApi;

public class UserRestControllerApiExample {
    public static void main(String[] args) {
        UserRestControllerApi apiInstance = new UserRestControllerApi();
        Pageable pageable = ; // Pageable | 

        try {
            PagedModelUserBasicDTO result = apiInstance.getUsers(pageable);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling UserRestControllerApi#getUsers");
            e.printStackTrace();
        }
    }
}



// Create an instance of the API class
UserRestControllerApi *apiInstance = [[UserRestControllerApi alloc] init];
Pageable *pageable = ; //  (default to null)

[apiInstance getUsersWith:pageable
              completionHandler: ^(PagedModelUserBasicDTO output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenApiDefinition = require('open_api_definition');

// Create an instance of the API class
var api = new OpenApiDefinition.UserRestControllerApi()
var pageable = ; // {Pageable} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getUsers(pageable, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class getUsersExample
    {
        public void main()
        {

            // Create an instance of the API class
            var apiInstance = new UserRestControllerApi();
            var pageable = new Pageable(); // Pageable |  (default to null)

            try {
                PagedModelUserBasicDTO result = apiInstance.getUsers(pageable);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling UserRestControllerApi.getUsers: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\UserRestControllerApi();
$pageable = ; // Pageable | 

try {
    $result = $api_instance->getUsers($pageable);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling UserRestControllerApi->getUsers: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::UserRestControllerApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::UserRestControllerApi->new();
my $pageable = ; # Pageable | 

eval {
    my $result = $api_instance->getUsers(pageable => $pageable);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling UserRestControllerApi->getUsers: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Create an instance of the API class
api_instance = openapi_client.UserRestControllerApi()
pageable =  # Pageable |  (default to null)

try:
    api_response = api_instance.get_users(pageable)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling UserRestControllerApi->getUsers: %s\n" % e)

extern crate UserRestControllerApi;

pub fn main() {
    let pageable = ; // Pageable

    let mut context = UserRestControllerApi::Context::default();
    let result = client.getUsers(pageable, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Query parameters

Name	Description
pageable*	Pageable Required

Responses

Schema

replaceUser

/api/users/{id}

Usage and SDK Samples

curl -X PUT \
 -H "Accept: */*" \
 -H "Content-Type: application/json" \
 "https://localhost:8443/api/users/{id}" \
 -d '{
  "role" : "role",
  "surname" : "surname",
  "name" : "name",
  "nickname" : "nickname",
  "id" : 0,
  "profileImage" : {
    "id" : 6
  },
  "birthDate" : "2000-01-23",
  "email" : "email"
}'

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.UserRestControllerApi;

import java.io.File;
import java.util.*;

public class UserRestControllerApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        UserRestControllerApi apiInstance = new UserRestControllerApi();
        Long id = 789; // Long | 
        UserDetailDTO userDetailDTO = ; // UserDetailDTO | 

        try {
            UserDetailDTO result = apiInstance.replaceUser(id, userDetailDTO);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling UserRestControllerApi#replaceUser");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final Long id = new Long(); // Long | 
final UserDetailDTO userDetailDTO = new UserDetailDTO(); // UserDetailDTO | 

try {
    final result = await api_instance.replaceUser(id, userDetailDTO);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->replaceUser: $e\n');
}

import org.openapitools.client.api.UserRestControllerApi;

public class UserRestControllerApiExample {
    public static void main(String[] args) {
        UserRestControllerApi apiInstance = new UserRestControllerApi();
        Long id = 789; // Long | 
        UserDetailDTO userDetailDTO = ; // UserDetailDTO | 

        try {
            UserDetailDTO result = apiInstance.replaceUser(id, userDetailDTO);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling UserRestControllerApi#replaceUser");
            e.printStackTrace();
        }
    }
}



// Create an instance of the API class
UserRestControllerApi *apiInstance = [[UserRestControllerApi alloc] init];
Long *id = 789; //  (default to null)
UserDetailDTO *userDetailDTO = ; // 

[apiInstance replaceUserWith:id
    userDetailDTO:userDetailDTO
              completionHandler: ^(UserDetailDTO output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenApiDefinition = require('open_api_definition');

// Create an instance of the API class
var api = new OpenApiDefinition.UserRestControllerApi()
var id = 789; // {Long} 
var userDetailDTO = ; // {UserDetailDTO} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.replaceUser(id, userDetailDTO, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class replaceUserExample
    {
        public void main()
        {

            // Create an instance of the API class
            var apiInstance = new UserRestControllerApi();
            var id = 789;  // Long |  (default to null)
            var userDetailDTO = new UserDetailDTO(); // UserDetailDTO | 

            try {
                UserDetailDTO result = apiInstance.replaceUser(id, userDetailDTO);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling UserRestControllerApi.replaceUser: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\UserRestControllerApi();
$id = 789; // Long | 
$userDetailDTO = ; // UserDetailDTO | 

try {
    $result = $api_instance->replaceUser($id, $userDetailDTO);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling UserRestControllerApi->replaceUser: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::UserRestControllerApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::UserRestControllerApi->new();
my $id = 789; # Long | 
my $userDetailDTO = WWW::OPenAPIClient::Object::UserDetailDTO->new(); # UserDetailDTO | 

eval {
    my $result = $api_instance->replaceUser(id => $id, userDetailDTO => $userDetailDTO);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling UserRestControllerApi->replaceUser: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Create an instance of the API class
api_instance = openapi_client.UserRestControllerApi()
id = 789 # Long |  (default to null)
userDetailDTO =  # UserDetailDTO | 

try:
    api_response = api_instance.replace_user(id, userDetailDTO)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling UserRestControllerApi->replaceUser: %s\n" % e)

extern crate UserRestControllerApi;

pub fn main() {
    let id = 789; // Long
    let userDetailDTO = ; // UserDetailDTO

    let mut context = UserRestControllerApi::Context::default();
    let result = client.replaceUser(id, userDetailDTO, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters

Name	Description
id*	Long (int64) Required

Body parameters

Name	Description
userDetailDTO *

Responses

Schema

uploadProfileImage

/api/users/{id}/image

Usage and SDK Samples

curl -X POST \
 -H "Accept: */*" \
 -H "Content-Type: application/json" \
 "https://localhost:8443/api/users/{id}/image" \
 -d ''

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.UserRestControllerApi;

import java.io.File;
import java.util.*;

public class UserRestControllerApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        UserRestControllerApi apiInstance = new UserRestControllerApi();
        Long id = 789; // Long | 
        ReplaceImageRequest replaceImageRequest = ; // ReplaceImageRequest | 

        try {
            ImageDTO result = apiInstance.uploadProfileImage(id, replaceImageRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling UserRestControllerApi#uploadProfileImage");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final Long id = new Long(); // Long | 
final ReplaceImageRequest replaceImageRequest = new ReplaceImageRequest(); // ReplaceImageRequest | 

try {
    final result = await api_instance.uploadProfileImage(id, replaceImageRequest);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->uploadProfileImage: $e\n');
}

import org.openapitools.client.api.UserRestControllerApi;

public class UserRestControllerApiExample {
    public static void main(String[] args) {
        UserRestControllerApi apiInstance = new UserRestControllerApi();
        Long id = 789; // Long | 
        ReplaceImageRequest replaceImageRequest = ; // ReplaceImageRequest | 

        try {
            ImageDTO result = apiInstance.uploadProfileImage(id, replaceImageRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling UserRestControllerApi#uploadProfileImage");
            e.printStackTrace();
        }
    }
}



// Create an instance of the API class
UserRestControllerApi *apiInstance = [[UserRestControllerApi alloc] init];
Long *id = 789; //  (default to null)
ReplaceImageRequest *replaceImageRequest = ; //  (optional)

[apiInstance uploadProfileImageWith:id
    replaceImageRequest:replaceImageRequest
              completionHandler: ^(ImageDTO output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenApiDefinition = require('open_api_definition');

// Create an instance of the API class
var api = new OpenApiDefinition.UserRestControllerApi()
var id = 789; // {Long} 
var opts = {
  'replaceImageRequest':  // {ReplaceImageRequest} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.uploadProfileImage(id, opts, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class uploadProfileImageExample
    {
        public void main()
        {

            // Create an instance of the API class
            var apiInstance = new UserRestControllerApi();
            var id = 789;  // Long |  (default to null)
            var replaceImageRequest = new ReplaceImageRequest(); // ReplaceImageRequest |  (optional) 

            try {
                ImageDTO result = apiInstance.uploadProfileImage(id, replaceImageRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling UserRestControllerApi.uploadProfileImage: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\UserRestControllerApi();
$id = 789; // Long | 
$replaceImageRequest = ; // ReplaceImageRequest | 

try {
    $result = $api_instance->uploadProfileImage($id, $replaceImageRequest);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling UserRestControllerApi->uploadProfileImage: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::UserRestControllerApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::UserRestControllerApi->new();
my $id = 789; # Long | 
my $replaceImageRequest = WWW::OPenAPIClient::Object::ReplaceImageRequest->new(); # ReplaceImageRequest | 

eval {
    my $result = $api_instance->uploadProfileImage(id => $id, replaceImageRequest => $replaceImageRequest);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling UserRestControllerApi->uploadProfileImage: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Create an instance of the API class
api_instance = openapi_client.UserRestControllerApi()
id = 789 # Long |  (default to null)
replaceImageRequest =  # ReplaceImageRequest |  (optional)

try:
    api_response = api_instance.upload_profile_image(id, replaceImageRequest=replaceImageRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling UserRestControllerApi->uploadProfileImage: %s\n" % e)

extern crate UserRestControllerApi;

pub fn main() {
    let id = 789; // Long
    let replaceImageRequest = ; // ReplaceImageRequest

    let mut context = UserRestControllerApi::Context::default();
    let result = client.uploadProfileImage(id, replaceImageRequest, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters

Name	Description
id*	Long (int64) Required

Body parameters

Name	Description
replaceImageRequest

Responses

Schema

OpenAPI definition

API and SDK Documentation

AdminCategoryController

getImage2

Usage and SDK Samples

Scopes

Parameters

Responses

AdminProductController

getProductImage

Usage and SDK Samples

Scopes

Parameters

Responses

CartController

obtenerCarrito

Usage and SDK Samples

Scopes

Parameters

Responses

CategoryRestController

createCategory

Usage and SDK Samples

Scopes

Parameters

Responses

deletecategory

Usage and SDK Samples

Scopes

Parameters

Responses

getCategories

Usage and SDK Samples

Scopes

Parameters

Responses

getCategory

Usage and SDK Samples

Scopes

Parameters

Responses

replaceCategory

Usage and SDK Samples

Scopes

Parameters

Responses

DocumentRestController

downloadDni

Usage and SDK Samples

Scopes

Parameters

Responses

uploadUserDni

Usage and SDK Samples

Scopes

Parameters

Responses

ImageController

getImage

Usage and SDK Samples

Scopes

Parameters

Responses

ImageRestController

createCategoryImage

Usage and SDK Samples

Scopes

Parameters

Responses

createProductImage

Usage and SDK Samples

Scopes

Parameters

Responses

createUserImage

Usage and SDK Samples

Scopes

Parameters

Responses

deleteCategoryImage