OpenAPI definition

ImageRestController

getImage


/api/v1/images/{id}

Usage and SDK Samples

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

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

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

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

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

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

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

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


import org.openapitools.client.api.ImageRestControllerApi;

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

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


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

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

var OpenApiDefinition = require('open_api_definition');

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Scopes

Parameters

Path parameters
Name Description
id*
Long (int64)
Required

Responses

getImageFile


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

Usage and SDK Samples

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

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

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

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

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

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

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

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


import org.openapitools.client.api.ImageRestControllerApi;

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

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


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

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

var OpenApiDefinition = require('open_api_definition');

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Scopes

Parameters

Path parameters
Name Description
id*
Long (int64)
Required

Responses

replaceImageFile


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

Usage and SDK Samples

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

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

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

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

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

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

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

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


import org.openapitools.client.api.ImageRestControllerApi;

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

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


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

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

var OpenApiDefinition = require('open_api_definition');

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Scopes

Parameters

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

Responses

LoginRestcontroller

logOut


/api/v1/auth/logout

Usage and SDK Samples

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

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

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

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

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

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

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

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


// Create an instance of the API class
LoginRestcontrollerApi *apiInstance = [[LoginRestcontrollerApi 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.LoginRestcontrollerApi()
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 LoginRestcontrollerApi();

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

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

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

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

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

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

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

pub fn main() {

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

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

Scopes

Parameters

Responses

login


/api/v1/auth/login

Usage and SDK Samples

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

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

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

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

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

        try {
            AuthResponse result = apiInstance.login(loginRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling LoginRestcontrollerApi#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.LoginRestcontrollerApi;

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

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


// Create an instance of the API class
LoginRestcontrollerApi *apiInstance = [[LoginRestcontrollerApi 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.LoginRestcontrollerApi()
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 LoginRestcontrollerApi();
            var loginRequest = new LoginRequest(); // LoginRequest | 

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

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

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::LoginRestcontrollerApi->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 LoginRestcontrollerApi->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.LoginRestcontrollerApi()
loginRequest =  # LoginRequest | 

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

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

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

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

Scopes

Parameters

Body parameters
Name Description
loginRequest *

Responses

refreshToken


/api/v1/auth/refresh

Usage and SDK Samples

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

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

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

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

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

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

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

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


// Create an instance of the API class
LoginRestcontrollerApi *apiInstance = [[LoginRestcontrollerApi 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.LoginRestcontrollerApi()
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 LoginRestcontrollerApi();
            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 LoginRestcontrollerApi.refreshToken: " + e.Message );
            }
        }
    }
}

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

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

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

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

eval {
    my $result = $api_instance->refreshToken(refreshToken => $refreshToken);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling LoginRestcontrollerApi->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.LoginRestcontrollerApi()
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 LoginRestcontrollerApi->refreshToken: %s\n" % e)
extern crate LoginRestcontrollerApi;

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

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

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

Scopes

Parameters

Responses

OrderRestController

cancelOrder


/api/v1/orders/{id}/cancel

Usage and SDK Samples

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

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 {
            OrderDTO result = apiInstance.cancelOrder(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling OrderRestControllerApi#cancelOrder");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

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

try {
    final result = await api_instance.cancelOrder(id);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->cancelOrder: $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 {
            OrderDTO result = apiInstance.cancelOrder(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling OrderRestControllerApi#cancelOrder");
            e.printStackTrace();
        }
    }
}


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

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

var OpenApiDefinition = require('open_api_definition');

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

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

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

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

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

            try {
                OrderDTO result = apiInstance.cancelOrder(id);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling OrderRestControllerApi.cancelOrder: " + 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->cancelOrder($id);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling OrderRestControllerApi->cancelOrder: ', $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->cancelOrder(id => $id);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling OrderRestControllerApi->cancelOrder: $@\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.cancel_order(id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling OrderRestControllerApi->cancelOrder: %s\n" % e)
extern crate OrderRestControllerApi;

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

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

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

Scopes

Parameters

Path parameters
Name Description
id*
Long (int64)
Required

Responses

createOrder


/api/v1/orders/

Usage and SDK Samples

curl -X POST \
 -H "Accept: */*" \
 -H "Content-Type: application/json" \
 "https://localhost:8443/api/v1/orders/" \
 -d '{
  "quantity" : 6,
  "productId" : 0
}'

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();
        array[CreateOrderItemDTO] createOrderItemDTO = ; // array[CreateOrderItemDTO] | 

        try {
            OrderDTO result = apiInstance.createOrder(createOrderItemDTO);
            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 array[CreateOrderItemDTO] createOrderItemDTO = new array[CreateOrderItemDTO](); // array[CreateOrderItemDTO] | 

try {
    final result = await api_instance.createOrder(createOrderItemDTO);
    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();
        array[CreateOrderItemDTO] createOrderItemDTO = ; // array[CreateOrderItemDTO] | 

        try {
            OrderDTO result = apiInstance.createOrder(createOrderItemDTO);
            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];
array[CreateOrderItemDTO] *createOrderItemDTO = ; // 

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

var OpenApiDefinition = require('open_api_definition');

// Create an instance of the API class
var api = new OpenApiDefinition.OrderRestControllerApi()
var createOrderItemDTO = ; // {array[CreateOrderItemDTO]} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.createOrder(createOrderItemDTO, 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 createOrderItemDTO = new array[CreateOrderItemDTO](); // array[CreateOrderItemDTO] | 

            try {
                OrderDTO result = apiInstance.createOrder(createOrderItemDTO);
                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();
$createOrderItemDTO = ; // array[CreateOrderItemDTO] | 

try {
    $result = $api_instance->createOrder($createOrderItemDTO);
    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 $createOrderItemDTO = [WWW::OPenAPIClient::Object::array[CreateOrderItemDTO]->new()]; # array[CreateOrderItemDTO] | 

eval {
    my $result = $api_instance->createOrder(createOrderItemDTO => $createOrderItemDTO);
    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()
createOrderItemDTO =  # array[CreateOrderItemDTO] | 

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

pub fn main() {
    let createOrderItemDTO = ; // array[CreateOrderItemDTO]

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

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

Scopes

Parameters

Body parameters
Name Description
createOrderItemDTO *

Responses

deleteOrder


/api/v1/orders/{id}

Usage and SDK Samples

curl -X DELETE \
 -H "Accept: */*" \
 "https://localhost:8443/api/v1/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 {
            OrderDTO 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 {
            OrderDTO 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: ^(OrderDTO output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenApiDefinition = require('open_api_definition');

// Create an instance of the API class
var api = new OpenApiDefinition.OrderRestControllerApi()
var 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 {
                OrderDTO 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

getAllOrders


/api/v1/orders/

Usage and SDK Samples

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

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

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

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

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

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();


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


import org.openapitools.client.api.OrderRestControllerApi;

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

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


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

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

var OpenApiDefinition = require('open_api_definition');

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

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

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

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

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

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

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

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

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

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

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

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

pub fn main() {

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

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

Scopes

Parameters

Responses

getOrder


/api/v1/orders/{id}

Usage and SDK Samples

curl -X GET \
 -H "Accept: */*" \
 "https://localhost:8443/api/v1/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 {
            OrderDTO 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 {
            OrderDTO 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: ^(OrderDTO output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenApiDefinition = require('open_api_definition');

// Create an instance of the API class
var api = new OpenApiDefinition.OrderRestControllerApi()
var 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 {
                OrderDTO 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

getUserOrders


/api/v1/orders/my

Usage and SDK Samples

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

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

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

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

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

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();


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


import org.openapitools.client.api.OrderRestControllerApi;

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

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


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

[apiInstance getUserOrdersWithCompletionHandler: 
              ^(array[OrderDTO] output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenApiDefinition = require('open_api_definition');

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

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

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

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

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

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

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

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

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

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

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

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

pub fn main() {

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

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

Scopes

Parameters

Responses

updateStatus


/api/v1/orders/{id}/status

Usage and SDK Samples

curl -X PUT \
 -H "Accept: */*" \
 "https://localhost:8443/api/v1/orders/{id}/status?status=status_example"

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 | 
        String status = status_example; // String | 

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

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

try {
    final result = await api_instance.updateStatus(id, status);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->updateStatus: $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 | 
        String status = status_example; // String | 

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


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

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

var OpenApiDefinition = require('open_api_definition');

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

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

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

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

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

            try {
                OrderDTO result = apiInstance.updateStatus(id, status);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling OrderRestControllerApi.updateStatus: " + 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 | 
$status = status_example; // String | 

try {
    $result = $api_instance->updateStatus($id, $status);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling OrderRestControllerApi->updateStatus: ', $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 | 
my $status = status_example; # String | 

eval {
    my $result = $api_instance->updateStatus(id => $id, status => $status);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling OrderRestControllerApi->updateStatus: $@\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)
status = status_example # String |  (default to null)

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

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

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

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

Scopes

Parameters

Path parameters
Name Description
id*
Long (int64)
Required
Query parameters
Name Description
status*
String
Required

Responses

PlantRestController

addImageToPlant


/api/v1/plants/{id}/image

Usage and SDK Samples

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

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

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

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

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

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

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

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


import org.openapitools.client.api.PlantRestControllerApi;

public class PlantRestControllerApiExample {
    public static void main(String[] args) {
        PlantRestControllerApi apiInstance = new PlantRestControllerApi();
        Long id = 789; // Long | 
        AddImageToProductRequest addImageToProductRequest = ; // AddImageToProductRequest | 

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


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

[apiInstance addImageToPlantWith:id
    addImageToProductRequest:addImageToProductRequest
              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.PlantRestControllerApi()
var id = 789; // {Long} 
var opts = {
  'addImageToProductRequest':  // {AddImageToProductRequest} 
};

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

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

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

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

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

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

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

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

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

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

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

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

    let mut context = PlantRestControllerApi::Context::default();
    let result = client.addImageToPlant(id, addImageToProductRequest, &context).wait();

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

Scopes

Parameters

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

Responses

deletePlant


/api/v1/plants/{id}

Usage and SDK Samples

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

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

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

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

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

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

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

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


import org.openapitools.client.api.PlantRestControllerApi;

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

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


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

[apiInstance deletePlantWith:id
              completionHandler: ^(PlantBasicDTO 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.PlantRestControllerApi()
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.deletePlant(id, callback);

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

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

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

            try {
                PlantBasicDTO result = apiInstance.deletePlant(id);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling PlantRestControllerApi.deletePlant: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

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

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

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

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

Scopes

Parameters

Path parameters
Name Description
id*
Long (int64)
Required

Responses

deletePlantImage


/api/v1/plants/{plantId}/image/{imageId}

Usage and SDK Samples

curl -X DELETE \
 -H "Accept: */*" \
 "https://localhost:8443/api/v1/plants/{plantId}/image/{imageId}"

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

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

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

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

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

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

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


import org.openapitools.client.api.PlantRestControllerApi;

public class PlantRestControllerApiExample {
    public static void main(String[] args) {
        PlantRestControllerApi apiInstance = new PlantRestControllerApi();
        Long plantId = 789; // Long | 
        Long imageId = 789; // Long | 

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


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

[apiInstance deletePlantImageWith:plantId
    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.PlantRestControllerApi()
var plantId = 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.deletePlantImage(plantId, imageId, callback);

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

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

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

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

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

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

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

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

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

try:
    api_response = api_instance.delete_plant_image(plantId, imageId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling PlantRestControllerApi->deletePlantImage: %s\n" % e)
extern crate PlantRestControllerApi;

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

    let mut context = PlantRestControllerApi::Context::default();
    let result = client.deletePlantImage(plantId, imageId, &context).wait();

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

Scopes

Parameters

Path parameters
Name Description
plantId*
Long (int64)
Required
imageId*
Long (int64)
Required

Responses

editPlant


/api/v1/plants/{id}

Usage and SDK Samples

curl -X PUT \
 -H "Accept: */*" \
 -H "Content-Type: application/json" \
 "https://localhost:8443/api/v1/plants/{id}" \
 -d '{
  "cares" : "cares",
  "images" : [ {
    "id" : 1
  }, {
    "id" : 1
  } ],
  "species" : "species",
  "name" : "name",
  "description" : "description"
}'

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

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

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

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

        try {
            PlantBasicDTO result = apiInstance.editPlant(id, plantBasicDTO);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling PlantRestControllerApi#editPlant");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

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

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


import org.openapitools.client.api.PlantRestControllerApi;

public class PlantRestControllerApiExample {
    public static void main(String[] args) {
        PlantRestControllerApi apiInstance = new PlantRestControllerApi();
        Long id = 789; // Long | 
        PlantBasicDTO plantBasicDTO = ; // PlantBasicDTO | 

        try {
            PlantBasicDTO result = apiInstance.editPlant(id, plantBasicDTO);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling PlantRestControllerApi#editPlant");
            e.printStackTrace();
        }
    }
}


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

[apiInstance editPlantWith:id
    plantBasicDTO:plantBasicDTO
              completionHandler: ^(PlantBasicDTO 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.PlantRestControllerApi()
var id = 789; // {Long} 
var plantBasicDTO = ; // {PlantBasicDTO} 

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

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

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

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

            try {
                PlantBasicDTO result = apiInstance.editPlant(id, plantBasicDTO);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling PlantRestControllerApi.editPlant: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

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

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

    let mut context = PlantRestControllerApi::Context::default();
    let result = client.editPlant(id, plantBasicDTO, &context).wait();

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

Scopes

Parameters

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

Responses

getItemRepository


/api/v1/plants/

Usage and SDK Samples

curl -X GET \
 -H "Accept: */*" \
 "https://localhost:8443/api/v1/plants/?search=search_example&page=&whatToShow=whatToShow_example&order=order_example"

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

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

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

        // Create an instance of the API class
        PlantRestControllerApi apiInstance = new PlantRestControllerApi();
        Pageable page = ; // Pageable | 
        String search = search_example; // String | 
        String whatToShow = whatToShow_example; // String | 
        String order = order_example; // String | 

        try {
            PagedModelPlantBasicDTO result = apiInstance.getItemRepository(page, search, whatToShow, order);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling PlantRestControllerApi#getItemRepository");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final Pageable page = new Pageable(); // Pageable | 
final String search = new String(); // String | 
final String whatToShow = new String(); // String | 
final String order = new String(); // String | 

try {
    final result = await api_instance.getItemRepository(page, search, whatToShow, order);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->getItemRepository: $e\n');
}


import org.openapitools.client.api.PlantRestControllerApi;

public class PlantRestControllerApiExample {
    public static void main(String[] args) {
        PlantRestControllerApi apiInstance = new PlantRestControllerApi();
        Pageable page = ; // Pageable | 
        String search = search_example; // String | 
        String whatToShow = whatToShow_example; // String | 
        String order = order_example; // String | 

        try {
            PagedModelPlantBasicDTO result = apiInstance.getItemRepository(page, search, whatToShow, order);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling PlantRestControllerApi#getItemRepository");
            e.printStackTrace();
        }
    }
}


// Create an instance of the API class
PlantRestControllerApi *apiInstance = [[PlantRestControllerApi alloc] init];
Pageable *page = ; //  (default to null)
String *search = search_example; //  (optional) (default to null)
String *whatToShow = whatToShow_example; //  (optional) (default to null)
String *order = order_example; //  (optional) (default to null)

[apiInstance getItemRepositoryWith:page
    search:search
    whatToShow:whatToShow
    order:order
              completionHandler: ^(PagedModelPlantBasicDTO 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.PlantRestControllerApi()
var page = ; // {Pageable} 
var opts = {
  'search': search_example, // {String} 
  'whatToShow': whatToShow_example, // {String} 
  'order': order_example // {String} 
};

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

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

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

            // Create an instance of the API class
            var apiInstance = new PlantRestControllerApi();
            var page = new Pageable(); // Pageable |  (default to null)
            var search = search_example;  // String |  (optional)  (default to null)
            var whatToShow = whatToShow_example;  // String |  (optional)  (default to null)
            var order = order_example;  // String |  (optional)  (default to null)

            try {
                PagedModelPlantBasicDTO result = apiInstance.getItemRepository(page, search, whatToShow, order);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling PlantRestControllerApi.getItemRepository: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\PlantRestControllerApi();
$page = ; // Pageable | 
$search = search_example; // String | 
$whatToShow = whatToShow_example; // String | 
$order = order_example; // String | 

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::PlantRestControllerApi->new();
my $page = ; # Pageable | 
my $search = search_example; # String | 
my $whatToShow = whatToShow_example; # String | 
my $order = order_example; # String | 

eval {
    my $result = $api_instance->getItemRepository(page => $page, search => $search, whatToShow => $whatToShow, order => $order);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling PlantRestControllerApi->getItemRepository: $@\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.PlantRestControllerApi()
page =  # Pageable |  (default to null)
search = search_example # String |  (optional) (default to null)
whatToShow = whatToShow_example # String |  (optional) (default to null)
order = order_example # String |  (optional) (default to null)

try:
    api_response = api_instance.get_item_repository(page, search=search, whatToShow=whatToShow, order=order)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling PlantRestControllerApi->getItemRepository: %s\n" % e)
extern crate PlantRestControllerApi;

pub fn main() {
    let page = ; // Pageable
    let search = search_example; // String
    let whatToShow = whatToShow_example; // String
    let order = order_example; // String

    let mut context = PlantRestControllerApi::Context::default();
    let result = client.getItemRepository(page, search, whatToShow, order, &context).wait();

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

Scopes

Parameters

Query parameters
Name Description
search
page*
Pageable
Required
whatToShow
String
order
String

Responses

getPlant


/api/v1/plants/{id}

Usage and SDK Samples

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

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

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

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

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

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

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

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


import org.openapitools.client.api.PlantRestControllerApi;

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

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


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

[apiInstance getPlantWith:id
              completionHandler: ^(PlantBasicDTO 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.PlantRestControllerApi()
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.getPlant(id, callback);

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

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

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

            try {
                PlantBasicDTO result = apiInstance.getPlant(id);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling PlantRestControllerApi.getPlant: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

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

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

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

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

Scopes

Parameters

Path parameters
Name Description
id*
Long (int64)
Required

Responses

newPlant


/api/v1/plants/

Usage and SDK Samples

curl -X POST \
 -H "Accept: */*" \
 -H "Content-Type: application/json" \
 "https://localhost:8443/api/v1/plants/" \
 -d '{
  "cares" : "cares",
  "images" : [ {
    "id" : 1
  }, {
    "id" : 1
  } ],
  "species" : "species",
  "name" : "name",
  "description" : "description"
}'

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

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

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

        // Create an instance of the API class
        PlantRestControllerApi apiInstance = new PlantRestControllerApi();
        PlantBasicDTO plantBasicDTO = ; // PlantBasicDTO | 

        try {
            PlantBasicDTO result = apiInstance.newPlant(plantBasicDTO);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling PlantRestControllerApi#newPlant");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final PlantBasicDTO plantBasicDTO = new PlantBasicDTO(); // PlantBasicDTO | 

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


import org.openapitools.client.api.PlantRestControllerApi;

public class PlantRestControllerApiExample {
    public static void main(String[] args) {
        PlantRestControllerApi apiInstance = new PlantRestControllerApi();
        PlantBasicDTO plantBasicDTO = ; // PlantBasicDTO | 

        try {
            PlantBasicDTO result = apiInstance.newPlant(plantBasicDTO);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling PlantRestControllerApi#newPlant");
            e.printStackTrace();
        }
    }
}


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

[apiInstance newPlantWith:plantBasicDTO
              completionHandler: ^(PlantBasicDTO 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.PlantRestControllerApi()
var plantBasicDTO = ; // {PlantBasicDTO} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new PlantRestControllerApi();
            var plantBasicDTO = new PlantBasicDTO(); // PlantBasicDTO | 

            try {
                PlantBasicDTO result = apiInstance.newPlant(plantBasicDTO);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling PlantRestControllerApi.newPlant: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\PlantRestControllerApi();
$plantBasicDTO = ; // PlantBasicDTO | 

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::PlantRestControllerApi->new();
my $plantBasicDTO = WWW::OPenAPIClient::Object::PlantBasicDTO->new(); # PlantBasicDTO | 

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

try:
    api_response = api_instance.new_plant(plantBasicDTO)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling PlantRestControllerApi->newPlant: %s\n" % e)
extern crate PlantRestControllerApi;

pub fn main() {
    let plantBasicDTO = ; // PlantBasicDTO

    let mut context = PlantRestControllerApi::Context::default();
    let result = client.newPlant(plantBasicDTO, &context).wait();

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

Scopes

Parameters

Body parameters
Name Description
plantBasicDTO *

Responses

ProductRestController

addImageToProduct


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

Usage and SDK Samples

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

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

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

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

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

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

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

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


import org.openapitools.client.api.ProductRestControllerApi;

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

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


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

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

var OpenApiDefinition = require('open_api_definition');

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Scopes

Parameters

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

Responses

createProduct


/api/v1/products/

Usage and SDK Samples

curl -X POST \
 -H "Accept: */*" \
 -H "Content-Type: application/json" \
 "https://localhost:8443/api/v1/products/" \
 -d '{
  "images" : [ {
    "id" : 1
  }, {
    "id" : 1
  } ],
  "price" : 6.027456183070403,
  "name" : "name",
  "description" : "description",
  "active" : true,
  "id" : 0
}'

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();
        ProductDTO productDTO = ; // ProductDTO | 

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

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

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


import org.openapitools.client.api.ProductRestControllerApi;

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

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


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

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

var OpenApiDefinition = require('open_api_definition');

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

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

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

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

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

            try {
                ProductDTO result = apiInstance.createProduct(productDTO);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ProductRestControllerApi.createProduct: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

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

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

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

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

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

Scopes

Parameters

Body parameters
Name Description
productDTO *

Responses

deleteProduct


/api/v1/products/{id}

Usage and SDK Samples

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

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

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

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

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

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

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

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


import org.openapitools.client.api.ProductRestControllerApi;

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

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


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

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

var OpenApiDefinition = require('open_api_definition');

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Scopes

Parameters

Path parameters
Name Description
id*
Long (int64)
Required

Responses

deleteProductImage


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

Usage and SDK Samples

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

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

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

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

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

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

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

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


import org.openapitools.client.api.ProductRestControllerApi;

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

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


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

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

var OpenApiDefinition = require('open_api_definition');

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Scopes

Parameters

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

Responses

editProduct


/api/v1/products/{id}

Usage and SDK Samples

curl -X PUT \
 -H "Accept: */*" \
 -H "Content-Type: application/json" \
 "https://localhost:8443/api/v1/products/{id}" \
 -d '{
  "images" : [ {
    "id" : 1
  }, {
    "id" : 1
  } ],
  "price" : 6.027456183070403,
  "name" : "name",
  "description" : "description",
  "active" : true,
  "id" : 0
}'

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

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

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

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

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

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

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


import org.openapitools.client.api.ProductRestControllerApi;

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

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


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

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

var OpenApiDefinition = require('open_api_definition');

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

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

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

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

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

            try {
                ProductDTO result = apiInstance.editProduct(id, productDTO);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ProductRestControllerApi.editProduct: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

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

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

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

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

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

Scopes

Parameters

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

Responses

getAllProducts


/api/v1/products/

Usage and SDK Samples

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

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 page = ; // Pageable | 

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

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

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


import org.openapitools.client.api.ProductRestControllerApi;

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

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


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

[apiInstance getAllProductsWith:page
              completionHandler: ^(PagedModelProductDTO 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 page = ; // {Pageable} 

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

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

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

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

            try {
                PagedModelProductDTO result = apiInstance.getAllProducts(page);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ProductRestControllerApi.getAllProducts: " + e.Message );
            }
        }
    }
}

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

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

try {
    $result = $api_instance->getAllProducts($page);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ProductRestControllerApi->getAllProducts: ', $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 $page = ; # Pageable | 

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

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

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

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

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

Scopes

Parameters

Query parameters
Name Description
page*
Pageable
Required

Responses

getProduct


/api/v1/products/{id}

Usage and SDK Samples

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

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

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

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

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

        try {
            ProductDTO result = apiInstance.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 Long id = new Long(); // Long | 

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();
        Long id = 789; // Long | 

        try {
            ProductDTO 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];
Long *id = 789; //  (default to null)

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

var OpenApiDefinition = require('open_api_definition');

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

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.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 = 789;  // Long |  (default to null)

            try {
                ProductDTO 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 = 789; // Long | 

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 = 789; # Long | 

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 = 789 # Long |  (default to null)

try:
    api_response = api_instance.get_product(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 = 789; // Long

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

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

Scopes

Parameters

Path parameters
Name Description
id*
Long (int64)
Required

Responses

ReviewRestController

createReview


/api/v1/reviews/

Usage and SDK Samples

curl -X POST \
 -H "Accept: */*" \
 -H "Content-Type: application/json" \
 "https://localhost:8443/api/v1/reviews/" \
 -d '{
  "product" : "product",
  "plantSpecies" : "plantSpecies",
  "description" : "description",
  "id" : 0,
  "video" : {
    "fileName" : "fileName",
    "id" : 6,
    "contentType" : "contentType",
    "url" : "url"
  },
  "title" : "title",
  "type" : "PLANT",
  "username" : "username"
}'

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();
        ReviewDTO reviewDTO = ; // ReviewDTO | 

        try {
            ReviewDTO result = apiInstance.createReview(reviewDTO);
            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 ReviewDTO reviewDTO = new ReviewDTO(); // ReviewDTO | 

try {
    final result = await api_instance.createReview(reviewDTO);
    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();
        ReviewDTO reviewDTO = ; // ReviewDTO | 

        try {
            ReviewDTO result = apiInstance.createReview(reviewDTO);
            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];
ReviewDTO *reviewDTO = ; // 

[apiInstance createReviewWith:reviewDTO
              completionHandler: ^(ReviewDTO output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenApiDefinition = require('open_api_definition');

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

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

            try {
                ReviewDTO result = apiInstance.createReview(reviewDTO);
                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();
$reviewDTO = ; // ReviewDTO | 

try {
    $result = $api_instance->createReview($reviewDTO);
    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 $reviewDTO = WWW::OPenAPIClient::Object::ReviewDTO->new(); # ReviewDTO | 

eval {
    my $result = $api_instance->createReview(reviewDTO => $reviewDTO);
    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()
reviewDTO =  # ReviewDTO | 

try:
    api_response = api_instance.create_review(reviewDTO)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ReviewRestControllerApi->createReview: %s\n" % e)
extern crate ReviewRestControllerApi;

pub fn main() {
    let reviewDTO = ; // ReviewDTO

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

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

Scopes

Parameters

Body parameters
Name Description
reviewDTO *

Responses

deleteReview


/api/v1/reviews/{id}

Usage and SDK Samples

curl -X DELETE \
 "https://localhost:8443/api/v1/reviews/{id}"

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.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 {
            apiInstance.deleteReview(id);
        } catch (ApiException e) {
            System.err.println("Exception when calling ReviewRestControllerApi#deleteReview");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

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

try {
    final result = await api_instance.deleteReview(id);
    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 id = 789; // Long | 

        try {
            apiInstance.deleteReview(id);
        } 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 *id = 789; //  (default to null)

[apiInstance deleteReviewWith:id
              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 id = 789; // {Long} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.deleteReview(id, 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 id = 789;  // Long |  (default to null)

            try {
                apiInstance.deleteReview(id);
            } 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();
$id = 789; // Long | 

try {
    $api_instance->deleteReview($id);
} 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 $id = 789; # Long | 

eval {
    $api_instance->deleteReview(id => $id);
};
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()
id = 789 # Long |  (default to null)

try:
    api_instance.delete_review(id)
except ApiException as e:
    print("Exception when calling ReviewRestControllerApi->deleteReview: %s\n" % e)
extern crate ReviewRestControllerApi;

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

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

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

Scopes

Parameters

Path parameters
Name Description
id*
Long (int64)
Required

Responses

getAllReviews


/api/v1/reviews

Usage and SDK Samples

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

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

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

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

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

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();


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


import org.openapitools.client.api.ReviewRestControllerApi;

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

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


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

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

var OpenApiDefinition = require('open_api_definition');

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

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

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

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

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

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

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

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

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

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

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

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

pub fn main() {

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

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

Scopes

Parameters

Responses

getReview


/api/v1/reviews/{id}

Usage and SDK Samples

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

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

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

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

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

        try {
            ReviewDTO result = apiInstance.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 {
            ReviewDTO 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: ^(ReviewDTO output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenApiDefinition = require('open_api_definition');

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

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

updateReview


/api/v1/reviews/{id}

Usage and SDK Samples

curl -X PUT \
 -H "Accept: */*" \
 -H "Content-Type: application/json" \
 "https://localhost:8443/api/v1/reviews/{id}" \
 -d '{
  "product" : "product",
  "plantSpecies" : "plantSpecies",
  "description" : "description",
  "id" : 0,
  "video" : {
    "fileName" : "fileName",
    "id" : 6,
    "contentType" : "contentType",
    "url" : "url"
  },
  "title" : "title",
  "type" : "PLANT",
  "username" : "username"
}'

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 | 
        ReviewDTO reviewDTO = ; // ReviewDTO | 

        try {
            ReviewDTO result = apiInstance.updateReview(id, reviewDTO);
            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 id = new Long(); // Long | 
final ReviewDTO reviewDTO = new ReviewDTO(); // ReviewDTO | 

try {
    final result = await api_instance.updateReview(id, reviewDTO);
    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 id = 789; // Long | 
        ReviewDTO reviewDTO = ; // ReviewDTO | 

        try {
            ReviewDTO result = apiInstance.updateReview(id, reviewDTO);
            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 *id = 789; //  (default to null)
ReviewDTO *reviewDTO = ; // 

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

var OpenApiDefinition = require('open_api_definition');

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

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.updateReview(id, reviewDTO, 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 id = 789;  // Long |  (default to null)
            var reviewDTO = new ReviewDTO(); // ReviewDTO | 

            try {
                ReviewDTO result = apiInstance.updateReview(id, reviewDTO);
                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();
$id = 789; // Long | 
$reviewDTO = ; // ReviewDTO | 

try {
    $result = $api_instance->updateReview($id, $reviewDTO);
    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 $id = 789; # Long | 
my $reviewDTO = WWW::OPenAPIClient::Object::ReviewDTO->new(); # ReviewDTO | 

eval {
    my $result = $api_instance->updateReview(id => $id, reviewDTO => $reviewDTO);
    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()
id = 789 # Long |  (default to null)
reviewDTO =  # ReviewDTO | 

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

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

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

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

Scopes

Parameters

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

Responses

UserRestController

deleteUser


/api/v1/users/{id}

Usage and SDK Samples

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

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

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

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

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

        try {
            Object 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 {
            Object 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: ^(Object output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenApiDefinition = require('open_api_definition');

// Create an instance of the API class
var api = new OpenApiDefinition.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 {
                Object 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

editUser


/api/v1/users/{id}

Usage and SDK Samples

curl -X PUT \
 -H "Accept: */*" \
 -H "Content-Type: application/json" \
 "https://localhost:8443/api/v1/users/{id}" \
 -d '{
  "password" : "password",
  "description" : "description",
  "email" : "email",
  "username" : "username"
}'

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 | 
        UserEditDTO userEditDTO = ; // UserEditDTO | 

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

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

try {
    final result = await api_instance.editUser(id, userEditDTO);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->editUser: $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 | 
        UserEditDTO userEditDTO = ; // UserEditDTO | 

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


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

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

var OpenApiDefinition = require('open_api_definition');

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

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

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

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

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

            try {
                Object result = apiInstance.editUser(id, userEditDTO);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling UserRestControllerApi.editUser: " + 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 | 
$userEditDTO = ; // UserEditDTO | 

try {
    $result = $api_instance->editUser($id, $userEditDTO);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling UserRestControllerApi->editUser: ', $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 $userEditDTO = WWW::OPenAPIClient::Object::UserEditDTO->new(); # UserEditDTO | 

eval {
    my $result = $api_instance->editUser(id => $id, userEditDTO => $userEditDTO);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling UserRestControllerApi->editUser: $@\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)
userEditDTO =  # UserEditDTO | 

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

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

    let mut context = UserRestControllerApi::Context::default();
    let result = client.editUser(id, userEditDTO, &context).wait();

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

Scopes

Parameters

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

Responses

getMe


/api/v1/users/me

Usage and SDK Samples

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

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

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

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

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

        try {
            UserBasicDTO result = apiInstance.getMe();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling UserRestControllerApi#getMe");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();


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


import org.openapitools.client.api.UserRestControllerApi;

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

        try {
            UserBasicDTO result = apiInstance.getMe();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling UserRestControllerApi#getMe");
            e.printStackTrace();
        }
    }
}


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

[apiInstance getMeWithCompletionHandler: 
              ^(UserBasicDTO output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenApiDefinition = require('open_api_definition');

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

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

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

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

            try {
                UserBasicDTO result = apiInstance.getMe();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling UserRestControllerApi.getMe: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

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

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

pub fn main() {

    let mut context = UserRestControllerApi::Context::default();
    let result = client.getMe(&context).wait();

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

Scopes

Parameters

Responses

getUser


/api/v1/users/{id}

Usage and SDK Samples

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

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

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

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

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

        try {
            Object 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 {
            Object 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: ^(Object output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenApiDefinition = require('open_api_definition');

// Create an instance of the API class
var api = new OpenApiDefinition.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 {
                Object 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

getUsers


/api/v1/users/

Usage and SDK Samples

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

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

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

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

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

        try {
            Object result = apiInstance.getUsers();
            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();


try {
    final result = await api_instance.getUsers();
    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();

        try {
            Object result = apiInstance.getUsers();
            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];

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

var OpenApiDefinition = require('open_api_definition');

// Create an instance of the API class
var api = new OpenApiDefinition.UserRestControllerApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getUsers(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();

            try {
                Object result = apiInstance.getUsers();
                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();

try {
    $result = $api_instance->getUsers();
    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();

eval {
    my $result = $api_instance->getUsers();
    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()

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

pub fn main() {

    let mut context = UserRestControllerApi::Context::default();
    let result = client.getUsers(&context).wait();

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

Scopes

Parameters

Responses

newUser


/api/v1/users/

Usage and SDK Samples

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

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();
        UserValidationDTO userValidationDTO = ; // UserValidationDTO | 

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final UserValidationDTO userValidationDTO = new UserValidationDTO(); // UserValidationDTO | 

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


import org.openapitools.client.api.UserRestControllerApi;

public class UserRestControllerApiExample {
    public static void main(String[] args) {
        UserRestControllerApi apiInstance = new UserRestControllerApi();
        UserValidationDTO userValidationDTO = ; // UserValidationDTO | 

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


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

[apiInstance newUserWith:userValidationDTO
              completionHandler: ^(Object output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenApiDefinition = require('open_api_definition');

// Create an instance of the API class
var api = new OpenApiDefinition.UserRestControllerApi()
var userValidationDTO = ; // {UserValidationDTO} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new UserRestControllerApi();
            var userValidationDTO = new UserValidationDTO(); // UserValidationDTO | 

            try {
                Object result = apiInstance.newUser(userValidationDTO);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling UserRestControllerApi.newUser: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\UserRestControllerApi();
$userValidationDTO = ; // UserValidationDTO | 

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

eval {
    my $result = $api_instance->newUser(userValidationDTO => $userValidationDTO);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling UserRestControllerApi->newUser: $@\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()
userValidationDTO =  # UserValidationDTO | 

try:
    api_response = api_instance.new_user(userValidationDTO)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling UserRestControllerApi->newUser: %s\n" % e)
extern crate UserRestControllerApi;

pub fn main() {
    let userValidationDTO = ; // UserValidationDTO

    let mut context = UserRestControllerApi::Context::default();
    let result = client.newUser(userValidationDTO, &context).wait();

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

Scopes

Parameters

Body parameters
Name Description
userValidationDTO *

Responses

uploadProfilePhoto


/api/v1/users/{id}/profile-photo

Usage and SDK Samples

curl -X PUT \
 -H "Accept: */*" \
 -H "Content-Type: application/json" \
 "https://localhost:8443/api/v1/users/{id}/profile-photo" \
 -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 | 
        UploadProfilePhotoRequest uploadProfilePhotoRequest = ; // UploadProfilePhotoRequest | 

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

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

try {
    final result = await api_instance.uploadProfilePhoto(id, uploadProfilePhotoRequest);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->uploadProfilePhoto: $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 | 
        UploadProfilePhotoRequest uploadProfilePhotoRequest = ; // UploadProfilePhotoRequest | 

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


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

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

var OpenApiDefinition = require('open_api_definition');

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

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

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

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

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

            try {
                Object result = apiInstance.uploadProfilePhoto(id, uploadProfilePhotoRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling UserRestControllerApi.uploadProfilePhoto: " + 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 | 
$uploadProfilePhotoRequest = ; // UploadProfilePhotoRequest | 

try {
    $result = $api_instance->uploadProfilePhoto($id, $uploadProfilePhotoRequest);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling UserRestControllerApi->uploadProfilePhoto: ', $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 $uploadProfilePhotoRequest = WWW::OPenAPIClient::Object::UploadProfilePhotoRequest->new(); # UploadProfilePhotoRequest | 

eval {
    my $result = $api_instance->uploadProfilePhoto(id => $id, uploadProfilePhotoRequest => $uploadProfilePhotoRequest);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling UserRestControllerApi->uploadProfilePhoto: $@\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)
uploadProfilePhotoRequest =  # UploadProfilePhotoRequest |  (optional)

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

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

    let mut context = UserRestControllerApi::Context::default();
    let result = client.uploadProfilePhoto(id, uploadProfilePhotoRequest, &context).wait();

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

Scopes

Parameters

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

Responses

VideoRestController

deleteVideo


/api/v1/reviews/{reviewId}/video

Usage and SDK Samples

curl -X DELETE \
 "https://localhost:8443/api/v1/reviews/{reviewId}/video"

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

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

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

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

        try {
            apiInstance.deleteVideo(reviewId);
        } catch (ApiException e) {
            System.err.println("Exception when calling VideoRestControllerApi#deleteVideo");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

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

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


import org.openapitools.client.api.VideoRestControllerApi;

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

        try {
            apiInstance.deleteVideo(reviewId);
        } catch (ApiException e) {
            System.err.println("Exception when calling VideoRestControllerApi#deleteVideo");
            e.printStackTrace();
        }
    }
}


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

[apiInstance deleteVideoWith: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.VideoRestControllerApi()
var reviewId = 789; // {Long} 

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

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

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

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

            try {
                apiInstance.deleteVideo(reviewId);
            } catch (Exception e) {
                Debug.Print("Exception when calling VideoRestControllerApi.deleteVideo: " + e.Message );
            }
        }
    }
}

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

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

try {
    $api_instance->deleteVideo($reviewId);
} catch (Exception $e) {
    echo 'Exception when calling VideoRestControllerApi->deleteVideo: ', $e->getMessage(), PHP_EOL;
}
?>
use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::VideoRestControllerApi;

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

eval {
    $api_instance->deleteVideo(reviewId => $reviewId);
};
if ($@) {
    warn "Exception when calling VideoRestControllerApi->deleteVideo: $@\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.VideoRestControllerApi()
reviewId = 789 # Long |  (default to null)

try:
    api_instance.delete_video(reviewId)
except ApiException as e:
    print("Exception when calling VideoRestControllerApi->deleteVideo: %s\n" % e)
extern crate VideoRestControllerApi;

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

    let mut context = VideoRestControllerApi::Context::default();
    let result = client.deleteVideo(reviewId, &context).wait();

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

Scopes

Parameters

Path parameters
Name Description
reviewId*
Long (int64)
Required

Responses

getVideo


/api/v1/reviews/{reviewId}/video

Usage and SDK Samples

curl -X GET \
 -H "Accept: */*" \
 "https://localhost:8443/api/v1/reviews/{reviewId}/video"

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

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

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

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

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

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

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


import org.openapitools.client.api.VideoRestControllerApi;

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

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


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

[apiInstance getVideoWith:reviewId
              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.VideoRestControllerApi()
var reviewId = 789; // {Long} 

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

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

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

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

            try {
                File result = apiInstance.getVideo(reviewId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling VideoRestControllerApi.getVideo: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

try:
    api_response = api_instance.get_video(reviewId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling VideoRestControllerApi->getVideo: %s\n" % e)
extern crate VideoRestControllerApi;

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

    let mut context = VideoRestControllerApi::Context::default();
    let result = client.getVideo(reviewId, &context).wait();

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

Scopes

Parameters

Path parameters
Name Description
reviewId*
Long (int64)
Required

Responses

getVideoInfo


/api/v1/reviews/{reviewId}/video/info

Usage and SDK Samples

curl -X GET \
 -H "Accept: */*" \
 "https://localhost:8443/api/v1/reviews/{reviewId}/video/info"

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

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

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

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

        try {
            VideoDTO result = apiInstance.getVideoInfo(reviewId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling VideoRestControllerApi#getVideoInfo");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

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

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


import org.openapitools.client.api.VideoRestControllerApi;

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

        try {
            VideoDTO result = apiInstance.getVideoInfo(reviewId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling VideoRestControllerApi#getVideoInfo");
            e.printStackTrace();
        }
    }
}


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

[apiInstance getVideoInfoWith:reviewId
              completionHandler: ^(VideoDTO 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.VideoRestControllerApi()
var reviewId = 789; // {Long} 

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

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

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

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

            try {
                VideoDTO result = apiInstance.getVideoInfo(reviewId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling VideoRestControllerApi.getVideoInfo: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

try:
    api_response = api_instance.get_video_info(reviewId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling VideoRestControllerApi->getVideoInfo: %s\n" % e)
extern crate VideoRestControllerApi;

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

    let mut context = VideoRestControllerApi::Context::default();
    let result = client.getVideoInfo(reviewId, &context).wait();

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

Scopes

Parameters

Path parameters
Name Description
reviewId*
Long (int64)
Required

Responses

uploadVideo


/api/v1/reviews/{reviewId}/video

Usage and SDK Samples

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

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

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

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

        // Create an instance of the API class
        VideoRestControllerApi apiInstance = new VideoRestControllerApi();
        Long reviewId = 789; // Long | 
        UploadProfilePhotoRequest uploadProfilePhotoRequest = ; // UploadProfilePhotoRequest | 

        try {
            'String' result = apiInstance.uploadVideo(reviewId, uploadProfilePhotoRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling VideoRestControllerApi#uploadVideo");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final Long reviewId = new Long(); // Long | 
final UploadProfilePhotoRequest uploadProfilePhotoRequest = new UploadProfilePhotoRequest(); // UploadProfilePhotoRequest | 

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


import org.openapitools.client.api.VideoRestControllerApi;

public class VideoRestControllerApiExample {
    public static void main(String[] args) {
        VideoRestControllerApi apiInstance = new VideoRestControllerApi();
        Long reviewId = 789; // Long | 
        UploadProfilePhotoRequest uploadProfilePhotoRequest = ; // UploadProfilePhotoRequest | 

        try {
            'String' result = apiInstance.uploadVideo(reviewId, uploadProfilePhotoRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling VideoRestControllerApi#uploadVideo");
            e.printStackTrace();
        }
    }
}


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

[apiInstance uploadVideoWith:reviewId
    uploadProfilePhotoRequest:uploadProfilePhotoRequest
              completionHandler: ^('String' 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.VideoRestControllerApi()
var reviewId = 789; // {Long} 
var opts = {
  'uploadProfilePhotoRequest':  // {UploadProfilePhotoRequest} 
};

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

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

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

            // Create an instance of the API class
            var apiInstance = new VideoRestControllerApi();
            var reviewId = 789;  // Long |  (default to null)
            var uploadProfilePhotoRequest = new UploadProfilePhotoRequest(); // UploadProfilePhotoRequest |  (optional) 

            try {
                'String' result = apiInstance.uploadVideo(reviewId, uploadProfilePhotoRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling VideoRestControllerApi.uploadVideo: " + e.Message );
            }
        }
    }
}

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

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

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

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

eval {
    my $result = $api_instance->uploadVideo(reviewId => $reviewId, uploadProfilePhotoRequest => $uploadProfilePhotoRequest);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling VideoRestControllerApi->uploadVideo: $@\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.VideoRestControllerApi()
reviewId = 789 # Long |  (default to null)
uploadProfilePhotoRequest =  # UploadProfilePhotoRequest |  (optional)

try:
    api_response = api_instance.upload_video(reviewId, uploadProfilePhotoRequest=uploadProfilePhotoRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling VideoRestControllerApi->uploadVideo: %s\n" % e)
extern crate VideoRestControllerApi;

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

    let mut context = VideoRestControllerApi::Context::default();
    let result = client.uploadVideo(reviewId, uploadProfilePhotoRequest, &context).wait();

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

Scopes

Parameters

Path parameters
Name Description
reviewId*
Long (int64)
Required
Body parameters
Name Description
uploadProfilePhotoRequest

Responses