OpenAPI definition

RestCommentsController

createComment

Create a new comment

/api/v1/posts/{id}/comments

Usage and SDK Samples

curl -X POST \
 -H "Accept: application/json" \
 "http://localhost:8443/api/v1/posts/{id}/comments?request="

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

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

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

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

        try {
            SimpleCommentDTO result = apiInstance.createComment(id, request);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling RestCommentsControllerApi#createComment");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

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

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

import org.openapitools.client.api.RestCommentsControllerApi;

public class RestCommentsControllerApiExample {
    public static void main(String[] args) {
        RestCommentsControllerApi apiInstance = new RestCommentsControllerApi();
        Long id = 789; // Long | 
        CreateCommentRequest request = ; // CreateCommentRequest | 

        try {
            SimpleCommentDTO result = apiInstance.createComment(id, request);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling RestCommentsControllerApi#createComment");
            e.printStackTrace();
        }
    }
}



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

// Create a new comment
[apiInstance createCommentWith:id
    request:request
              completionHandler: ^(SimpleCommentDTO 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.RestCommentsControllerApi()
var id = 789; // {Long} 
var request = ; // {CreateCommentRequest} 

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

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

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

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

            try {
                // Create a new comment
                SimpleCommentDTO result = apiInstance.createComment(id, request);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling RestCommentsControllerApi.createComment: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

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

try:
    # Create a new comment
    api_response = api_instance.create_comment(id, request)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling RestCommentsControllerApi->createComment: %s\n" % e)

extern crate RestCommentsControllerApi;

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

    let mut context = RestCommentsControllerApi::Context::default();
    let result = client.createComment(id, request, &context).wait();

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

Scopes

Parameters

Path parameters

Name	Description
id*	Long (int64) Required

Query parameters

Name	Description
request*	CreateCommentRequest Required

Responses

Schema

createComment1

Create a new comment

/api/v1/posts/{id}/comments/

Usage and SDK Samples

curl -X POST \
 -H "Accept: application/json" \
 "http://localhost:8443/api/v1/posts/{id}/comments/?request="

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

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

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

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

        try {
            SimpleCommentDTO result = apiInstance.createComment1(id, request);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling RestCommentsControllerApi#createComment1");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

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

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

import org.openapitools.client.api.RestCommentsControllerApi;

public class RestCommentsControllerApiExample {
    public static void main(String[] args) {
        RestCommentsControllerApi apiInstance = new RestCommentsControllerApi();
        Long id = 789; // Long | 
        CreateCommentRequest request = ; // CreateCommentRequest | 

        try {
            SimpleCommentDTO result = apiInstance.createComment1(id, request);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling RestCommentsControllerApi#createComment1");
            e.printStackTrace();
        }
    }
}



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

// Create a new comment
[apiInstance createComment1With:id
    request:request
              completionHandler: ^(SimpleCommentDTO 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.RestCommentsControllerApi()
var id = 789; // {Long} 
var request = ; // {CreateCommentRequest} 

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

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

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

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

            try {
                // Create a new comment
                SimpleCommentDTO result = apiInstance.createComment1(id, request);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling RestCommentsControllerApi.createComment1: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

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

try:
    # Create a new comment
    api_response = api_instance.create_comment1(id, request)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling RestCommentsControllerApi->createComment1: %s\n" % e)

extern crate RestCommentsControllerApi;

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

    let mut context = RestCommentsControllerApi::Context::default();
    let result = client.createComment1(id, request, &context).wait();

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

Scopes

Parameters

Path parameters

Name	Description
id*	Long (int64) Required

Query parameters

Name	Description
request*	CreateCommentRequest Required

Responses

Schema

deleteComment

Delete a comment

/api/v1/posts/{id}/comments/{commentId}

Usage and SDK Samples

curl -X DELETE \
 -H "Accept: application/json" \
 "http://localhost:8443/api/v1/posts/{id}/comments/{commentId}"

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

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

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

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

        try {
            SimpleCommentDTO result = apiInstance.deleteComment(id, commentId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling RestCommentsControllerApi#deleteComment");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

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

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

import org.openapitools.client.api.RestCommentsControllerApi;

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

        try {
            SimpleCommentDTO result = apiInstance.deleteComment(id, commentId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling RestCommentsControllerApi#deleteComment");
            e.printStackTrace();
        }
    }
}



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

// Delete a comment
[apiInstance deleteCommentWith:id
    commentId:commentId
              completionHandler: ^(SimpleCommentDTO 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.RestCommentsControllerApi()
var id = 789; // {Long} 
var commentId = 789; // {Long} 

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

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

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

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

            try {
                // Delete a comment
                SimpleCommentDTO result = apiInstance.deleteComment(id, commentId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling RestCommentsControllerApi.deleteComment: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

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

try:
    # Delete a comment
    api_response = api_instance.delete_comment(id, commentId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling RestCommentsControllerApi->deleteComment: %s\n" % e)

extern crate RestCommentsControllerApi;

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

    let mut context = RestCommentsControllerApi::Context::default();
    let result = client.deleteComment(id, commentId, &context).wait();

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

Scopes

Parameters

Path parameters

Name	Description
id*	Long (int64) Required
commentId*	Long (int64) Required

Responses

Schema

getComment

Get a comment

/api/v1/posts/{id}/comments/{commentId}

Usage and SDK Samples

curl -X GET \
 -H "Accept: application/json" \
 "http://localhost:8443/api/v1/posts/{id}/comments/{commentId}"

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

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

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

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

        try {
            SimpleCommentDTO result = apiInstance.getComment(id, commentId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling RestCommentsControllerApi#getComment");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

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

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

import org.openapitools.client.api.RestCommentsControllerApi;

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

        try {
            SimpleCommentDTO result = apiInstance.getComment(id, commentId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling RestCommentsControllerApi#getComment");
            e.printStackTrace();
        }
    }
}



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

// Get a comment
[apiInstance getCommentWith:id
    commentId:commentId
              completionHandler: ^(SimpleCommentDTO 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.RestCommentsControllerApi()
var id = 789; // {Long} 
var commentId = 789; // {Long} 

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

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

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

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

            try {
                // Get a comment
                SimpleCommentDTO result = apiInstance.getComment(id, commentId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling RestCommentsControllerApi.getComment: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

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

try:
    # Get a comment
    api_response = api_instance.get_comment(id, commentId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling RestCommentsControllerApi->getComment: %s\n" % e)

extern crate RestCommentsControllerApi;

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

    let mut context = RestCommentsControllerApi::Context::default();
    let result = client.getComment(id, commentId, &context).wait();

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

Scopes

Parameters

Path parameters

Name	Description
id*	Long (int64) Required
commentId*	Long (int64) Required

Responses

Schema

getComments

Get all comments

/api/v1/posts/{id}/comments

Usage and SDK Samples

curl -X GET \
 -H "Accept: application/json" \
 "http://localhost:8443/api/v1/posts/{id}/comments?pageable="

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

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

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

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

        try {
            PaginatedDTO result = apiInstance.getComments(id, pageable);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling RestCommentsControllerApi#getComments");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

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

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

import org.openapitools.client.api.RestCommentsControllerApi;

public class RestCommentsControllerApiExample {
    public static void main(String[] args) {
        RestCommentsControllerApi apiInstance = new RestCommentsControllerApi();
        Long id = 789; // Long | 
        Pageable pageable = ; // Pageable | 

        try {
            PaginatedDTO result = apiInstance.getComments(id, pageable);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling RestCommentsControllerApi#getComments");
            e.printStackTrace();
        }
    }
}



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

// Get all comments
[apiInstance getCommentsWith:id
    pageable:pageable
              completionHandler: ^(PaginatedDTO 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.RestCommentsControllerApi()
var id = 789; // {Long} 
var pageable = ; // {Pageable} 

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

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

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

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

            try {
                // Get all comments
                PaginatedDTO result = apiInstance.getComments(id, pageable);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling RestCommentsControllerApi.getComments: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

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

try:
    # Get all comments
    api_response = api_instance.get_comments(id, pageable)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling RestCommentsControllerApi->getComments: %s\n" % e)

extern crate RestCommentsControllerApi;

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

    let mut context = RestCommentsControllerApi::Context::default();
    let result = client.getComments(id, pageable, &context).wait();

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

Scopes

Parameters

Path parameters

Name	Description
id*	Long (int64) Required

Query parameters

Name	Description
pageable*	Pageable Required

Responses

Schema

getComments1

Get all comments

/api/v1/posts/{id}/comments/

Usage and SDK Samples

curl -X GET \
 -H "Accept: application/json" \
 "http://localhost:8443/api/v1/posts/{id}/comments/?pageable="

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

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

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

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

        try {
            PaginatedDTO result = apiInstance.getComments1(id, pageable);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling RestCommentsControllerApi#getComments1");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

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

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

import org.openapitools.client.api.RestCommentsControllerApi;

public class RestCommentsControllerApiExample {
    public static void main(String[] args) {
        RestCommentsControllerApi apiInstance = new RestCommentsControllerApi();
        Long id = 789; // Long | 
        Pageable pageable = ; // Pageable | 

        try {
            PaginatedDTO result = apiInstance.getComments1(id, pageable);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling RestCommentsControllerApi#getComments1");
            e.printStackTrace();
        }
    }
}



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

// Get all comments
[apiInstance getComments1With:id
    pageable:pageable
              completionHandler: ^(PaginatedDTO 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.RestCommentsControllerApi()
var id = 789; // {Long} 
var pageable = ; // {Pageable} 

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

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

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

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

            try {
                // Get all comments
                PaginatedDTO result = apiInstance.getComments1(id, pageable);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling RestCommentsControllerApi.getComments1: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

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

try:
    # Get all comments
    api_response = api_instance.get_comments1(id, pageable)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling RestCommentsControllerApi->getComments1: %s\n" % e)

extern crate RestCommentsControllerApi;

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

    let mut context = RestCommentsControllerApi::Context::default();
    let result = client.getComments1(id, pageable, &context).wait();

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

Scopes

Parameters

Path parameters

Name	Description
id*	Long (int64) Required

Query parameters

Name	Description
pageable*	Pageable Required

Responses

Schema

updateComment

Update a comment

/api/v1/posts/{id}/comments/{commentId}

Usage and SDK Samples

curl -X PATCH \
 -H "Accept: application/json" \
 "http://localhost:8443/api/v1/posts/{id}/comments/{commentId}?request="

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

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

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

        // Create an instance of the API class
        RestCommentsControllerApi apiInstance = new RestCommentsControllerApi();
        Long id = 789; // Long | 
        Long commentId = 789; // Long | 
        CreateCommentRequest request = ; // CreateCommentRequest | 

        try {
            SimpleCommentDTO result = apiInstance.updateComment(id, commentId, request);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling RestCommentsControllerApi#updateComment");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final Long id = new Long(); // Long | 
final Long commentId = new Long(); // Long | 
final CreateCommentRequest request = new CreateCommentRequest(); // CreateCommentRequest | 

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

import org.openapitools.client.api.RestCommentsControllerApi;

public class RestCommentsControllerApiExample {
    public static void main(String[] args) {
        RestCommentsControllerApi apiInstance = new RestCommentsControllerApi();
        Long id = 789; // Long | 
        Long commentId = 789; // Long | 
        CreateCommentRequest request = ; // CreateCommentRequest | 

        try {
            SimpleCommentDTO result = apiInstance.updateComment(id, commentId, request);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling RestCommentsControllerApi#updateComment");
            e.printStackTrace();
        }
    }
}



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

// Update a comment
[apiInstance updateCommentWith:id
    commentId:commentId
    request:request
              completionHandler: ^(SimpleCommentDTO 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.RestCommentsControllerApi()
var id = 789; // {Long} 
var commentId = 789; // {Long} 
var request = ; // {CreateCommentRequest} 

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

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

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

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

            try {
                // Update a comment
                SimpleCommentDTO result = apiInstance.updateComment(id, commentId, request);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling RestCommentsControllerApi.updateComment: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

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

try:
    # Update a comment
    api_response = api_instance.update_comment(id, commentId, request)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling RestCommentsControllerApi->updateComment: %s\n" % e)

extern crate RestCommentsControllerApi;

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

    let mut context = RestCommentsControllerApi::Context::default();
    let result = client.updateComment(id, commentId, request, &context).wait();

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

Scopes

Parameters

Path parameters

Name	Description
id*	Long (int64) Required
commentId*	Long (int64) Required

Query parameters

Name	Description
request*	CreateCommentRequest Required

Responses

Schema

RestLoginController

logOut

/api/auth/logout

Usage and SDK Samples

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

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

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

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

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

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

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

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



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

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

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

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

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

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

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

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

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

extern crate RestLoginControllerApi;

pub fn main() {

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

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

Scopes

Parameters

Responses

Schema

login

/api/auth/login

Usage and SDK Samples

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

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

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

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

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

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

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

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



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

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

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

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

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

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

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

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

extern crate RestLoginControllerApi;

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

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

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

Scopes

Parameters

Body parameters

Name	Description
loginRequest *

Responses

refreshToken

/api/auth/refresh

Usage and SDK Samples

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

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

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

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

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

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

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

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



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

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

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

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

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

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

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

extern crate RestLoginControllerApi;

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

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

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

Scopes

Parameters

Responses

Schema

RestPostsController

createPost

Create a post

/api/v1/posts/

Usage and SDK Samples

curl -X POST \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "http://localhost:8443/api/v1/posts/?createPostRequest=" \
 -d '{
  "date" : "date",
  "visibility" : "PUBLIC",
  "author" : "author",
  "description" : "description",
  "title" : "title",
  "content" : "content",
  "tags" : [ "tags", "tags" ]
}'

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

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

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

        // Create an instance of the API class
        RestPostsControllerApi apiInstance = new RestPostsControllerApi();
        CreatePostRequest createPostRequest = ; // CreatePostRequest | 
        CreatePostRequest createPostRequest2 = ; // CreatePostRequest | 

        try {
            PostDTO result = apiInstance.createPost(createPostRequest, createPostRequest2);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling RestPostsControllerApi#createPost");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final CreatePostRequest createPostRequest = new CreatePostRequest(); // CreatePostRequest | 
final CreatePostRequest createPostRequest2 = new CreatePostRequest(); // CreatePostRequest | 

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

import org.openapitools.client.api.RestPostsControllerApi;

public class RestPostsControllerApiExample {
    public static void main(String[] args) {
        RestPostsControllerApi apiInstance = new RestPostsControllerApi();
        CreatePostRequest createPostRequest = ; // CreatePostRequest | 
        CreatePostRequest createPostRequest2 = ; // CreatePostRequest | 

        try {
            PostDTO result = apiInstance.createPost(createPostRequest, createPostRequest2);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling RestPostsControllerApi#createPost");
            e.printStackTrace();
        }
    }
}



// Create an instance of the API class
RestPostsControllerApi *apiInstance = [[RestPostsControllerApi alloc] init];
CreatePostRequest *createPostRequest = ; //  (default to null)
CreatePostRequest *createPostRequest2 = ; //  (optional)

// Create a post
[apiInstance createPostWith:createPostRequest
    createPostRequest2:createPostRequest2
              completionHandler: ^(PostDTO 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.RestPostsControllerApi()
var createPostRequest = ; // {CreatePostRequest} 
var opts = {
  'createPostRequest2':  // {CreatePostRequest} 
};

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

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

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

            // Create an instance of the API class
            var apiInstance = new RestPostsControllerApi();
            var createPostRequest = new CreatePostRequest(); // CreatePostRequest |  (default to null)
            var createPostRequest2 = new CreatePostRequest(); // CreatePostRequest |  (optional) 

            try {
                // Create a post
                PostDTO result = apiInstance.createPost(createPostRequest, createPostRequest2);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling RestPostsControllerApi.createPost: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\RestPostsControllerApi();
$createPostRequest = ; // CreatePostRequest | 
$createPostRequest2 = ; // CreatePostRequest | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::RestPostsControllerApi->new();
my $createPostRequest = ; # CreatePostRequest | 
my $createPostRequest2 = WWW::OPenAPIClient::Object::CreatePostRequest->new(); # CreatePostRequest | 

eval {
    my $result = $api_instance->createPost(createPostRequest => $createPostRequest, createPostRequest2 => $createPostRequest2);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling RestPostsControllerApi->createPost: $@\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.RestPostsControllerApi()
createPostRequest =  # CreatePostRequest |  (default to null)
createPostRequest2 =  # CreatePostRequest |  (optional)

try:
    # Create a post
    api_response = api_instance.create_post(createPostRequest, createPostRequest2=createPostRequest2)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling RestPostsControllerApi->createPost: %s\n" % e)

extern crate RestPostsControllerApi;

pub fn main() {
    let createPostRequest = ; // CreatePostRequest
    let createPostRequest2 = ; // CreatePostRequest

    let mut context = RestPostsControllerApi::Context::default();
    let result = client.createPost(createPostRequest, createPostRequest2, &context).wait();

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

Scopes

Parameters

Body parameters

Name	Description
createPostRequest2

Query parameters

Name	Description
createPostRequest*	CreatePostRequest Required

Responses

Schema

createPost1

Create a post

/api/v1/posts

Usage and SDK Samples

curl -X POST \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "http://localhost:8443/api/v1/posts?createPostRequest=" \
 -d '{
  "date" : "date",
  "visibility" : "PUBLIC",
  "author" : "author",
  "description" : "description",
  "title" : "title",
  "content" : "content",
  "tags" : [ "tags", "tags" ]
}'

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

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

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

        // Create an instance of the API class
        RestPostsControllerApi apiInstance = new RestPostsControllerApi();
        CreatePostRequest createPostRequest = ; // CreatePostRequest | 
        CreatePostRequest createPostRequest2 = ; // CreatePostRequest | 

        try {
            PostDTO result = apiInstance.createPost1(createPostRequest, createPostRequest2);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling RestPostsControllerApi#createPost1");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final CreatePostRequest createPostRequest = new CreatePostRequest(); // CreatePostRequest | 
final CreatePostRequest createPostRequest2 = new CreatePostRequest(); // CreatePostRequest | 

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

import org.openapitools.client.api.RestPostsControllerApi;

public class RestPostsControllerApiExample {
    public static void main(String[] args) {
        RestPostsControllerApi apiInstance = new RestPostsControllerApi();
        CreatePostRequest createPostRequest = ; // CreatePostRequest | 
        CreatePostRequest createPostRequest2 = ; // CreatePostRequest | 

        try {
            PostDTO result = apiInstance.createPost1(createPostRequest, createPostRequest2);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling RestPostsControllerApi#createPost1");
            e.printStackTrace();
        }
    }
}



// Create an instance of the API class
RestPostsControllerApi *apiInstance = [[RestPostsControllerApi alloc] init];
CreatePostRequest *createPostRequest = ; //  (default to null)
CreatePostRequest *createPostRequest2 = ; //  (optional)

// Create a post
[apiInstance createPost1With:createPostRequest
    createPostRequest2:createPostRequest2
              completionHandler: ^(PostDTO 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.RestPostsControllerApi()
var createPostRequest = ; // {CreatePostRequest} 
var opts = {
  'createPostRequest2':  // {CreatePostRequest} 
};

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

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

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

            // Create an instance of the API class
            var apiInstance = new RestPostsControllerApi();
            var createPostRequest = new CreatePostRequest(); // CreatePostRequest |  (default to null)
            var createPostRequest2 = new CreatePostRequest(); // CreatePostRequest |  (optional) 

            try {
                // Create a post
                PostDTO result = apiInstance.createPost1(createPostRequest, createPostRequest2);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling RestPostsControllerApi.createPost1: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\RestPostsControllerApi();
$createPostRequest = ; // CreatePostRequest | 
$createPostRequest2 = ; // CreatePostRequest | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::RestPostsControllerApi->new();
my $createPostRequest = ; # CreatePostRequest | 
my $createPostRequest2 = WWW::OPenAPIClient::Object::CreatePostRequest->new(); # CreatePostRequest | 

eval {
    my $result = $api_instance->createPost1(createPostRequest => $createPostRequest, createPostRequest2 => $createPostRequest2);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling RestPostsControllerApi->createPost1: $@\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.RestPostsControllerApi()
createPostRequest =  # CreatePostRequest |  (default to null)
createPostRequest2 =  # CreatePostRequest |  (optional)

try:
    # Create a post
    api_response = api_instance.create_post1(createPostRequest, createPostRequest2=createPostRequest2)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling RestPostsControllerApi->createPost1: %s\n" % e)

extern crate RestPostsControllerApi;

pub fn main() {
    let createPostRequest = ; // CreatePostRequest
    let createPostRequest2 = ; // CreatePostRequest

    let mut context = RestPostsControllerApi::Context::default();
    let result = client.createPost1(createPostRequest, createPostRequest2, &context).wait();

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

Scopes

Parameters

Body parameters

Name	Description
createPostRequest2

Query parameters

Name	Description
createPostRequest*	CreatePostRequest Required

Responses

Schema

deletePost

Delete a post by id

/api/v1/posts/{id}

Usage and SDK Samples

curl -X DELETE \
 -H "Accept: application/json" \
 "http://localhost:8443/api/v1/posts/{id}"

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

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

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

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

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

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

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

import org.openapitools.client.api.RestPostsControllerApi;

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

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



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

// Delete a post by id
[apiInstance deletePostWith:id
              completionHandler: ^(PostDTO 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.RestPostsControllerApi()
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.deletePost(id, callback);

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

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

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

            try {
                // Delete a post by id
                PostDTO result = apiInstance.deletePost(id);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling RestPostsControllerApi.deletePost: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

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

try:
    # Delete a post by id
    api_response = api_instance.delete_post(id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling RestPostsControllerApi->deletePost: %s\n" % e)

extern crate RestPostsControllerApi;

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

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

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

Scopes

Parameters

Path parameters

Name	Description
id*	Long (int64) Required

Responses

Schema

deletePostBanner

Delete post banner

/api/v1/posts/{id}/banner

Usage and SDK Samples

curl -X DELETE \
 -H "Accept: application/json" \
 "http://localhost:8443/api/v1/posts/{id}/banner"

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

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

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

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

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

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

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

import org.openapitools.client.api.RestPostsControllerApi;

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

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



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

// Delete post banner
[apiInstance deletePostBannerWith:id
              completionHandler: ^(PostDTO 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.RestPostsControllerApi()
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.deletePostBanner(id, callback);

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

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

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

            try {
                // Delete post banner
                PostDTO result = apiInstance.deletePostBanner(id);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling RestPostsControllerApi.deletePostBanner: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

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

try:
    # Delete post banner
    api_response = api_instance.delete_post_banner(id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling RestPostsControllerApi->deletePostBanner: %s\n" % e)

extern crate RestPostsControllerApi;

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

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

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

Scopes

Parameters

Path parameters

Name	Description
id*	Long (int64) Required

Responses

Schema

getPost

Get a post by id

/api/v1/posts/{id}

Usage and SDK Samples

curl -X GET \
 -H "Accept: application/json" \
 "http://localhost:8443/api/v1/posts/{id}"

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

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

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

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

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

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

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

import org.openapitools.client.api.RestPostsControllerApi;

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

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



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

// Get a post by id
[apiInstance getPostWith:id
              completionHandler: ^(PostDTO 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.RestPostsControllerApi()
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.getPost(id, callback);

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

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

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

            try {
                // Get a post by id
                PostDTO result = apiInstance.getPost(id);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling RestPostsControllerApi.getPost: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

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

try:
    # Get a post by id
    api_response = api_instance.get_post(id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling RestPostsControllerApi->getPost: %s\n" % e)

extern crate RestPostsControllerApi;

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

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

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

Scopes

Parameters

Path parameters

Name	Description
id*	Long (int64) Required

Responses

Schema

getPostBanner

Get post banner

/api/v1/posts/{id}/banner

Usage and SDK Samples

curl -X GET \
 -H "Accept: application/json" \
 "http://localhost:8443/api/v1/posts/{id}/banner"

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

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

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

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

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

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

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

import org.openapitools.client.api.RestPostsControllerApi;

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

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



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

// Get post banner
[apiInstance getPostBannerWith:id
              completionHandler: ^(File output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenApiDefinition = require('open_api_definition');

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

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

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

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

            try {
                // Get post banner
                File result = apiInstance.getPostBanner(id);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling RestPostsControllerApi.getPostBanner: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

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

try:
    # Get post banner
    api_response = api_instance.get_post_banner(id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling RestPostsControllerApi->getPostBanner: %s\n" % e)

extern crate RestPostsControllerApi;

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

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

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

Scopes

Parameters

Path parameters

Name	Description
id*	Long (int64) Required

Responses

Schema

getPostContent

Get post content

/api/v1/posts/{id}/content

Usage and SDK Samples

curl -X GET \
 -H "Accept: application/json" \
 "http://localhost:8443/api/v1/posts/{id}/content"

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

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

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

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

        try {
            'String' result = apiInstance.getPostContent(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling RestPostsControllerApi#getPostContent");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

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

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

import org.openapitools.client.api.RestPostsControllerApi;

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

        try {
            'String' result = apiInstance.getPostContent(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling RestPostsControllerApi#getPostContent");
            e.printStackTrace();
        }
    }
}



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

// Get post content
[apiInstance getPostContentWith:id
              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.RestPostsControllerApi()
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.getPostContent(id, callback);

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

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

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

            try {
                // Get post content
                'String' result = apiInstance.getPostContent(id);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling RestPostsControllerApi.getPostContent: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

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

try:
    # Get post content
    api_response = api_instance.get_post_content(id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling RestPostsControllerApi->getPostContent: %s\n" % e)

extern crate RestPostsControllerApi;

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

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

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

Scopes

Parameters

Path parameters

Name	Description
id*	Long (int64) Required

Responses

Schema

getPosts

Get all posts paginated

/api/v1/posts/

Usage and SDK Samples

curl -X GET \
 -H "Accept: application/json" \
 "http://localhost:8443/api/v1/posts/?pageable="

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

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

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

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

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

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

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

import org.openapitools.client.api.RestPostsControllerApi;

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

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



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

// Get all posts paginated
[apiInstance getPostsWith:pageable
              completionHandler: ^(PaginatedDTO 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.RestPostsControllerApi()
var pageable = ; // {Pageable} 

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

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

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

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

            try {
                // Get all posts paginated
                PaginatedDTO result = apiInstance.getPosts(pageable);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling RestPostsControllerApi.getPosts: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

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

try:
    # Get all posts paginated
    api_response = api_instance.get_posts(pageable)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling RestPostsControllerApi->getPosts: %s\n" % e)

extern crate RestPostsControllerApi;

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

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

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

Scopes

Parameters

Query parameters

Name	Description
pageable*	Pageable Required

Responses

Schema

getPosts1

Get all posts paginated

/api/v1/posts

Usage and SDK Samples

curl -X GET \
 -H "Accept: application/json" \
 "http://localhost:8443/api/v1/posts?pageable="

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

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

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

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

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

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

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

import org.openapitools.client.api.RestPostsControllerApi;

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

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



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

// Get all posts paginated
[apiInstance getPosts1With:pageable
              completionHandler: ^(PaginatedDTO 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.RestPostsControllerApi()
var pageable = ; // {Pageable} 

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

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

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

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

            try {
                // Get all posts paginated
                PaginatedDTO result = apiInstance.getPosts1(pageable);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling RestPostsControllerApi.getPosts1: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

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

try:
    # Get all posts paginated
    api_response = api_instance.get_posts1(pageable)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling RestPostsControllerApi->getPosts1: %s\n" % e)

extern crate RestPostsControllerApi;

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

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

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

Scopes

Parameters

Query parameters

Name	Description
pageable*	Pageable Required

Responses

Schema

updatePost

Update a post by id

/api/v1/posts/{id}

Usage and SDK Samples

curl -X PATCH \
 -H "Accept: application/json" \
 "http://localhost:8443/api/v1/posts/{id}?createPostRequest="

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

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

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

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

        try {
            PostDTO result = apiInstance.updatePost(id, createPostRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling RestPostsControllerApi#updatePost");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

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

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

import org.openapitools.client.api.RestPostsControllerApi;

public class RestPostsControllerApiExample {
    public static void main(String[] args) {
        RestPostsControllerApi apiInstance = new RestPostsControllerApi();
        Long id = 789; // Long | 
        CreatePostRequest createPostRequest = ; // CreatePostRequest | 

        try {
            PostDTO result = apiInstance.updatePost(id, createPostRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling RestPostsControllerApi#updatePost");
            e.printStackTrace();
        }
    }
}



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

// Update a post by id
[apiInstance updatePostWith:id
    createPostRequest:createPostRequest
              completionHandler: ^(PostDTO 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.RestPostsControllerApi()
var id = 789; // {Long} 
var createPostRequest = ; // {CreatePostRequest} 

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

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

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

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

            try {
                // Update a post by id
                PostDTO result = apiInstance.updatePost(id, createPostRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling RestPostsControllerApi.updatePost: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

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

try:
    # Update a post by id
    api_response = api_instance.update_post(id, createPostRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling RestPostsControllerApi->updatePost: %s\n" % e)

extern crate RestPostsControllerApi;

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

    let mut context = RestPostsControllerApi::Context::default();
    let result = client.updatePost(id, createPostRequest, &context).wait();

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

Scopes

Parameters

Path parameters

Name	Description
id*	Long (int64) Required

Query parameters

Name	Description
createPostRequest*	CreatePostRequest Required

Responses

Schema

updatePostBanner

Update post banner

/api/v1/posts/{id}/banner

Usage and SDK Samples

curl -X POST \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "http://localhost:8443/api/v1/posts/{id}/banner" \
 -d ''

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

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

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

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

        try {
            PostDTO result = apiInstance.updatePostBanner(id, updatePostBannerRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling RestPostsControllerApi#updatePostBanner");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

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

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

import org.openapitools.client.api.RestPostsControllerApi;

public class RestPostsControllerApiExample {
    public static void main(String[] args) {
        RestPostsControllerApi apiInstance = new RestPostsControllerApi();
        Long id = 789; // Long | 
        UpdatePostBannerRequest updatePostBannerRequest = ; // UpdatePostBannerRequest | 

        try {
            PostDTO result = apiInstance.updatePostBanner(id, updatePostBannerRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling RestPostsControllerApi#updatePostBanner");
            e.printStackTrace();
        }
    }
}



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

// Update post banner
[apiInstance updatePostBannerWith:id
    updatePostBannerRequest:updatePostBannerRequest
              completionHandler: ^(PostDTO 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.RestPostsControllerApi()
var id = 789; // {Long} 
var opts = {
  'updatePostBannerRequest':  // {UpdatePostBannerRequest} 
};

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

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

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

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

            try {
                // Update post banner
                PostDTO result = apiInstance.updatePostBanner(id, updatePostBannerRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling RestPostsControllerApi.updatePostBanner: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

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

try:
    # Update post banner
    api_response = api_instance.update_post_banner(id, updatePostBannerRequest=updatePostBannerRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling RestPostsControllerApi->updatePostBanner: %s\n" % e)

extern crate RestPostsControllerApi;

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

    let mut context = RestPostsControllerApi::Context::default();
    let result = client.updatePostBanner(id, updatePostBannerRequest, &context).wait();

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

Scopes

Parameters

Path parameters

Name	Description
id*	Long (int64) Required

Body parameters

Name	Description
updatePostBannerRequest

Responses

Schema

RestProductsController

compareProducts

Compare products

/api/v1/products/{id}/compare

Usage and SDK Samples

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

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

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

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

        // Create an instance of the API class
        RestProductsControllerApi apiInstance = new RestProductsControllerApi();
        String id = id_example; // String | 

        try {
            'String' result = apiInstance.compareProducts(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling RestProductsControllerApi#compareProducts");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

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

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

import org.openapitools.client.api.RestProductsControllerApi;

public class RestProductsControllerApiExample {
    public static void main(String[] args) {
        RestProductsControllerApi apiInstance = new RestProductsControllerApi();
        String id = id_example; // String | 

        try {
            'String' result = apiInstance.compareProducts(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling RestProductsControllerApi#compareProducts");
            e.printStackTrace();
        }
    }
}



// Create an instance of the API class
RestProductsControllerApi *apiInstance = [[RestProductsControllerApi alloc] init];
String *id = id_example; //  (default to null)

// Compare products
[apiInstance compareProductsWith:id
              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.RestProductsControllerApi()
var id = id_example; // {String} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new RestProductsControllerApi();
            var id = id_example;  // String |  (default to null)

            try {
                // Compare products
                'String' result = apiInstance.compareProducts(id);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling RestProductsControllerApi.compareProducts: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\RestProductsControllerApi();
$id = id_example; // String | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::RestProductsControllerApi->new();
my $id = id_example; # String | 

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

try:
    # Compare products
    api_response = api_instance.compare_products(id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling RestProductsControllerApi->compareProducts: %s\n" % e)

extern crate RestProductsControllerApi;

pub fn main() {
    let id = id_example; // String

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

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

Scopes

Parameters

Path parameters

Name	Description
id*	String Required

Responses

Schema

Schema

Schema

getProductById

Get product by id

/api/v1/products/{id}

Usage and SDK Samples

curl -X GET \
 -H "Accept: */*" \
 "http://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.RestProductsControllerApi;

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

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

        // Create an instance of the API class
        RestProductsControllerApi apiInstance = new RestProductsControllerApi();
        String id = id_example; // String | 

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

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

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

import org.openapitools.client.api.RestProductsControllerApi;

public class RestProductsControllerApiExample {
    public static void main(String[] args) {
        RestProductsControllerApi apiInstance = new RestProductsControllerApi();
        String id = id_example; // String | 

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



// Create an instance of the API class
RestProductsControllerApi *apiInstance = [[RestProductsControllerApi alloc] init];
String *id = id_example; //  (default to null)

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

var OpenApiDefinition = require('open_api_definition');

// Create an instance of the API class
var api = new OpenApiDefinition.RestProductsControllerApi()
var id = id_example; // {String} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new RestProductsControllerApi();
            var id = id_example;  // String |  (default to null)

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

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\RestProductsControllerApi();
$id = id_example; // String | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::RestProductsControllerApi->new();
my $id = id_example; # String | 

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

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

# Create an instance of the API class
api_instance = openapi_client.RestProductsControllerApi()
id = id_example # String |  (default to null)

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

extern crate RestProductsControllerApi;

pub fn main() {
    let id = id_example; // String

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

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

Scopes

Parameters

Path parameters

Name	Description
id*	String Required

Responses

Schema

Schema

Schema

getProducts

Get products

/api/v1/products/

Usage and SDK Samples

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

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

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

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

        // Create an instance of the API class
        RestProductsControllerApi apiInstance = new RestProductsControllerApi();
        SearchProductRequest searchProductRequest = ; // SearchProductRequest | 

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final SearchProductRequest searchProductRequest = new SearchProductRequest(); // SearchProductRequest | 

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

import org.openapitools.client.api.RestProductsControllerApi;

public class RestProductsControllerApiExample {
    public static void main(String[] args) {
        RestProductsControllerApi apiInstance = new RestProductsControllerApi();
        SearchProductRequest searchProductRequest = ; // SearchProductRequest | 

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



// Create an instance of the API class
RestProductsControllerApi *apiInstance = [[RestProductsControllerApi alloc] init];
SearchProductRequest *searchProductRequest = ; //  (default to null)

// Get products
[apiInstance getProductsWith:searchProductRequest
              completionHandler: ^(PaginatedDTO 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.RestProductsControllerApi()
var searchProductRequest = ; // {SearchProductRequest} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new RestProductsControllerApi();
            var searchProductRequest = new SearchProductRequest(); // SearchProductRequest |  (default to null)

            try {
                // Get products
                PaginatedDTO result = apiInstance.getProducts(searchProductRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling RestProductsControllerApi.getProducts: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\RestProductsControllerApi();
$searchProductRequest = ; // SearchProductRequest | 

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

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

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

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

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

# Create an instance of the API class
api_instance = openapi_client.RestProductsControllerApi()
searchProductRequest =  # SearchProductRequest |  (default to null)

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

extern crate RestProductsControllerApi;

pub fn main() {
    let searchProductRequest = ; // SearchProductRequest

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

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

Scopes

Parameters

Query parameters

Name	Description
searchProductRequest*	SearchProductRequest Required

Responses

Schema

Schema

getProducts1

Get products

/api/v1/products

Usage and SDK Samples

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

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

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

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

        // Create an instance of the API class
        RestProductsControllerApi apiInstance = new RestProductsControllerApi();
        SearchProductRequest searchProductRequest = ; // SearchProductRequest | 

        try {
            PaginatedDTO result = apiInstance.getProducts1(searchProductRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling RestProductsControllerApi#getProducts1");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final SearchProductRequest searchProductRequest = new SearchProductRequest(); // SearchProductRequest | 

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

import org.openapitools.client.api.RestProductsControllerApi;

public class RestProductsControllerApiExample {
    public static void main(String[] args) {
        RestProductsControllerApi apiInstance = new RestProductsControllerApi();
        SearchProductRequest searchProductRequest = ; // SearchProductRequest | 

        try {
            PaginatedDTO result = apiInstance.getProducts1(searchProductRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling RestProductsControllerApi#getProducts1");
            e.printStackTrace();
        }
    }
}



// Create an instance of the API class
RestProductsControllerApi *apiInstance = [[RestProductsControllerApi alloc] init];
SearchProductRequest *searchProductRequest = ; //  (default to null)

// Get products
[apiInstance getProducts1With:searchProductRequest
              completionHandler: ^(PaginatedDTO 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.RestProductsControllerApi()
var searchProductRequest = ; // {SearchProductRequest} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new RestProductsControllerApi();
            var searchProductRequest = new SearchProductRequest(); // SearchProductRequest |  (default to null)

            try {
                // Get products
                PaginatedDTO result = apiInstance.getProducts1(searchProductRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling RestProductsControllerApi.getProducts1: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\RestProductsControllerApi();
$searchProductRequest = ; // SearchProductRequest | 

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

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

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

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

try:
    # Get products
    api_response = api_instance.get_products1(searchProductRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling RestProductsControllerApi->getProducts1: %s\n" % e)

extern crate RestProductsControllerApi;

pub fn main() {
    let searchProductRequest = ; // SearchProductRequest

    let mut context = RestProductsControllerApi::Context::default();
    let result = client.getProducts1(searchProductRequest, &context).wait();

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

Scopes

Parameters

Query parameters

Name	Description
searchProductRequest*	SearchProductRequest Required

Responses

Schema

Schema

suggestProducts

Suggest products

/api/v1/products/{id}/suggested

Usage and SDK Samples

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

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

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

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

        // Create an instance of the API class
        RestProductsControllerApi apiInstance = new RestProductsControllerApi();
        String id = id_example; // String | 

        try {
            'String' result = apiInstance.suggestProducts(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling RestProductsControllerApi#suggestProducts");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

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

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

import org.openapitools.client.api.RestProductsControllerApi;

public class RestProductsControllerApiExample {
    public static void main(String[] args) {
        RestProductsControllerApi apiInstance = new RestProductsControllerApi();
        String id = id_example; // String | 

        try {
            'String' result = apiInstance.suggestProducts(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling RestProductsControllerApi#suggestProducts");
            e.printStackTrace();
        }
    }
}



// Create an instance of the API class
RestProductsControllerApi *apiInstance = [[RestProductsControllerApi alloc] init];
String *id = id_example; //  (default to null)

// Suggest products
[apiInstance suggestProductsWith:id
              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.RestProductsControllerApi()
var id = id_example; // {String} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new RestProductsControllerApi();
            var id = id_example;  // String |  (default to null)

            try {
                // Suggest products
                'String' result = apiInstance.suggestProducts(id);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling RestProductsControllerApi.suggestProducts: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\RestProductsControllerApi();
$id = id_example; // String | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::RestProductsControllerApi->new();
my $id = id_example; # String | 

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

try:
    # Suggest products
    api_response = api_instance.suggest_products(id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling RestProductsControllerApi->suggestProducts: %s\n" % e)

extern crate RestProductsControllerApi;

pub fn main() {
    let id = id_example; // String

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

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

Scopes

Parameters

Path parameters

Name	Description
id*	String Required

Responses

Schema

Schema

Schema

RestShoppingListController

addProductToList

Add a product to a list

/api/v1/lists/{id}/product/{productId}

Usage and SDK Samples

curl -X POST \
 -H "Accept: application/json" \
 "http://localhost:8443/api/v1/lists/{id}/product/{productId}"

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

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

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

        // Create an instance of the API class
        RestShoppingListControllerApi apiInstance = new RestShoppingListControllerApi();
        Long id = 789; // Long | 
        String productId = productId_example; // String | 

        try {
            ShoppingListDTO result = apiInstance.addProductToList(id, productId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling RestShoppingListControllerApi#addProductToList");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

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

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

import org.openapitools.client.api.RestShoppingListControllerApi;

public class RestShoppingListControllerApiExample {
    public static void main(String[] args) {
        RestShoppingListControllerApi apiInstance = new RestShoppingListControllerApi();
        Long id = 789; // Long | 
        String productId = productId_example; // String | 

        try {
            ShoppingListDTO result = apiInstance.addProductToList(id, productId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling RestShoppingListControllerApi#addProductToList");
            e.printStackTrace();
        }
    }
}



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

// Add a product to a list
[apiInstance addProductToListWith:id
    productId:productId
              completionHandler: ^(ShoppingListDTO 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.RestShoppingListControllerApi()
var id = 789; // {Long} 
var productId = productId_example; // {String} 

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

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

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

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

            try {
                // Add a product to a list
                ShoppingListDTO result = apiInstance.addProductToList(id, productId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling RestShoppingListControllerApi.addProductToList: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

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

try:
    # Add a product to a list
    api_response = api_instance.add_product_to_list(id, productId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling RestShoppingListControllerApi->addProductToList: %s\n" % e)

extern crate RestShoppingListControllerApi;

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

    let mut context = RestShoppingListControllerApi::Context::default();
    let result = client.addProductToList(id, productId, &context).wait();

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

Scopes

Parameters

Path parameters

Name	Description
id*	Long (int64) Required
productId*	String Required

Responses

Schema

getShoppingList

Get a list

/api/v1/lists/{id}

Usage and SDK Samples

curl -X GET \
 -H "Accept: application/json" \
 "http://localhost:8443/api/v1/lists/{id}"

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

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

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

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

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

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

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

import org.openapitools.client.api.RestShoppingListControllerApi;

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

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



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

// Get a list
[apiInstance getShoppingListWith:id
              completionHandler: ^(ShoppingListDTO 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.RestShoppingListControllerApi()
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.getShoppingList(id, callback);

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

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

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

            try {
                // Get a list
                ShoppingListDTO result = apiInstance.getShoppingList(id);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling RestShoppingListControllerApi.getShoppingList: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

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

try:
    # Get a list
    api_response = api_instance.get_shopping_list(id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling RestShoppingListControllerApi->getShoppingList: %s\n" % e)

extern crate RestShoppingListControllerApi;

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

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

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

Scopes

Parameters

Path parameters

Name	Description
id*	Long (int64) Required

Responses

Schema

getUserLists

Get all lists

/api/v1/lists

Usage and SDK Samples

curl -X GET \
 -H "Accept: application/json" \
 "http://localhost:8443/api/v1/lists?pageable="

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

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

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

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

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

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

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

import org.openapitools.client.api.RestShoppingListControllerApi;

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

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



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

// Get all lists
[apiInstance getUserListsWith:pageable
              completionHandler: ^(PaginatedDTO 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.RestShoppingListControllerApi()
var pageable = ; // {Pageable} 

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

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

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

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

            try {
                // Get all lists
                PaginatedDTO result = apiInstance.getUserLists(pageable);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling RestShoppingListControllerApi.getUserLists: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

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

try:
    # Get all lists
    api_response = api_instance.get_user_lists(pageable)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling RestShoppingListControllerApi->getUserLists: %s\n" % e)

extern crate RestShoppingListControllerApi;

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

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

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

Scopes

Parameters

Query parameters

Name	Description
pageable*	Pageable Required

Responses

Schema

getUserLists1

Get all lists

/api/v1/lists/

Usage and SDK Samples

curl -X GET \
 -H "Accept: application/json" \
 "http://localhost:8443/api/v1/lists/?pageable="

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

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

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

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

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

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

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

import org.openapitools.client.api.RestShoppingListControllerApi;

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

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



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

// Get all lists
[apiInstance getUserLists1With:pageable
              completionHandler: ^(PaginatedDTO 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.RestShoppingListControllerApi()
var pageable = ; // {Pageable} 

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

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

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

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

            try {
                // Get all lists
                PaginatedDTO result = apiInstance.getUserLists1(pageable);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling RestShoppingListControllerApi.getUserLists1: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

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

try:
    # Get all lists
    api_response = api_instance.get_user_lists1(pageable)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling RestShoppingListControllerApi->getUserLists1: %s\n" % e)

extern crate RestShoppingListControllerApi;

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

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

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

Scopes

Parameters

Query parameters

Name	Description
pageable*	Pageable Required

Responses

Schema

newList

Create a new list

/api/v1/lists

Usage and SDK Samples

curl -X POST \
 -H "Accept: application/json" \
 "http://localhost:8443/api/v1/lists?request="

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

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

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

        // Create an instance of the API class
        RestShoppingListControllerApi apiInstance = new RestShoppingListControllerApi();
        CreateListRequest request = ; // CreateListRequest | 

        try {
            SimpleShoppingListDTO result = apiInstance.newList(request);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling RestShoppingListControllerApi#newList");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final CreateListRequest request = new CreateListRequest(); // CreateListRequest | 

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

import org.openapitools.client.api.RestShoppingListControllerApi;

public class RestShoppingListControllerApiExample {
    public static void main(String[] args) {
        RestShoppingListControllerApi apiInstance = new RestShoppingListControllerApi();
        CreateListRequest request = ; // CreateListRequest | 

        try {
            SimpleShoppingListDTO result = apiInstance.newList(request);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling RestShoppingListControllerApi#newList");
            e.printStackTrace();
        }
    }
}



// Create an instance of the API class
RestShoppingListControllerApi *apiInstance = [[RestShoppingListControllerApi alloc] init];
CreateListRequest *request = ; //  (default to null)

// Create a new list
[apiInstance newListWith:request
              completionHandler: ^(SimpleShoppingListDTO 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.RestShoppingListControllerApi()
var request = ; // {CreateListRequest} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new RestShoppingListControllerApi();
            var request = new CreateListRequest(); // CreateListRequest |  (default to null)

            try {
                // Create a new list
                SimpleShoppingListDTO result = apiInstance.newList(request);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling RestShoppingListControllerApi.newList: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\RestShoppingListControllerApi();
$request = ; // CreateListRequest | 

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

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

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

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

try:
    # Create a new list
    api_response = api_instance.new_list(request)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling RestShoppingListControllerApi->newList: %s\n" % e)

extern crate RestShoppingListControllerApi;

pub fn main() {
    let request = ; // CreateListRequest

    let mut context = RestShoppingListControllerApi::Context::default();
    let result = client.newList(request, &context).wait();

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

Scopes

Parameters

Query parameters

Name	Description
request*	CreateListRequest Required

Responses

Schema

newList1

Create a new list

/api/v1/lists/

Usage and SDK Samples

curl -X POST \
 -H "Accept: application/json" \
 "http://localhost:8443/api/v1/lists/?request="

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

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

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

        // Create an instance of the API class
        RestShoppingListControllerApi apiInstance = new RestShoppingListControllerApi();
        CreateListRequest request = ; // CreateListRequest | 

        try {
            SimpleShoppingListDTO result = apiInstance.newList1(request);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling RestShoppingListControllerApi#newList1");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final CreateListRequest request = new CreateListRequest(); // CreateListRequest | 

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

import org.openapitools.client.api.RestShoppingListControllerApi;

public class RestShoppingListControllerApiExample {
    public static void main(String[] args) {
        RestShoppingListControllerApi apiInstance = new RestShoppingListControllerApi();
        CreateListRequest request = ; // CreateListRequest | 

        try {
            SimpleShoppingListDTO result = apiInstance.newList1(request);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling RestShoppingListControllerApi#newList1");
            e.printStackTrace();
        }
    }
}



// Create an instance of the API class
RestShoppingListControllerApi *apiInstance = [[RestShoppingListControllerApi alloc] init];
CreateListRequest *request = ; //  (default to null)

// Create a new list
[apiInstance newList1With:request
              completionHandler: ^(SimpleShoppingListDTO 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.RestShoppingListControllerApi()
var request = ; // {CreateListRequest} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new RestShoppingListControllerApi();
            var request = new CreateListRequest(); // CreateListRequest |  (default to null)

            try {
                // Create a new list
                SimpleShoppingListDTO result = apiInstance.newList1(request);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling RestShoppingListControllerApi.newList1: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\RestShoppingListControllerApi();
$request = ; // CreateListRequest | 

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

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

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

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

try:
    # Create a new list
    api_response = api_instance.new_list1(request)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling RestShoppingListControllerApi->newList1: %s\n" % e)

extern crate RestShoppingListControllerApi;

pub fn main() {
    let request = ; // CreateListRequest

    let mut context = RestShoppingListControllerApi::Context::default();
    let result = client.newList1(request, &context).wait();

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

Scopes

Parameters

Query parameters

Name	Description
request*	CreateListRequest Required

Responses

Schema

removeList

Remove a list

/api/v1/lists/{id}

Usage and SDK Samples

curl -X DELETE \
 -H "Accept: application/json" \
 "http://localhost:8443/api/v1/lists/{id}"

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

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

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

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

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

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

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

import org.openapitools.client.api.RestShoppingListControllerApi;

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

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



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

// Remove a list
[apiInstance removeListWith:id
              completionHandler: ^(ShoppingListDTO 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.RestShoppingListControllerApi()
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.removeList(id, callback);

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

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

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

            try {
                // Remove a list
                ShoppingListDTO result = apiInstance.removeList(id);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling RestShoppingListControllerApi.removeList: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

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

try:
    # Remove a list
    api_response = api_instance.remove_list(id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling RestShoppingListControllerApi->removeList: %s\n" % e)

extern crate RestShoppingListControllerApi;

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

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

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

Scopes

Parameters

Path parameters

Name	Description
id*	Long (int64) Required

Responses

Schema

removeProductFromList

Remove a product from a list

/api/v1/lists/{id}/product/{productId}

Usage and SDK Samples

curl -X DELETE \
 -H "Accept: application/json" \
 "http://localhost:8443/api/v1/lists/{id}/product/{productId}"

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

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

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

        // Create an instance of the API class
        RestShoppingListControllerApi apiInstance = new RestShoppingListControllerApi();
        Long id = 789; // Long | 
        String productId = productId_example; // String | 

        try {
            SimpleShoppingListDTO result = apiInstance.removeProductFromList(id, productId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling RestShoppingListControllerApi#removeProductFromList");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

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

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

import org.openapitools.client.api.RestShoppingListControllerApi;

public class RestShoppingListControllerApiExample {
    public static void main(String[] args) {
        RestShoppingListControllerApi apiInstance = new RestShoppingListControllerApi();
        Long id = 789; // Long | 
        String productId = productId_example; // String | 

        try {
            SimpleShoppingListDTO result = apiInstance.removeProductFromList(id, productId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling RestShoppingListControllerApi#removeProductFromList");
            e.printStackTrace();
        }
    }
}



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

// Remove a product from a list
[apiInstance removeProductFromListWith:id
    productId:productId
              completionHandler: ^(SimpleShoppingListDTO 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.RestShoppingListControllerApi()
var id = 789; // {Long} 
var productId = productId_example; // {String} 

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

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

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

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

            try {
                // Remove a product from a list
                SimpleShoppingListDTO result = apiInstance.removeProductFromList(id, productId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling RestShoppingListControllerApi.removeProductFromList: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

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

try:
    # Remove a product from a list
    api_response = api_instance.remove_product_from_list(id, productId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling RestShoppingListControllerApi->removeProductFromList: %s\n" % e)

extern crate RestShoppingListControllerApi;

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

    let mut context = RestShoppingListControllerApi::Context::default();
    let result = client.removeProductFromList(id, productId, &context).wait();

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

Scopes

Parameters

Path parameters

Name	Description
id*	Long (int64) Required
productId*	String Required

Responses

Schema

updateList

Update a list

/api/v1/lists/{id}

Usage and SDK Samples

curl -X PATCH \
 -H "Accept: application/json" \
 "http://localhost:8443/api/v1/lists/{id}?request="

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

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

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

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

        try {
            ShoppingListDTO result = apiInstance.updateList(id, request);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling RestShoppingListControllerApi#updateList");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

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

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

import org.openapitools.client.api.RestShoppingListControllerApi;

public class RestShoppingListControllerApiExample {
    public static void main(String[] args) {
        RestShoppingListControllerApi apiInstance = new RestShoppingListControllerApi();
        Long id = 789; // Long | 
        CreateListRequest request = ; // CreateListRequest | 

        try {
            ShoppingListDTO result = apiInstance.updateList(id, request);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling RestShoppingListControllerApi#updateList");
            e.printStackTrace();
        }
    }
}



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

// Update a list
[apiInstance updateListWith:id
    request:request
              completionHandler: ^(ShoppingListDTO 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.RestShoppingListControllerApi()
var id = 789; // {Long} 
var request = ; // {CreateListRequest} 

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

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

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

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

            try {
                // Update a list
                ShoppingListDTO result = apiInstance.updateList(id, request);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling RestShoppingListControllerApi.updateList: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

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

try:
    # Update a list
    api_response = api_instance.update_list(id, request)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling RestShoppingListControllerApi->updateList: %s\n" % e)

extern crate RestShoppingListControllerApi;

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

    let mut context = RestShoppingListControllerApi::Context::default();
    let result = client.updateList(id, request, &context).wait();

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

Scopes

Parameters

Path parameters

Name	Description
id*	Long (int64) Required

Query parameters

Name	Description
request*	CreateListRequest Required

Responses

Schema

RestStatsController

getProductsStats

Get the stats of the products

/api/v1/stats/products

Usage and SDK Samples

curl -X GET \
 -H "Accept: application/json" \
 "http://localhost:8443/api/v1/stats/products"

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

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

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

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

        try {
            SupermarketStatsDTO result = apiInstance.getProductsStats();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling RestStatsControllerApi#getProductsStats");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();


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

import org.openapitools.client.api.RestStatsControllerApi;

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

        try {
            SupermarketStatsDTO result = apiInstance.getProductsStats();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling RestStatsControllerApi#getProductsStats");
            e.printStackTrace();
        }
    }
}



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

// Get the stats of the products
[apiInstance getProductsStatsWithCompletionHandler: 
              ^(SupermarketStatsDTO 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.RestStatsControllerApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getProductsStats(callback);

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

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

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

            try {
                // Get the stats of the products
                SupermarketStatsDTO result = apiInstance.getProductsStats();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling RestStatsControllerApi.getProductsStats: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

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

try:
    # Get the stats of the products
    api_response = api_instance.get_products_stats()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling RestStatsControllerApi->getProductsStats: %s\n" % e)

extern crate RestStatsControllerApi;

pub fn main() {

    let mut context = RestStatsControllerApi::Context::default();
    let result = client.getProductsStats(&context).wait();

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

Scopes

Parameters

Responses

Schema

getUsersStats

Get the stats of the users

/api/v1/stats/users

Usage and SDK Samples

curl -X GET \
 -H "Accept: application/json" \
 "http://localhost:8443/api/v1/stats/users"

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

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

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

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

        try {
            SupermarketStatsDTO result = apiInstance.getUsersStats();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling RestStatsControllerApi#getUsersStats");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();


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

import org.openapitools.client.api.RestStatsControllerApi;

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

        try {
            SupermarketStatsDTO result = apiInstance.getUsersStats();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling RestStatsControllerApi#getUsersStats");
            e.printStackTrace();
        }
    }
}



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

// Get the stats of the users
[apiInstance getUsersStatsWithCompletionHandler: 
              ^(SupermarketStatsDTO 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.RestStatsControllerApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getUsersStats(callback);

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

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

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

            try {
                // Get the stats of the users
                SupermarketStatsDTO result = apiInstance.getUsersStats();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling RestStatsControllerApi.getUsersStats: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

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

try:
    # Get the stats of the users
    api_response = api_instance.get_users_stats()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling RestStatsControllerApi->getUsersStats: %s\n" % e)

extern crate RestStatsControllerApi;

pub fn main() {

    let mut context = RestStatsControllerApi::Context::default();
    let result = client.getUsersStats(&context).wait();

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

Scopes

Parameters

Responses

Schema

RestUserController

deleteAvatar

Delete avatar for logged user

/api/v1/users/{id}/avatar

Usage and SDK Samples

curl -X DELETE \
 -H "Accept: application/json" \
 "http://localhost:8443/api/v1/users/{id}/avatar"

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

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

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

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

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

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

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

import org.openapitools.client.api.RestUserControllerApi;

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

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



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

// Delete avatar for logged user
[apiInstance deleteAvatarWith:id
              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.RestUserControllerApi()
var id = 789; // {Long} 

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

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

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

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

            try {
                // Delete avatar for logged user
                'String' result = apiInstance.deleteAvatar(id);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling RestUserControllerApi.deleteAvatar: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

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

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

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

try:
    # Delete avatar for logged user
    api_response = api_instance.delete_avatar(id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling RestUserControllerApi->deleteAvatar: %s\n" % e)

extern crate RestUserControllerApi;

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

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

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

Scopes

Parameters

Path parameters

Name	Description
id*	Long (int64) Required

Responses

Schema

deleteUser

Delete user

/api/v1/users/{id}

Usage and SDK Samples

curl -X DELETE \
 -H "Accept: application/json" \
 "http://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.RestUserControllerApi;

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

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

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

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

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

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



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

// Delete user
[apiInstance deleteUserWith:id
              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.RestUserControllerApi()
var id = 789; // {Long} 

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

            try {
                // Delete user
                'String' result = apiInstance.deleteUser(id);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling RestUserControllerApi.deleteUser: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

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

try:
    # Delete user
    api_response = api_instance.delete_user(id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling RestUserControllerApi->deleteUser: %s\n" % e)

extern crate RestUserControllerApi;

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

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

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

Scopes

Parameters

Path parameters

Name	Description
id*	Long (int64) Required

Responses

Schema

getProfilePic

Get logged user avatar

/api/v1/users/{id}/avatar

Usage and SDK Samples

curl -X GET \
 -H "Accept: application/json" \
 "http://localhost:8443/api/v1/users/{id}/avatar"

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

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

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

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

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

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

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

import org.openapitools.client.api.RestUserControllerApi;

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

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



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

// Get logged user avatar
[apiInstance getProfilePicWith:id
              completionHandler: ^(File output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenApiDefinition = require('open_api_definition');

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

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

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

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

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

            try {
                // Get logged user avatar
                File result = apiInstance.getProfilePic(id);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling RestUserControllerApi.getProfilePic: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

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

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

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

try:
    # Get logged user avatar
    api_response = api_instance.get_profile_pic(id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling RestUserControllerApi->getProfilePic: %s\n" % e)

extern crate RestUserControllerApi;

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

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

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

Scopes

Parameters

Path parameters

Name	Description
id*	Long (int64) Required

Responses

Schema

getUser

Get user by id

/api/v1/users/{id}

Usage and SDK Samples

curl -X GET \
 -H "Accept: application/json" \
 "http://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.RestUserControllerApi;

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

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

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

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

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

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



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

// Get user by id
[apiInstance getUserWith:id
              completionHandler: ^(PublicUserDTO output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenApiDefinition = require('open_api_definition');

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

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

            try {
                // Get user by id
                PublicUserDTO result = apiInstance.getUser(id);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling RestUserControllerApi.getUser: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

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

try:
    # Get user by id
    api_response = api_instance.get_user(id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling RestUserControllerApi->getUser: %s\n" % e)

extern crate RestUserControllerApi;

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

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

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

Scopes

Parameters

Path parameters

Name	Description
id*	Long (int64) Required

Responses

Schema

getUsers

Get all users Paginated

/api/v1/users/

Usage and SDK Samples

curl -X GET \
 -H "Accept: application/json" \
 "http://localhost:8443/api/v1/users/?pageable="

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

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

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

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

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

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

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

import org.openapitools.client.api.RestUserControllerApi;

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

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



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

// Get all users Paginated
[apiInstance getUsersWith:pageable
              completionHandler: ^(PaginatedDTO output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenApiDefinition = require('open_api_definition');

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

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

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

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

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

            try {
                // Get all users Paginated
                PaginatedDTO result = apiInstance.getUsers(pageable);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling RestUserControllerApi.getUsers: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

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

try:
    # Get all users Paginated
    api_response = api_instance.get_users(pageable)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling RestUserControllerApi->getUsers: %s\n" % e)

extern crate RestUserControllerApi;

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

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

    println!("{:?}", result);
}

Scopes

Parameters

Query parameters

Name	Description
pageable*	Pageable Required

Responses

Schema

getUsers1

Get all users Paginated

/api/v1/users

Usage and SDK Samples

curl -X GET \
 -H "Accept: application/json" \
 "http://localhost:8443/api/v1/users?pageable="

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.RestUserControllerApi;

import java.io.File;
import java.util.*;

public class RestUserControllerApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        RestUserControllerApi apiInstance = new RestUserControllerApi();
        Pageable pageable = ; // Pageable | 

        try {
            PaginatedDTO result = apiInstance.getUsers1(pageable);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling RestUserControllerApi#getUsers1");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final Pageable pageable = new Pageable(); // Pageable | 

try {
    final result = await api_instance.getUsers1(pageable);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->getUsers1: $e\n');
}

import org.openapitools.client.api.RestUserControllerApi;

public class RestUserControllerApiExample {
    public static void main(String[] args) {
        RestUserControllerApi apiInstance = new RestUserControllerApi();
        Pageable pageable = ; // Pageable | 

        try {
            PaginatedDTO result = apiInstance.getUsers1(pageable);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling RestUserControllerApi#getUsers1");
            e.printStackTrace();
        }
    }
}



// Create an instance of the API class
RestUserControllerApi *apiInstance = [[RestUserControllerApi alloc] init];
Pageable *pageable = ; //  (default to null)

// Get all users Paginated
[apiInstance getUsers1With:pageable
              completionHandler: ^(PaginatedDTO output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenApiDefinition = require('open_api_definition');

// Create an instance of the API class
var api = new OpenApiDefinition.RestUserControllerApi()
var pageable = ; // {Pageable} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.getUsers1(pageable, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class getUsers1Example
    {
        public void main()
        {

            // Create an instance of the API class
            var apiInstance = new RestUserControllerApi();
            var pageable = new Pageable(); // Pageable |  (default to null)

            try {
                // Get all users Paginated
                PaginatedDTO result = apiInstance.getUsers1(pageable);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling RestUserControllerApi.getUsers1: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\RestUserControllerApi();
$pageable = ; // Pageable | 

try {
    $result = $api_instance->getUsers1($pageable);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling RestUserControllerApi->getUsers1: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::RestUserControllerApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::RestUserControllerApi->new();
my $pageable = ; # Pageable | 

eval {
    my $result = $api_instance->getUsers1(pageable => $pageable);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling RestUserControllerApi->getUsers1: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Create an instance of the API class
api_instance = openapi_client.RestUserControllerApi()
pageable =  # Pageable |  (default to null)

try:
    # Get all users Paginated
    api_response = api_instance.get_users1(pageable)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling RestUserControllerApi->getUsers1: %s\n" % e)

extern crate RestUserControllerApi;

pub fn main() {
    let pageable = ; // Pageable

    let mut context = RestUserControllerApi::Context::default();
    let result = client.getUsers1(pageable, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Query parameters

Name	Description
pageable*	Pageable Required

Responses

Schema

modifyAvatar

Modify avatar for logged user

/api/v1/users/{id}/avatar

Usage and SDK Samples

curl -X PUT \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "http://localhost:8443/api/v1/users/{id}/avatar" \
 -d ''

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.RestUserControllerApi;

import java.io.File;
import java.util.*;

public class RestUserControllerApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        RestUserControllerApi apiInstance = new RestUserControllerApi();
        Long id = 789; // Long | 
        ModifyAvatarRequest modifyAvatarRequest = ; // ModifyAvatarRequest | 

        try {
            PublicUserDTO result = apiInstance.modifyAvatar(id, modifyAvatarRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling RestUserControllerApi#modifyAvatar");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final Long id = new Long(); // Long | 
final ModifyAvatarRequest modifyAvatarRequest = new ModifyAvatarRequest(); // ModifyAvatarRequest | 

try {
    final result = await api_instance.modifyAvatar(id, modifyAvatarRequest);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->modifyAvatar: $e\n');
}

import org.openapitools.client.api.RestUserControllerApi;

public class RestUserControllerApiExample {
    public static void main(String[] args) {
        RestUserControllerApi apiInstance = new RestUserControllerApi();
        Long id = 789; // Long | 
        ModifyAvatarRequest modifyAvatarRequest = ; // ModifyAvatarRequest | 

        try {
            PublicUserDTO result = apiInstance.modifyAvatar(id, modifyAvatarRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling RestUserControllerApi#modifyAvatar");
            e.printStackTrace();
        }
    }
}



// Create an instance of the API class
RestUserControllerApi *apiInstance = [[RestUserControllerApi alloc] init];
Long *id = 789; //  (default to null)
ModifyAvatarRequest *modifyAvatarRequest = ; //  (optional)

// Modify avatar for logged user
[apiInstance modifyAvatarWith:id
    modifyAvatarRequest:modifyAvatarRequest
              completionHandler: ^(PublicUserDTO output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenApiDefinition = require('open_api_definition');

// Create an instance of the API class
var api = new OpenApiDefinition.RestUserControllerApi()
var id = 789; // {Long} 
var opts = {
  'modifyAvatarRequest':  // {ModifyAvatarRequest} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.modifyAvatar(id, opts, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class modifyAvatarExample
    {
        public void main()
        {

            // Create an instance of the API class
            var apiInstance = new RestUserControllerApi();
            var id = 789;  // Long |  (default to null)
            var modifyAvatarRequest = new ModifyAvatarRequest(); // ModifyAvatarRequest |  (optional) 

            try {
                // Modify avatar for logged user
                PublicUserDTO result = apiInstance.modifyAvatar(id, modifyAvatarRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling RestUserControllerApi.modifyAvatar: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\RestUserControllerApi();
$id = 789; // Long | 
$modifyAvatarRequest = ; // ModifyAvatarRequest | 

try {
    $result = $api_instance->modifyAvatar($id, $modifyAvatarRequest);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling RestUserControllerApi->modifyAvatar: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::RestUserControllerApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::RestUserControllerApi->new();
my $id = 789; # Long | 
my $modifyAvatarRequest = WWW::OPenAPIClient::Object::ModifyAvatarRequest->new(); # ModifyAvatarRequest | 

eval {
    my $result = $api_instance->modifyAvatar(id => $id, modifyAvatarRequest => $modifyAvatarRequest);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling RestUserControllerApi->modifyAvatar: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Create an instance of the API class
api_instance = openapi_client.RestUserControllerApi()
id = 789 # Long |  (default to null)
modifyAvatarRequest =  # ModifyAvatarRequest |  (optional)

try:
    # Modify avatar for logged user
    api_response = api_instance.modify_avatar(id, modifyAvatarRequest=modifyAvatarRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling RestUserControllerApi->modifyAvatar: %s\n" % e)

extern crate RestUserControllerApi;

pub fn main() {
    let id = 789; // Long
    let modifyAvatarRequest = ; // ModifyAvatarRequest

    let mut context = RestUserControllerApi::Context::default();
    let result = client.modifyAvatar(id, modifyAvatarRequest, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters

Name	Description
id*	Long (int64) Required

Body parameters

Name	Description
modifyAvatarRequest

Responses

Schema

modifyPassword

Modify user password

/api/v1/users/{id}/password

Usage and SDK Samples

curl -X PATCH \
 -H "Accept: application/json" \
 "http://localhost:8443/api/v1/users/{id}/password?modifyUserPassword="

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.RestUserControllerApi;

import java.io.File;
import java.util.*;

public class RestUserControllerApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        RestUserControllerApi apiInstance = new RestUserControllerApi();
        Long id = 789; // Long | 
        ModifyPasswordRequest modifyUserPassword = ; // ModifyPasswordRequest | 

        try {
            PrivateUserDTO result = apiInstance.modifyPassword(id, modifyUserPassword);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling RestUserControllerApi#modifyPassword");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final Long id = new Long(); // Long | 
final ModifyPasswordRequest modifyUserPassword = new ModifyPasswordRequest(); // ModifyPasswordRequest | 

try {
    final result = await api_instance.modifyPassword(id, modifyUserPassword);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->modifyPassword: $e\n');
}

import org.openapitools.client.api.RestUserControllerApi;

public class RestUserControllerApiExample {
    public static void main(String[] args) {
        RestUserControllerApi apiInstance = new RestUserControllerApi();
        Long id = 789; // Long | 
        ModifyPasswordRequest modifyUserPassword = ; // ModifyPasswordRequest | 

        try {
            PrivateUserDTO result = apiInstance.modifyPassword(id, modifyUserPassword);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling RestUserControllerApi#modifyPassword");
            e.printStackTrace();
        }
    }
}



// Create an instance of the API class
RestUserControllerApi *apiInstance = [[RestUserControllerApi alloc] init];
Long *id = 789; //  (default to null)
ModifyPasswordRequest *modifyUserPassword = ; //  (default to null)

// Modify user password
[apiInstance modifyPasswordWith:id
    modifyUserPassword:modifyUserPassword
              completionHandler: ^(PrivateUserDTO output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenApiDefinition = require('open_api_definition');

// Create an instance of the API class
var api = new OpenApiDefinition.RestUserControllerApi()
var id = 789; // {Long} 
var modifyUserPassword = ; // {ModifyPasswordRequest} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.modifyPassword(id, modifyUserPassword, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class modifyPasswordExample
    {
        public void main()
        {

            // Create an instance of the API class
            var apiInstance = new RestUserControllerApi();
            var id = 789;  // Long |  (default to null)
            var modifyUserPassword = new ModifyPasswordRequest(); // ModifyPasswordRequest |  (default to null)

            try {
                // Modify user password
                PrivateUserDTO result = apiInstance.modifyPassword(id, modifyUserPassword);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling RestUserControllerApi.modifyPassword: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\RestUserControllerApi();
$id = 789; // Long | 
$modifyUserPassword = ; // ModifyPasswordRequest | 

try {
    $result = $api_instance->modifyPassword($id, $modifyUserPassword);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling RestUserControllerApi->modifyPassword: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::RestUserControllerApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::RestUserControllerApi->new();
my $id = 789; # Long | 
my $modifyUserPassword = ; # ModifyPasswordRequest | 

eval {
    my $result = $api_instance->modifyPassword(id => $id, modifyUserPassword => $modifyUserPassword);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling RestUserControllerApi->modifyPassword: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Create an instance of the API class
api_instance = openapi_client.RestUserControllerApi()
id = 789 # Long |  (default to null)
modifyUserPassword =  # ModifyPasswordRequest |  (default to null)

try:
    # Modify user password
    api_response = api_instance.modify_password(id, modifyUserPassword)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling RestUserControllerApi->modifyPassword: %s\n" % e)

extern crate RestUserControllerApi;

pub fn main() {
    let id = 789; // Long
    let modifyUserPassword = ; // ModifyPasswordRequest

    let mut context = RestUserControllerApi::Context::default();
    let result = client.modifyPassword(id, modifyUserPassword, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters

Name	Description
id*	Long (int64) Required

Query parameters

Name	Description
modifyUserPassword*	ModifyPasswordRequest Required

Responses

Schema

modifyUser

Modify user

/api/v1/users/{id}

Usage and SDK Samples

curl -X PATCH \
 -H "Accept: application/json" \
 "http://localhost:8443/api/v1/users/{id}?modifyUser="

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.RestUserControllerApi;

import java.io.File;
import java.util.*;

public class RestUserControllerApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        RestUserControllerApi apiInstance = new RestUserControllerApi();
        Long id = 789; // Long | 
        ModifyUserRequest modifyUser = ; // ModifyUserRequest | 

        try {
            PrivateUserDTO result = apiInstance.modifyUser(id, modifyUser);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling RestUserControllerApi#modifyUser");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final Long id = new Long(); // Long | 
final ModifyUserRequest modifyUser = new ModifyUserRequest(); // ModifyUserRequest | 

try {
    final result = await api_instance.modifyUser(id, modifyUser);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->modifyUser: $e\n');
}

import org.openapitools.client.api.RestUserControllerApi;

public class RestUserControllerApiExample {
    public static void main(String[] args) {
        RestUserControllerApi apiInstance = new RestUserControllerApi();
        Long id = 789; // Long | 
        ModifyUserRequest modifyUser = ; // ModifyUserRequest | 

        try {
            PrivateUserDTO result = apiInstance.modifyUser(id, modifyUser);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling RestUserControllerApi#modifyUser");
            e.printStackTrace();
        }
    }
}



// Create an instance of the API class
RestUserControllerApi *apiInstance = [[RestUserControllerApi alloc] init];
Long *id = 789; //  (default to null)
ModifyUserRequest *modifyUser = ; //  (default to null)

// Modify user
[apiInstance modifyUserWith:id
    modifyUser:modifyUser
              completionHandler: ^(PrivateUserDTO output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenApiDefinition = require('open_api_definition');

// Create an instance of the API class
var api = new OpenApiDefinition.RestUserControllerApi()
var id = 789; // {Long} 
var modifyUser = ; // {ModifyUserRequest} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.modifyUser(id, modifyUser, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class modifyUserExample
    {
        public void main()
        {

            // Create an instance of the API class
            var apiInstance = new RestUserControllerApi();
            var id = 789;  // Long |  (default to null)
            var modifyUser = new ModifyUserRequest(); // ModifyUserRequest |  (default to null)

            try {
                // Modify user
                PrivateUserDTO result = apiInstance.modifyUser(id, modifyUser);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling RestUserControllerApi.modifyUser: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\RestUserControllerApi();
$id = 789; // Long | 
$modifyUser = ; // ModifyUserRequest | 

try {
    $result = $api_instance->modifyUser($id, $modifyUser);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling RestUserControllerApi->modifyUser: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::RestUserControllerApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::RestUserControllerApi->new();
my $id = 789; # Long | 
my $modifyUser = ; # ModifyUserRequest | 

eval {
    my $result = $api_instance->modifyUser(id => $id, modifyUser => $modifyUser);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling RestUserControllerApi->modifyUser: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Create an instance of the API class
api_instance = openapi_client.RestUserControllerApi()
id = 789 # Long |  (default to null)
modifyUser =  # ModifyUserRequest |  (default to null)

try:
    # Modify user
    api_response = api_instance.modify_user(id, modifyUser)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling RestUserControllerApi->modifyUser: %s\n" % e)

extern crate RestUserControllerApi;

pub fn main() {
    let id = 789; // Long
    let modifyUser = ; // ModifyUserRequest

    let mut context = RestUserControllerApi::Context::default();
    let result = client.modifyUser(id, modifyUser, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters

Name	Description
id*	Long (int64) Required

Query parameters

Name	Description
modifyUser*	ModifyUserRequest Required

Responses

Schema

registerNewUser

/api/v1/users/

Usage and SDK Samples

curl -X POST \
 -H "Accept: application/json" \
 "http://localhost:8443/api/v1/users/?createUserRequest="

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.RestUserControllerApi;

import java.io.File;
import java.util.*;

public class RestUserControllerApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        RestUserControllerApi apiInstance = new RestUserControllerApi();
        CreateUserRequest createUserRequest = ; // CreateUserRequest | 

        try {
            PrivateUserDTO result = apiInstance.registerNewUser(createUserRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling RestUserControllerApi#registerNewUser");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final CreateUserRequest createUserRequest = new CreateUserRequest(); // CreateUserRequest | 

try {
    final result = await api_instance.registerNewUser(createUserRequest);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->registerNewUser: $e\n');
}

import org.openapitools.client.api.RestUserControllerApi;

public class RestUserControllerApiExample {
    public static void main(String[] args) {
        RestUserControllerApi apiInstance = new RestUserControllerApi();
        CreateUserRequest createUserRequest = ; // CreateUserRequest | 

        try {
            PrivateUserDTO result = apiInstance.registerNewUser(createUserRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling RestUserControllerApi#registerNewUser");
            e.printStackTrace();
        }
    }
}



// Create an instance of the API class
RestUserControllerApi *apiInstance = [[RestUserControllerApi alloc] init];
CreateUserRequest *createUserRequest = ; //  (default to null)

// Register new user
[apiInstance registerNewUserWith:createUserRequest
              completionHandler: ^(PrivateUserDTO output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenApiDefinition = require('open_api_definition');

// Create an instance of the API class
var api = new OpenApiDefinition.RestUserControllerApi()
var createUserRequest = ; // {CreateUserRequest} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.registerNewUser(createUserRequest, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class registerNewUserExample
    {
        public void main()
        {

            // Create an instance of the API class
            var apiInstance = new RestUserControllerApi();
            var createUserRequest = new CreateUserRequest(); // CreateUserRequest |  (default to null)

            try {
                // Register new user
                PrivateUserDTO result = apiInstance.registerNewUser(createUserRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling RestUserControllerApi.registerNewUser: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\RestUserControllerApi();
$createUserRequest = ; // CreateUserRequest | 

try {
    $result = $api_instance->registerNewUser($createUserRequest);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling RestUserControllerApi->registerNewUser: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::RestUserControllerApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::RestUserControllerApi->new();
my $createUserRequest = ; # CreateUserRequest | 

eval {
    my $result = $api_instance->registerNewUser(createUserRequest => $createUserRequest);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling RestUserControllerApi->registerNewUser: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Create an instance of the API class
api_instance = openapi_client.RestUserControllerApi()
createUserRequest =  # CreateUserRequest |  (default to null)

try:
    # Register new user
    api_response = api_instance.register_new_user(createUserRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling RestUserControllerApi->registerNewUser: %s\n" % e)

extern crate RestUserControllerApi;

pub fn main() {
    let createUserRequest = ; // CreateUserRequest

    let mut context = RestUserControllerApi::Context::default();
    let result = client.registerNewUser(createUserRequest, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Query parameters

Name	Description
createUserRequest*	CreateUserRequest Required

Responses

Schema

registerNewUser1

/api/v1/users

Usage and SDK Samples

curl -X POST \
 -H "Accept: application/json" \
 "http://localhost:8443/api/v1/users?createUserRequest="

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.RestUserControllerApi;

import java.io.File;
import java.util.*;

public class RestUserControllerApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        RestUserControllerApi apiInstance = new RestUserControllerApi();
        CreateUserRequest createUserRequest = ; // CreateUserRequest | 

        try {
            PrivateUserDTO result = apiInstance.registerNewUser1(createUserRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling RestUserControllerApi#registerNewUser1");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final CreateUserRequest createUserRequest = new CreateUserRequest(); // CreateUserRequest | 

try {
    final result = await api_instance.registerNewUser1(createUserRequest);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->registerNewUser1: $e\n');
}

import org.openapitools.client.api.RestUserControllerApi;

public class RestUserControllerApiExample {
    public static void main(String[] args) {
        RestUserControllerApi apiInstance = new RestUserControllerApi();
        CreateUserRequest createUserRequest = ; // CreateUserRequest | 

        try {
            PrivateUserDTO result = apiInstance.registerNewUser1(createUserRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling RestUserControllerApi#registerNewUser1");
            e.printStackTrace();
        }
    }
}



// Create an instance of the API class
RestUserControllerApi *apiInstance = [[RestUserControllerApi alloc] init];
CreateUserRequest *createUserRequest = ; //  (default to null)

// Register new user
[apiInstance registerNewUser1With:createUserRequest
              completionHandler: ^(PrivateUserDTO output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenApiDefinition = require('open_api_definition');

// Create an instance of the API class
var api = new OpenApiDefinition.RestUserControllerApi()
var createUserRequest = ; // {CreateUserRequest} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.registerNewUser1(createUserRequest, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class registerNewUser1Example
    {
        public void main()
        {

            // Create an instance of the API class
            var apiInstance = new RestUserControllerApi();
            var createUserRequest = new CreateUserRequest(); // CreateUserRequest |  (default to null)

            try {
                // Register new user
                PrivateUserDTO result = apiInstance.registerNewUser1(createUserRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling RestUserControllerApi.registerNewUser1: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\RestUserControllerApi();
$createUserRequest = ; // CreateUserRequest | 

try {
    $result = $api_instance->registerNewUser1($createUserRequest);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling RestUserControllerApi->registerNewUser1: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::RestUserControllerApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::RestUserControllerApi->new();
my $createUserRequest = ; # CreateUserRequest | 

eval {
    my $result = $api_instance->registerNewUser1(createUserRequest => $createUserRequest);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling RestUserControllerApi->registerNewUser1: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Create an instance of the API class
api_instance = openapi_client.RestUserControllerApi()
createUserRequest =  # CreateUserRequest |  (default to null)

try:
    # Register new user
    api_response = api_instance.register_new_user1(createUserRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling RestUserControllerApi->registerNewUser1: %s\n" % e)

extern crate RestUserControllerApi;

pub fn main() {
    let createUserRequest = ; // CreateUserRequest

    let mut context = RestUserControllerApi::Context::default();
    let result = client.registerNewUser1(createUserRequest, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Query parameters

Name	Description
createUserRequest*	CreateUserRequest Required

Responses

Schema

uploadAvatar

Upload avatar for logged user

/api/v1/users/{id}/avatar

Usage and SDK Samples

curl -X POST \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "http://localhost:8443/api/v1/users/{id}/avatar" \
 -d ''

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.RestUserControllerApi;

import java.io.File;
import java.util.*;

public class RestUserControllerApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        RestUserControllerApi apiInstance = new RestUserControllerApi();
        Long id = 789; // Long | 
        ModifyAvatarRequest modifyAvatarRequest = ; // ModifyAvatarRequest | 

        try {
            PublicUserDTO result = apiInstance.uploadAvatar(id, modifyAvatarRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling RestUserControllerApi#uploadAvatar");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final Long id = new Long(); // Long | 
final ModifyAvatarRequest modifyAvatarRequest = new ModifyAvatarRequest(); // ModifyAvatarRequest | 

try {
    final result = await api_instance.uploadAvatar(id, modifyAvatarRequest);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->uploadAvatar: $e\n');
}

import org.openapitools.client.api.RestUserControllerApi;

public class RestUserControllerApiExample {
    public static void main(String[] args) {
        RestUserControllerApi apiInstance = new RestUserControllerApi();
        Long id = 789; // Long | 
        ModifyAvatarRequest modifyAvatarRequest = ; // ModifyAvatarRequest | 

        try {
            PublicUserDTO result = apiInstance.uploadAvatar(id, modifyAvatarRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling RestUserControllerApi#uploadAvatar");
            e.printStackTrace();
        }
    }
}



// Create an instance of the API class
RestUserControllerApi *apiInstance = [[RestUserControllerApi alloc] init];
Long *id = 789; //  (default to null)
ModifyAvatarRequest *modifyAvatarRequest = ; //  (optional)

// Upload avatar for logged user
[apiInstance uploadAvatarWith:id
    modifyAvatarRequest:modifyAvatarRequest
              completionHandler: ^(PublicUserDTO output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenApiDefinition = require('open_api_definition');

// Create an instance of the API class
var api = new OpenApiDefinition.RestUserControllerApi()
var id = 789; // {Long} 
var opts = {
  'modifyAvatarRequest':  // {ModifyAvatarRequest} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.uploadAvatar(id, opts, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class uploadAvatarExample
    {
        public void main()
        {

            // Create an instance of the API class
            var apiInstance = new RestUserControllerApi();
            var id = 789;  // Long |  (default to null)
            var modifyAvatarRequest = new ModifyAvatarRequest(); // ModifyAvatarRequest |  (optional) 

            try {
                // Upload avatar for logged user
                PublicUserDTO result = apiInstance.uploadAvatar(id, modifyAvatarRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling RestUserControllerApi.uploadAvatar: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\RestUserControllerApi();
$id = 789; // Long | 
$modifyAvatarRequest = ; // ModifyAvatarRequest | 

try {
    $result = $api_instance->uploadAvatar($id, $modifyAvatarRequest);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling RestUserControllerApi->uploadAvatar: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::RestUserControllerApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::RestUserControllerApi->new();
my $id = 789; # Long | 
my $modifyAvatarRequest = WWW::OPenAPIClient::Object::ModifyAvatarRequest->new(); # ModifyAvatarRequest | 

eval {
    my $result = $api_instance->uploadAvatar(id => $id, modifyAvatarRequest => $modifyAvatarRequest);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling RestUserControllerApi->uploadAvatar: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Create an instance of the API class
api_instance = openapi_client.RestUserControllerApi()
id = 789 # Long |  (default to null)
modifyAvatarRequest =  # ModifyAvatarRequest |  (optional)

try:
    # Upload avatar for logged user
    api_response = api_instance.upload_avatar(id, modifyAvatarRequest=modifyAvatarRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling RestUserControllerApi->uploadAvatar: %s\n" % e)

extern crate RestUserControllerApi;

pub fn main() {
    let id = 789; // Long
    let modifyAvatarRequest = ; // ModifyAvatarRequest

    let mut context = RestUserControllerApi::Context::default();
    let result = client.uploadAvatar(id, modifyAvatarRequest, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters

Name	Description
id*	Long (int64) Required

Body parameters

Name	Description
modifyAvatarRequest

Responses

Schema

OpenAPI definition

API and SDK Documentation

RestCommentsController

createComment

Usage and SDK Samples

Scopes

Parameters

Responses

createComment1

Usage and SDK Samples

Scopes

Parameters

Responses

deleteComment

Usage and SDK Samples

Scopes

Parameters

Responses

getComment

Usage and SDK Samples

Scopes

Parameters

Responses

getComments

Usage and SDK Samples

Scopes

Parameters

Responses

getComments1

Usage and SDK Samples

Scopes

Parameters

Responses

updateComment

Usage and SDK Samples

Scopes

Parameters

Responses

RestLoginController

logOut

Usage and SDK Samples

Scopes

Parameters

Responses

login

Usage and SDK Samples

Scopes

Parameters

Responses

refreshToken

Usage and SDK Samples

Scopes

Parameters

Responses

RestPostsController

createPost

Usage and SDK Samples

Scopes

Parameters

Responses

createPost1

Usage and SDK Samples

Scopes

Parameters

Responses

deletePost

Usage and SDK Samples

Scopes

Parameters

Responses

deletePostBanner

Usage and SDK Samples

Scopes

Parameters

Responses

getPost

Usage and SDK Samples

Scopes

Parameters

Responses