OpenAPI definition

AdministrationController

topEventsParticipants

/admin/api/top-events-participants

Usage and SDK Samples

curl -X GET \
 -H "Accept: */*" \
 "http://127.0.0.1:8443/admin/api/top-events-participants?limit=56"

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

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

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

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

        try {
            array[EventParticipantsStatDTO] result = apiInstance.topEventsParticipants(limit);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AdministrationControllerApi#topEventsParticipants");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

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

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

import org.openapitools.client.api.AdministrationControllerApi;

public class AdministrationControllerApiExample {
    public static void main(String[] args) {
        AdministrationControllerApi apiInstance = new AdministrationControllerApi();
        Integer limit = 56; // Integer | 

        try {
            array[EventParticipantsStatDTO] result = apiInstance.topEventsParticipants(limit);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AdministrationControllerApi#topEventsParticipants");
            e.printStackTrace();
        }
    }
}



// Create an instance of the API class
AdministrationControllerApi *apiInstance = [[AdministrationControllerApi alloc] init];
Integer *limit = 56; //  (optional) (default to 10)

[apiInstance topEventsParticipantsWith:limit
              completionHandler: ^(array[EventParticipantsStatDTO] 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.AdministrationControllerApi()
var opts = {
  'limit': 56 // {Integer} 
};

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

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

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

            // Create an instance of the API class
            var apiInstance = new AdministrationControllerApi();
            var limit = 56;  // Integer |  (optional)  (default to 10)

            try {
                array[EventParticipantsStatDTO] result = apiInstance.topEventsParticipants(limit);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling AdministrationControllerApi.topEventsParticipants: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

eval {
    my $result = $api_instance->topEventsParticipants(limit => $limit);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AdministrationControllerApi->topEventsParticipants: $@\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.AdministrationControllerApi()
limit = 56 # Integer |  (optional) (default to 10)

try:
    api_response = api_instance.top_events_participants(limit=limit)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AdministrationControllerApi->topEventsParticipants: %s\n" % e)

extern crate AdministrationControllerApi;

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

    let mut context = AdministrationControllerApi::Context::default();
    let result = client.topEventsParticipants(limit, &context).wait();

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

Scopes

Parameters

Query parameters

Name	Description
limit	Integer (int32)

Responses

Schema

topFavoriteGames

/admin/api/top-favorite-games

Usage and SDK Samples

curl -X GET \
 -H "Accept: */*" \
 "http://127.0.0.1:8443/admin/api/top-favorite-games?limit=56"

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

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

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

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

        try {
            array[GameFavStatDTO] result = apiInstance.topFavoriteGames(limit);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AdministrationControllerApi#topFavoriteGames");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

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

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

import org.openapitools.client.api.AdministrationControllerApi;

public class AdministrationControllerApiExample {
    public static void main(String[] args) {
        AdministrationControllerApi apiInstance = new AdministrationControllerApi();
        Integer limit = 56; // Integer | 

        try {
            array[GameFavStatDTO] result = apiInstance.topFavoriteGames(limit);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling AdministrationControllerApi#topFavoriteGames");
            e.printStackTrace();
        }
    }
}



// Create an instance of the API class
AdministrationControllerApi *apiInstance = [[AdministrationControllerApi alloc] init];
Integer *limit = 56; //  (optional) (default to 10)

[apiInstance topFavoriteGamesWith:limit
              completionHandler: ^(array[GameFavStatDTO] 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.AdministrationControllerApi()
var opts = {
  'limit': 56 // {Integer} 
};

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

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

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

            // Create an instance of the API class
            var apiInstance = new AdministrationControllerApi();
            var limit = 56;  // Integer |  (optional)  (default to 10)

            try {
                array[GameFavStatDTO] result = apiInstance.topFavoriteGames(limit);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling AdministrationControllerApi.topFavoriteGames: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

eval {
    my $result = $api_instance->topFavoriteGames(limit => $limit);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling AdministrationControllerApi->topFavoriteGames: $@\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.AdministrationControllerApi()
limit = 56 # Integer |  (optional) (default to 10)

try:
    api_response = api_instance.top_favorite_games(limit=limit)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AdministrationControllerApi->topFavoriteGames: %s\n" % e)

extern crate AdministrationControllerApi;

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

    let mut context = AdministrationControllerApi::Context::default();
    let result = client.topFavoriteGames(limit, &context).wait();

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

Scopes

Parameters

Query parameters

Name	Description
limit	Integer (int32)

Responses

Schema

AdministrationRestController

approveEvent

/api/v1/admin/events/{id}

Usage and SDK Samples

curl -X PUT \
 "http://127.0.0.1:8443/api/v1/admin/events/{id}"

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

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

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

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

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

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

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

import org.openapitools.client.api.AdministrationRestControllerApi;

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

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



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

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

var OpenApiDefinition = require('open_api_definition');

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

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

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

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

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

            try {
                apiInstance.approveEvent(id);
            } catch (Exception e) {
                Debug.Print("Exception when calling AdministrationRestControllerApi.approveEvent: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

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

try:
    api_instance.approve_event(id)
except ApiException as e:
    print("Exception when calling AdministrationRestControllerApi->approveEvent: %s\n" % e)

extern crate AdministrationRestControllerApi;

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

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

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

Scopes

Parameters

Path parameters

Name	Description
id*	Long (int64) Required

Responses

approveNew

/api/v1/admin/news/{id}

Usage and SDK Samples

curl -X PUT \
 "http://127.0.0.1:8443/api/v1/admin/news/{id}"

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

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

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

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

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

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

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

import org.openapitools.client.api.AdministrationRestControllerApi;

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

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



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

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

var OpenApiDefinition = require('open_api_definition');

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

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

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

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

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

            try {
                apiInstance.approveNew(id);
            } catch (Exception e) {
                Debug.Print("Exception when calling AdministrationRestControllerApi.approveNew: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

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

try:
    api_instance.approve_new(id)
except ApiException as e:
    print("Exception when calling AdministrationRestControllerApi->approveNew: %s\n" % e)

extern crate AdministrationRestControllerApi;

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

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

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

Scopes

Parameters

Path parameters

Name	Description
id*	Long (int64) Required

Responses

getTopEvents

/api/v1/admin/top-events-participants

Usage and SDK Samples

curl -X GET \
 -H "Accept: */*" \
 "http://127.0.0.1:8443/api/v1/admin/top-events-participants"

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

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

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

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

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();


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

import org.openapitools.client.api.AdministrationRestControllerApi;

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

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



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

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

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

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

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

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

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

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

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

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

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

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

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

extern crate AdministrationRestControllerApi;

pub fn main() {

    let mut context = AdministrationRestControllerApi::Context::default();
    let result = client.getTopEvents(&context).wait();

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

Scopes

Parameters

Responses

Schema

getTopGames

/api/v1/admin/top-favorite-games

Usage and SDK Samples

curl -X GET \
 -H "Accept: */*" \
 "http://127.0.0.1:8443/api/v1/admin/top-favorite-games"

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

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

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

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

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();


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

import org.openapitools.client.api.AdministrationRestControllerApi;

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

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



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

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

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

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

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

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

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

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

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

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

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

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

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

extern crate AdministrationRestControllerApi;

pub fn main() {

    let mut context = AdministrationRestControllerApi::Context::default();
    let result = client.getTopGames(&context).wait();

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

Scopes

Parameters

Responses

Schema

rejectEvent

/api/v1/admin/events/{id}

Usage and SDK Samples

curl -X DELETE \
 "http://127.0.0.1:8443/api/v1/admin/events/{id}"

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

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

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

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

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

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

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

import org.openapitools.client.api.AdministrationRestControllerApi;

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

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



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

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

var OpenApiDefinition = require('open_api_definition');

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

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

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

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

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

            try {
                apiInstance.rejectEvent(id);
            } catch (Exception e) {
                Debug.Print("Exception when calling AdministrationRestControllerApi.rejectEvent: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

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

try:
    api_instance.reject_event(id)
except ApiException as e:
    print("Exception when calling AdministrationRestControllerApi->rejectEvent: %s\n" % e)

extern crate AdministrationRestControllerApi;

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

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

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

Scopes

Parameters

Path parameters

Name	Description
id*	Long (int64) Required

Responses

rejectNew

/api/v1/admin/news/{id}

Usage and SDK Samples

curl -X DELETE \
 "http://127.0.0.1:8443/api/v1/admin/news/{id}"

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

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

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

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

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

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

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

import org.openapitools.client.api.AdministrationRestControllerApi;

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

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



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

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

var OpenApiDefinition = require('open_api_definition');

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

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

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

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

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

            try {
                apiInstance.rejectNew(id);
            } catch (Exception e) {
                Debug.Print("Exception when calling AdministrationRestControllerApi.rejectNew: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

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

try:
    api_instance.reject_new(id)
except ApiException as e:
    print("Exception when calling AdministrationRestControllerApi->rejectNew: %s\n" % e)

extern crate AdministrationRestControllerApi;

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

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

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

Scopes

Parameters

Path parameters

Name	Description
id*	Long (int64) Required

Responses

CustomErrorRestController

handleError

/error

Usage and SDK Samples

curl -X GET \
 -H "Accept: application/json" \
 "http://127.0.0.1:8443/error"

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

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

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

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

        try {
            ErrorDTO result = apiInstance.handleError();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CustomErrorRestControllerApi#handleError");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();


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

import org.openapitools.client.api.CustomErrorRestControllerApi;

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

        try {
            ErrorDTO result = apiInstance.handleError();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CustomErrorRestControllerApi#handleError");
            e.printStackTrace();
        }
    }
}



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

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

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

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

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

            try {
                ErrorDTO result = apiInstance.handleError();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling CustomErrorRestControllerApi.handleError: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

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

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

extern crate CustomErrorRestControllerApi;

pub fn main() {

    let mut context = CustomErrorRestControllerApi::Context::default();
    let result = client.handleError(&context).wait();

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

Scopes

Parameters

Responses

Schema

handleError1

/error

Usage and SDK Samples

curl -X POST \
 -H "Accept: application/json" \
 "http://127.0.0.1:8443/error"

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

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

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

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

        try {
            ErrorDTO result = apiInstance.handleError1();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CustomErrorRestControllerApi#handleError1");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();


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

import org.openapitools.client.api.CustomErrorRestControllerApi;

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

        try {
            ErrorDTO result = apiInstance.handleError1();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CustomErrorRestControllerApi#handleError1");
            e.printStackTrace();
        }
    }
}



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

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

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

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

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

            try {
                ErrorDTO result = apiInstance.handleError1();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling CustomErrorRestControllerApi.handleError1: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

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

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

extern crate CustomErrorRestControllerApi;

pub fn main() {

    let mut context = CustomErrorRestControllerApi::Context::default();
    let result = client.handleError1(&context).wait();

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

Scopes

Parameters

Responses

Schema

handleError2

/error

Usage and SDK Samples

curl -X PUT \
 -H "Accept: application/json" \
 "http://127.0.0.1:8443/error"

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

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

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

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

        try {
            ErrorDTO result = apiInstance.handleError2();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CustomErrorRestControllerApi#handleError2");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();


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

import org.openapitools.client.api.CustomErrorRestControllerApi;

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

        try {
            ErrorDTO result = apiInstance.handleError2();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CustomErrorRestControllerApi#handleError2");
            e.printStackTrace();
        }
    }
}



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

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

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

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

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

            try {
                ErrorDTO result = apiInstance.handleError2();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling CustomErrorRestControllerApi.handleError2: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

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

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

extern crate CustomErrorRestControllerApi;

pub fn main() {

    let mut context = CustomErrorRestControllerApi::Context::default();
    let result = client.handleError2(&context).wait();

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

Scopes

Parameters

Responses

Schema

handleError3

/error

Usage and SDK Samples

curl -X DELETE \
 -H "Accept: application/json" \
 "http://127.0.0.1:8443/error"

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

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

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

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

        try {
            ErrorDTO result = apiInstance.handleError3();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CustomErrorRestControllerApi#handleError3");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();


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

import org.openapitools.client.api.CustomErrorRestControllerApi;

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

        try {
            ErrorDTO result = apiInstance.handleError3();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CustomErrorRestControllerApi#handleError3");
            e.printStackTrace();
        }
    }
}



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

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

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

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

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

            try {
                ErrorDTO result = apiInstance.handleError3();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling CustomErrorRestControllerApi.handleError3: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

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

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

extern crate CustomErrorRestControllerApi;

pub fn main() {

    let mut context = CustomErrorRestControllerApi::Context::default();
    let result = client.handleError3(&context).wait();

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

Scopes

Parameters

Responses

Schema

handleError4

/error

Usage and SDK Samples

curl -X PATCH \
 -H "Accept: application/json" \
 "http://127.0.0.1:8443/error"

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

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

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

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

        try {
            ErrorDTO result = apiInstance.handleError4();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CustomErrorRestControllerApi#handleError4");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();


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

import org.openapitools.client.api.CustomErrorRestControllerApi;

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

        try {
            ErrorDTO result = apiInstance.handleError4();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CustomErrorRestControllerApi#handleError4");
            e.printStackTrace();
        }
    }
}



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

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

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

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

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

            try {
                ErrorDTO result = apiInstance.handleError4();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling CustomErrorRestControllerApi.handleError4: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

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

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

extern crate CustomErrorRestControllerApi;

pub fn main() {

    let mut context = CustomErrorRestControllerApi::Context::default();
    let result = client.handleError4(&context).wait();

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

Scopes

Parameters

Responses

Schema

handleError5

/error

Usage and SDK Samples

curl -X HEAD \
 -H "Accept: application/json" \
 "http://127.0.0.1:8443/error"

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

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

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

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

        try {
            ErrorDTO result = apiInstance.handleError5();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CustomErrorRestControllerApi#handleError5");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();


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

import org.openapitools.client.api.CustomErrorRestControllerApi;

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

        try {
            ErrorDTO result = apiInstance.handleError5();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CustomErrorRestControllerApi#handleError5");
            e.printStackTrace();
        }
    }
}



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

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

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

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

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

            try {
                ErrorDTO result = apiInstance.handleError5();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling CustomErrorRestControllerApi.handleError5: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

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

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

extern crate CustomErrorRestControllerApi;

pub fn main() {

    let mut context = CustomErrorRestControllerApi::Context::default();
    let result = client.handleError5(&context).wait();

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

Scopes

Parameters

Responses

Schema

handleError6

/error

Usage and SDK Samples

curl -X OPTIONS \
 -H "Accept: application/json" \
 "http://127.0.0.1:8443/error"

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

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

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

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

        try {
            ErrorDTO result = apiInstance.handleError6();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CustomErrorRestControllerApi#handleError6");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();


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

import org.openapitools.client.api.CustomErrorRestControllerApi;

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

        try {
            ErrorDTO result = apiInstance.handleError6();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling CustomErrorRestControllerApi#handleError6");
            e.printStackTrace();
        }
    }
}



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

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

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

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

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

            try {
                ErrorDTO result = apiInstance.handleError6();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling CustomErrorRestControllerApi.handleError6: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

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

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

extern crate CustomErrorRestControllerApi;

pub fn main() {

    let mut context = CustomErrorRestControllerApi::Context::default();
    let result = client.handleError6(&context).wait();

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

Scopes

Parameters

Responses

Schema

EventsRestController

createEvent

/api/v1/events

Usage and SDK Samples

curl -X POST \
 -H "Accept: */*" \
 -H "Content-Type: application/json" \
 "http://127.0.0.1:8443/api/v1/events" \
 -d '{
  "eventId" : 0,
  "requiresRegistration" : true,
  "eventCreator" : {
    "userNickname" : "userNickname",
    "userEmail" : "userEmail",
    "userId" : 6
  },
  "link" : "link",
  "creationDate" : "2000-01-23T04:56:07.000+00:00",
  "maxParticipants" : 6,
  "eventNews" : [ {
    "newName" : "newName",
    "newId" : 3
  }, {
    "newName" : "newName",
    "newId" : 3
  } ],
  "eventImage" : {
    "id" : 6
  },
  "eventTag" : "eventTag",
  "validated" : true,
  "eventDescription" : "eventDescription",
  "eventName" : "eventName",
  "eventDate" : "2000-01-23",
  "participants" : [ {
    "userNickname" : "userNickname",
    "userEmail" : "userEmail",
    "userId" : 6
  }, {
    "userNickname" : "userNickname",
    "userEmail" : "userEmail",
    "userId" : 6
  } ]
}'

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

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

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

        // Create an instance of the API class
        EventsRestControllerApi apiInstance = new EventsRestControllerApi();
        EventDTO eventDTO = ; // EventDTO | 

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final EventDTO eventDTO = new EventDTO(); // EventDTO | 

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

import org.openapitools.client.api.EventsRestControllerApi;

public class EventsRestControllerApiExample {
    public static void main(String[] args) {
        EventsRestControllerApi apiInstance = new EventsRestControllerApi();
        EventDTO eventDTO = ; // EventDTO | 

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



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

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

var OpenApiDefinition = require('open_api_definition');

// Create an instance of the API class
var api = new OpenApiDefinition.EventsRestControllerApi()
var eventDTO = ; // {EventDTO} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new EventsRestControllerApi();
            var eventDTO = new EventDTO(); // EventDTO | 

            try {
                Object result = apiInstance.createEvent(eventDTO);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling EventsRestControllerApi.createEvent: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\EventsRestControllerApi();
$eventDTO = ; // EventDTO | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::EventsRestControllerApi->new();
my $eventDTO = WWW::OPenAPIClient::Object::EventDTO->new(); # EventDTO | 

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

try:
    api_response = api_instance.create_event(eventDTO)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling EventsRestControllerApi->createEvent: %s\n" % e)

extern crate EventsRestControllerApi;

pub fn main() {
    let eventDTO = ; // EventDTO

    let mut context = EventsRestControllerApi::Context::default();
    let result = client.createEvent(eventDTO, &context).wait();

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

Scopes

Parameters

Body parameters

Name	Description
eventDTO *

Responses

Schema

createEventImage

/api/v1/events/{id}/images

Usage and SDK Samples

curl -X POST \
 -H "Accept: */*" \
 -H "Content-Type: application/json" \
 "http://127.0.0.1:8443/api/v1/events/{id}/images" \
 -d ''

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

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

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

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

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

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

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

import org.openapitools.client.api.EventsRestControllerApi;

public class EventsRestControllerApiExample {
    public static void main(String[] args) {
        EventsRestControllerApi apiInstance = new EventsRestControllerApi();
        Long id = 789; // Long | 
        UpdateNewImageRequest updateNewImageRequest = ; // UpdateNewImageRequest | 

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



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

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

var OpenApiDefinition = require('open_api_definition');

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

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

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

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

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

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

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

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

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

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

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

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

try:
    api_response = api_instance.create_event_image(id, updateNewImageRequest=updateNewImageRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling EventsRestControllerApi->createEventImage: %s\n" % e)

extern crate EventsRestControllerApi;

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

    let mut context = EventsRestControllerApi::Context::default();
    let result = client.createEventImage(id, updateNewImageRequest, &context).wait();

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

Scopes

Parameters

Path parameters

Name	Description
id*	Long (int64) Required

Body parameters

Name	Description
updateNewImageRequest

Responses

Schema

deleteEvent

/api/v1/events/{id}

Usage and SDK Samples

curl -X DELETE \
 -H "Accept: */*" \
 "http://127.0.0.1:8443/api/v1/events/{id}"

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

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

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

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

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

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

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

import org.openapitools.client.api.EventsRestControllerApi;

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

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



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

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

var OpenApiDefinition = require('open_api_definition');

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

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

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

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

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

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

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

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

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

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

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

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

extern crate EventsRestControllerApi;

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

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

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

Scopes

Parameters

Path parameters

Name	Description
id*	Long (int64) Required

Responses

Schema

deleteEventImage

/api/v1/events/{eventId}/images/{imageId}

Usage and SDK Samples

curl -X DELETE \
 -H "Accept: */*" \
 "http://127.0.0.1:8443/api/v1/events/{eventId}/images/{imageId}"

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

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

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

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

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

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

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

import org.openapitools.client.api.EventsRestControllerApi;

public class EventsRestControllerApiExample {
    public static void main(String[] args) {
        EventsRestControllerApi apiInstance = new EventsRestControllerApi();
        Long eventId = 789; // Long | 
        Long imageId = 789; // Long | 

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



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

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

var OpenApiDefinition = require('open_api_definition');

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

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

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

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

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

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

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

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

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

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

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

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

try:
    api_response = api_instance.delete_event_image(eventId, imageId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling EventsRestControllerApi->deleteEventImage: %s\n" % e)

extern crate EventsRestControllerApi;

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

    let mut context = EventsRestControllerApi::Context::default();
    let result = client.deleteEventImage(eventId, imageId, &context).wait();

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

Scopes

Parameters

Path parameters

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

Responses

Schema

findByFilter2

/api/v1/events

Usage and SDK Samples

curl -X GET \
 -H "Accept: */*" \
 "http://127.0.0.1:8443/api/v1/events?name=name_example&tag=tag_example&pageable="

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

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

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

        // Create an instance of the API class
        EventsRestControllerApi apiInstance = new EventsRestControllerApi();
        Pageable pageable = ; // Pageable | 
        String name = name_example; // String | 
        String tag = tag_example; // String | 

        try {
            PagedModelObject result = apiInstance.findByFilter2(pageable, name, tag);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling EventsRestControllerApi#findByFilter2");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final Pageable pageable = new Pageable(); // Pageable | 
final String name = new String(); // String | 
final String tag = new String(); // String | 

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

import org.openapitools.client.api.EventsRestControllerApi;

public class EventsRestControllerApiExample {
    public static void main(String[] args) {
        EventsRestControllerApi apiInstance = new EventsRestControllerApi();
        Pageable pageable = ; // Pageable | 
        String name = name_example; // String | 
        String tag = tag_example; // String | 

        try {
            PagedModelObject result = apiInstance.findByFilter2(pageable, name, tag);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling EventsRestControllerApi#findByFilter2");
            e.printStackTrace();
        }
    }
}



// Create an instance of the API class
EventsRestControllerApi *apiInstance = [[EventsRestControllerApi alloc] init];
Pageable *pageable = ; //  (default to null)
String *name = name_example; //  (optional) (default to null)
String *tag = tag_example; //  (optional) (default to null)

[apiInstance findByFilter2With:pageable
    name:name
    tag:tag
              completionHandler: ^(PagedModelObject 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.EventsRestControllerApi()
var pageable = ; // {Pageable} 
var opts = {
  'name': name_example, // {String} 
  'tag': tag_example // {String} 
};

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

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

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

            // Create an instance of the API class
            var apiInstance = new EventsRestControllerApi();
            var pageable = new Pageable(); // Pageable |  (default to null)
            var name = name_example;  // String |  (optional)  (default to null)
            var tag = tag_example;  // String |  (optional)  (default to null)

            try {
                PagedModelObject result = apiInstance.findByFilter2(pageable, name, tag);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling EventsRestControllerApi.findByFilter2: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\EventsRestControllerApi();
$pageable = ; // Pageable | 
$name = name_example; // String | 
$tag = tag_example; // String | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::EventsRestControllerApi->new();
my $pageable = ; # Pageable | 
my $name = name_example; # String | 
my $tag = tag_example; # String | 

eval {
    my $result = $api_instance->findByFilter2(pageable => $pageable, name => $name, tag => $tag);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling EventsRestControllerApi->findByFilter2: $@\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.EventsRestControllerApi()
pageable =  # Pageable |  (default to null)
name = name_example # String |  (optional) (default to null)
tag = tag_example # String |  (optional) (default to null)

try:
    api_response = api_instance.find_by_filter2(pageable, name=name, tag=tag)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling EventsRestControllerApi->findByFilter2: %s\n" % e)

extern crate EventsRestControllerApi;

pub fn main() {
    let pageable = ; // Pageable
    let name = name_example; // String
    let tag = tag_example; // String

    let mut context = EventsRestControllerApi::Context::default();
    let result = client.findByFilter2(pageable, name, tag, &context).wait();

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

Scopes

Parameters

Query parameters

Name	Description
name	String
tag	String
pageable*	Pageable Required

Responses

Schema

getEvent

/api/v1/events/{id}

Usage and SDK Samples

curl -X GET \
 -H "Accept: */*" \
 "http://127.0.0.1:8443/api/v1/events/{id}"

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

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

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

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

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

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

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

import org.openapitools.client.api.EventsRestControllerApi;

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

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



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

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

var OpenApiDefinition = require('open_api_definition');

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

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

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

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

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

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

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

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

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

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

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

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

extern crate EventsRestControllerApi;

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

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

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

Scopes

Parameters

Path parameters

Name	Description
id*	Long (int64) Required

Responses

Schema

joinEvent

/api/v1/events/{eventId}/participants

Usage and SDK Samples

curl -X POST \
 -H "Accept: */*" \
 "http://127.0.0.1:8443/api/v1/events/{eventId}/participants"

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

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

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

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

        try {
            EventDTO result = apiInstance.joinEvent(eventId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling EventsRestControllerApi#joinEvent");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

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

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

import org.openapitools.client.api.EventsRestControllerApi;

public class EventsRestControllerApiExample {
    public static void main(String[] args) {
        EventsRestControllerApi apiInstance = new EventsRestControllerApi();
        Long eventId = 789; // Long | 

        try {
            EventDTO result = apiInstance.joinEvent(eventId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling EventsRestControllerApi#joinEvent");
            e.printStackTrace();
        }
    }
}



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

[apiInstance joinEventWith:eventId
              completionHandler: ^(EventDTO 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.EventsRestControllerApi()
var eventId = 789; // {Long} 

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

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

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

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

            try {
                EventDTO result = apiInstance.joinEvent(eventId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling EventsRestControllerApi.joinEvent: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

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

try:
    api_response = api_instance.join_event(eventId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling EventsRestControllerApi->joinEvent: %s\n" % e)

extern crate EventsRestControllerApi;

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

    let mut context = EventsRestControllerApi::Context::default();
    let result = client.joinEvent(eventId, &context).wait();

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

Scopes

Parameters

Path parameters

Name	Description
eventId*	Long (int64) Required

Responses

Schema

leaveEvent

/api/v1/events/{eventId}/participants

Usage and SDK Samples

curl -X DELETE \
 -H "Accept: */*" \
 "http://127.0.0.1:8443/api/v1/events/{eventId}/participants"

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

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

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

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

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

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

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

import org.openapitools.client.api.EventsRestControllerApi;

public class EventsRestControllerApiExample {
    public static void main(String[] args) {
        EventsRestControllerApi apiInstance = new EventsRestControllerApi();
        Long eventId = 789; // Long | 

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



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

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

var OpenApiDefinition = require('open_api_definition');

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

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

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

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

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

            try {
                Object result = apiInstance.leaveEvent(eventId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling EventsRestControllerApi.leaveEvent: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

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

try:
    api_response = api_instance.leave_event(eventId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling EventsRestControllerApi->leaveEvent: %s\n" % e)

extern crate EventsRestControllerApi;

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

    let mut context = EventsRestControllerApi::Context::default();
    let result = client.leaveEvent(eventId, &context).wait();

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

Scopes

Parameters

Path parameters

Name	Description
eventId*	Long (int64) Required

Responses

Schema

replaceEvent

/api/v1/events/{id}

Usage and SDK Samples

curl -X PUT \
 -H "Accept: */*" \
 -H "Content-Type: application/json" \
 "http://127.0.0.1:8443/api/v1/events/{id}" \
 -d '{
  "eventId" : 0,
  "requiresRegistration" : true,
  "eventCreator" : {
    "userNickname" : "userNickname",
    "userEmail" : "userEmail",
    "userId" : 6
  },
  "link" : "link",
  "creationDate" : "2000-01-23T04:56:07.000+00:00",
  "maxParticipants" : 6,
  "eventNews" : [ {
    "newName" : "newName",
    "newId" : 3
  }, {
    "newName" : "newName",
    "newId" : 3
  } ],
  "eventImage" : {
    "id" : 6
  },
  "eventTag" : "eventTag",
  "validated" : true,
  "eventDescription" : "eventDescription",
  "eventName" : "eventName",
  "eventDate" : "2000-01-23",
  "participants" : [ {
    "userNickname" : "userNickname",
    "userEmail" : "userEmail",
    "userId" : 6
  }, {
    "userNickname" : "userNickname",
    "userEmail" : "userEmail",
    "userId" : 6
  } ]
}'

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

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

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

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

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

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

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

import org.openapitools.client.api.EventsRestControllerApi;

public class EventsRestControllerApiExample {
    public static void main(String[] args) {
        EventsRestControllerApi apiInstance = new EventsRestControllerApi();
        Long id = 789; // Long | 
        EventDTO eventDTO = ; // EventDTO | 

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



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

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

var OpenApiDefinition = require('open_api_definition');

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

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

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

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

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

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

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

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

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

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

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

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

try:
    api_response = api_instance.replace_event(id, eventDTO)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling EventsRestControllerApi->replaceEvent: %s\n" % e)

extern crate EventsRestControllerApi;

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

    let mut context = EventsRestControllerApi::Context::default();
    let result = client.replaceEvent(id, eventDTO, &context).wait();

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

Scopes

Parameters

Path parameters

Name	Description
id*	Long (int64) Required

Body parameters

Name	Description
eventDTO *

Responses

Schema

updateEventImage

/api/v1/events/{id}/images

Usage and SDK Samples

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

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

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

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

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

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

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

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

import org.openapitools.client.api.EventsRestControllerApi;

public class EventsRestControllerApiExample {
    public static void main(String[] args) {
        EventsRestControllerApi apiInstance = new EventsRestControllerApi();
        Long id = 789; // Long | 
        UpdateNewImageRequest updateNewImageRequest = ; // UpdateNewImageRequest | 

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



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

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

var OpenApiDefinition = require('open_api_definition');

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

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

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

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

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

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

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

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

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

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

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

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

try:
    api_response = api_instance.update_event_image(id, updateNewImageRequest=updateNewImageRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling EventsRestControllerApi->updateEventImage: %s\n" % e)

extern crate EventsRestControllerApi;

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

    let mut context = EventsRestControllerApi::Context::default();
    let result = client.updateEventImage(id, updateNewImageRequest, &context).wait();

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

Scopes

Parameters

Path parameters

Name	Description
id*	Long (int64) Required

Body parameters

Name	Description
updateNewImageRequest

Responses

Schema

GamesRestController

addFavorite

/api/v1/games/{id}/favourites

Usage and SDK Samples

curl -X POST \
 -H "Accept: */*" \
 "http://127.0.0.1:8443/api/v1/games/{id}/favourites"

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

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

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

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

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

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

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

import org.openapitools.client.api.GamesRestControllerApi;

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

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



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

[apiInstance addFavoriteWith:id
              completionHandler: ^(GameDTO 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.GamesRestControllerApi()
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.addFavorite(id, callback);

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

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

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

            try {
                GameDTO result = apiInstance.addFavorite(id);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling GamesRestControllerApi.addFavorite: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

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

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

extern crate GamesRestControllerApi;

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

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

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

Scopes

Parameters

Path parameters

Name	Description
id*	Long (int64) Required

Responses

Schema

createGame

/api/v1/games/

Usage and SDK Samples

curl -X POST \
 -H "Accept: */*" \
 -H "Content-Type: application/json" \
 "http://127.0.0.1:8443/api/v1/games/" \
 -d '{
  "gameId" : 5,
  "maxPlayers" : 2,
  "minDuration" : 7,
  "gameName" : "gameName",
  "minPlayers" : 5,
  "genre" : "genre",
  "gameDescription" : "gameDescription",
  "gameImage" : {
    "id" : 6
  },
  "maxDuration" : 9
}'

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

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

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

        // Create an instance of the API class
        GamesRestControllerApi apiInstance = new GamesRestControllerApi();
        GameDTO gameDTO = ; // GameDTO | 

        try {
            GameDTO result = apiInstance.createGame(gameDTO);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling GamesRestControllerApi#createGame");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final GameDTO gameDTO = new GameDTO(); // GameDTO | 

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

import org.openapitools.client.api.GamesRestControllerApi;

public class GamesRestControllerApiExample {
    public static void main(String[] args) {
        GamesRestControllerApi apiInstance = new GamesRestControllerApi();
        GameDTO gameDTO = ; // GameDTO | 

        try {
            GameDTO result = apiInstance.createGame(gameDTO);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling GamesRestControllerApi#createGame");
            e.printStackTrace();
        }
    }
}



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

[apiInstance createGameWith:gameDTO
              completionHandler: ^(GameDTO 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.GamesRestControllerApi()
var gameDTO = ; // {GameDTO} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new GamesRestControllerApi();
            var gameDTO = new GameDTO(); // GameDTO | 

            try {
                GameDTO result = apiInstance.createGame(gameDTO);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling GamesRestControllerApi.createGame: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\GamesRestControllerApi();
$gameDTO = ; // GameDTO | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::GamesRestControllerApi->new();
my $gameDTO = WWW::OPenAPIClient::Object::GameDTO->new(); # GameDTO | 

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

try:
    api_response = api_instance.create_game(gameDTO)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling GamesRestControllerApi->createGame: %s\n" % e)

extern crate GamesRestControllerApi;

pub fn main() {
    let gameDTO = ; // GameDTO

    let mut context = GamesRestControllerApi::Context::default();
    let result = client.createGame(gameDTO, &context).wait();

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

Scopes

Parameters

Body parameters

Name	Description
gameDTO *

Responses

Schema

createGameImage

/api/v1/games/{id}/images/

Usage and SDK Samples

curl -X POST \
 -H "Accept: */*" \
 -H "Content-Type: application/json" \
 "http://127.0.0.1:8443/api/v1/games/{id}/images/" \
 -d ''

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

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

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

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

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

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

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

import org.openapitools.client.api.GamesRestControllerApi;

public class GamesRestControllerApiExample {
    public static void main(String[] args) {
        GamesRestControllerApi apiInstance = new GamesRestControllerApi();
        Long id = 789; // Long | 
        UpdateNewImageRequest updateNewImageRequest = ; // UpdateNewImageRequest | 

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



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

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

var OpenApiDefinition = require('open_api_definition');

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

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

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

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

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

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

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

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

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

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

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

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

try:
    api_response = api_instance.create_game_image(id, updateNewImageRequest=updateNewImageRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling GamesRestControllerApi->createGameImage: %s\n" % e)

extern crate GamesRestControllerApi;

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

    let mut context = GamesRestControllerApi::Context::default();
    let result = client.createGameImage(id, updateNewImageRequest, &context).wait();

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

Scopes

Parameters

Path parameters

Name	Description
id*	Long (int64) Required

Body parameters

Name	Description
updateNewImageRequest

Responses

Schema

deleteGame

/api/v1/games/{id}

Usage and SDK Samples

curl -X DELETE \
 -H "Accept: */*" \
 "http://127.0.0.1:8443/api/v1/games/{id}"

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

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

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

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

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

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

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

import org.openapitools.client.api.GamesRestControllerApi;

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

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



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

[apiInstance deleteGameWith:id
              completionHandler: ^(GameDTO 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.GamesRestControllerApi()
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.deleteGame(id, callback);

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

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

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

            try {
                GameDTO result = apiInstance.deleteGame(id);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling GamesRestControllerApi.deleteGame: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

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

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

extern crate GamesRestControllerApi;

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

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

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

Scopes

Parameters

Path parameters

Name	Description
id*	Long (int64) Required

Responses

Schema

deleteGameImage

/api/v1/games/{gameId}/images/{imageId}

Usage and SDK Samples

curl -X DELETE \
 -H "Accept: */*" \
 "http://127.0.0.1:8443/api/v1/games/{gameId}/images/{imageId}"

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

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

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

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

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

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

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

import org.openapitools.client.api.GamesRestControllerApi;

public class GamesRestControllerApiExample {
    public static void main(String[] args) {
        GamesRestControllerApi apiInstance = new GamesRestControllerApi();
        Long gameId = 789; // Long | 
        Long imageId = 789; // Long | 

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



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

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

var OpenApiDefinition = require('open_api_definition');

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

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

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

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

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

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

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

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

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

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

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

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

try:
    api_response = api_instance.delete_game_image(gameId, imageId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling GamesRestControllerApi->deleteGameImage: %s\n" % e)

extern crate GamesRestControllerApi;

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

    let mut context = GamesRestControllerApi::Context::default();
    let result = client.deleteGameImage(gameId, imageId, &context).wait();

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

Scopes

Parameters

Path parameters

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

Responses

Schema

findByFilter1

/api/v1/games/

Usage and SDK Samples

curl -X GET \
 -H "Accept: */*" \
 "http://127.0.0.1:8443/api/v1/games/?name=name_example&tag=tag_example&players=56&duration=56&pageable="

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

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

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

        // Create an instance of the API class
        GamesRestControllerApi apiInstance = new GamesRestControllerApi();
        Pageable pageable = ; // Pageable | 
        String name = name_example; // String | 
        String tag = tag_example; // String | 
        Integer players = 56; // Integer | 
        Integer duration = 56; // Integer | 

        try {
            PagedModelGameDTO result = apiInstance.findByFilter1(pageable, name, tag, players, duration);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling GamesRestControllerApi#findByFilter1");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final Pageable pageable = new Pageable(); // Pageable | 
final String name = new String(); // String | 
final String tag = new String(); // String | 
final Integer players = new Integer(); // Integer | 
final Integer duration = new Integer(); // Integer | 

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

import org.openapitools.client.api.GamesRestControllerApi;

public class GamesRestControllerApiExample {
    public static void main(String[] args) {
        GamesRestControllerApi apiInstance = new GamesRestControllerApi();
        Pageable pageable = ; // Pageable | 
        String name = name_example; // String | 
        String tag = tag_example; // String | 
        Integer players = 56; // Integer | 
        Integer duration = 56; // Integer | 

        try {
            PagedModelGameDTO result = apiInstance.findByFilter1(pageable, name, tag, players, duration);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling GamesRestControllerApi#findByFilter1");
            e.printStackTrace();
        }
    }
}



// Create an instance of the API class
GamesRestControllerApi *apiInstance = [[GamesRestControllerApi alloc] init];
Pageable *pageable = ; //  (default to null)
String *name = name_example; //  (optional) (default to null)
String *tag = tag_example; //  (optional) (default to null)
Integer *players = 56; //  (optional) (default to null)
Integer *duration = 56; //  (optional) (default to null)

[apiInstance findByFilter1With:pageable
    name:name
    tag:tag
    players:players
    duration:duration
              completionHandler: ^(PagedModelGameDTO 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.GamesRestControllerApi()
var pageable = ; // {Pageable} 
var opts = {
  'name': name_example, // {String} 
  'tag': tag_example, // {String} 
  'players': 56, // {Integer} 
  'duration': 56 // {Integer} 
};

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

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

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

            // Create an instance of the API class
            var apiInstance = new GamesRestControllerApi();
            var pageable = new Pageable(); // Pageable |  (default to null)
            var name = name_example;  // String |  (optional)  (default to null)
            var tag = tag_example;  // String |  (optional)  (default to null)
            var players = 56;  // Integer |  (optional)  (default to null)
            var duration = 56;  // Integer |  (optional)  (default to null)

            try {
                PagedModelGameDTO result = apiInstance.findByFilter1(pageable, name, tag, players, duration);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling GamesRestControllerApi.findByFilter1: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\GamesRestControllerApi();
$pageable = ; // Pageable | 
$name = name_example; // String | 
$tag = tag_example; // String | 
$players = 56; // Integer | 
$duration = 56; // Integer | 

try {
    $result = $api_instance->findByFilter1($pageable, $name, $tag, $players, $duration);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling GamesRestControllerApi->findByFilter1: ', $e->getMessage(), PHP_EOL;
}
?>

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::GamesRestControllerApi->new();
my $pageable = ; # Pageable | 
my $name = name_example; # String | 
my $tag = tag_example; # String | 
my $players = 56; # Integer | 
my $duration = 56; # Integer | 

eval {
    my $result = $api_instance->findByFilter1(pageable => $pageable, name => $name, tag => $tag, players => $players, duration => $duration);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling GamesRestControllerApi->findByFilter1: $@\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.GamesRestControllerApi()
pageable =  # Pageable |  (default to null)
name = name_example # String |  (optional) (default to null)
tag = tag_example # String |  (optional) (default to null)
players = 56 # Integer |  (optional) (default to null)
duration = 56 # Integer |  (optional) (default to null)

try:
    api_response = api_instance.find_by_filter1(pageable, name=name, tag=tag, players=players, duration=duration)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling GamesRestControllerApi->findByFilter1: %s\n" % e)

extern crate GamesRestControllerApi;

pub fn main() {
    let pageable = ; // Pageable
    let name = name_example; // String
    let tag = tag_example; // String
    let players = 56; // Integer
    let duration = 56; // Integer

    let mut context = GamesRestControllerApi::Context::default();
    let result = client.findByFilter1(pageable, name, tag, players, duration, &context).wait();

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

Scopes

Parameters

Query parameters

Name	Description
name	String
tag	String
players	Integer (int32)
duration	Integer (int32)
pageable*	Pageable Required

Responses

Schema

getGame

/api/v1/games/{id}

Usage and SDK Samples

curl -X GET \
 -H "Accept: */*" \
 "http://127.0.0.1:8443/api/v1/games/{id}"

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

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

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

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

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

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

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

import org.openapitools.client.api.GamesRestControllerApi;

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

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



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

[apiInstance getGameWith:id
              completionHandler: ^(GameDTO 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.GamesRestControllerApi()
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.getGame(id, callback);

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

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

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

            try {
                GameDTO result = apiInstance.getGame(id);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling GamesRestControllerApi.getGame: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

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

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

extern crate GamesRestControllerApi;

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

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

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

Scopes

Parameters

Path parameters

Name	Description
id*	Long (int64) Required

Responses

Schema

removeFavorite

/api/v1/games/{id}/favourites

Usage and SDK Samples

curl -X DELETE \
 -H "Accept: */*" \
 "http://127.0.0.1:8443/api/v1/games/{id}/favourites"

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

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

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

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

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

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

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

import org.openapitools.client.api.GamesRestControllerApi;

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

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



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

[apiInstance removeFavoriteWith:id
              completionHandler: ^(GameDTO 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.GamesRestControllerApi()
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.removeFavorite(id, callback);

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

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

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

            try {
                GameDTO result = apiInstance.removeFavorite(id);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling GamesRestControllerApi.removeFavorite: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

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

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

extern crate GamesRestControllerApi;

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

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

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

Scopes

Parameters

Path parameters

Name	Description
id*	Long (int64) Required

Responses

Schema

replaceGame

/api/v1/games/{id}

Usage and SDK Samples

curl -X PUT \
 -H "Accept: */*" \
 -H "Content-Type: application/json" \
 "http://127.0.0.1:8443/api/v1/games/{id}" \
 -d '{
  "gameId" : 5,
  "maxPlayers" : 2,
  "minDuration" : 7,
  "gameName" : "gameName",
  "minPlayers" : 5,
  "genre" : "genre",
  "gameDescription" : "gameDescription",
  "gameImage" : {
    "id" : 6
  },
  "maxDuration" : 9
}'

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

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

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

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

        try {
            GameDTO result = apiInstance.replaceGame(id, gameDTO);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling GamesRestControllerApi#replaceGame");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

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

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

import org.openapitools.client.api.GamesRestControllerApi;

public class GamesRestControllerApiExample {
    public static void main(String[] args) {
        GamesRestControllerApi apiInstance = new GamesRestControllerApi();
        Long id = 789; // Long | 
        GameDTO gameDTO = ; // GameDTO | 

        try {
            GameDTO result = apiInstance.replaceGame(id, gameDTO);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling GamesRestControllerApi#replaceGame");
            e.printStackTrace();
        }
    }
}



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

[apiInstance replaceGameWith:id
    gameDTO:gameDTO
              completionHandler: ^(GameDTO 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.GamesRestControllerApi()
var id = 789; // {Long} 
var gameDTO = ; // {GameDTO} 

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

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

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

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

            try {
                GameDTO result = apiInstance.replaceGame(id, gameDTO);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling GamesRestControllerApi.replaceGame: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

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

try:
    api_response = api_instance.replace_game(id, gameDTO)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling GamesRestControllerApi->replaceGame: %s\n" % e)

extern crate GamesRestControllerApi;

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

    let mut context = GamesRestControllerApi::Context::default();
    let result = client.replaceGame(id, gameDTO, &context).wait();

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

Scopes

Parameters

Path parameters

Name	Description
id*	Long (int64) Required

Body parameters

Name	Description
gameDTO *

Responses

Schema

updateGameImage

/api/v1/games/{id}/images/

Usage and SDK Samples

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

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

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

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

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

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

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

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

import org.openapitools.client.api.GamesRestControllerApi;

public class GamesRestControllerApiExample {
    public static void main(String[] args) {
        GamesRestControllerApi apiInstance = new GamesRestControllerApi();
        Long id = 789; // Long | 
        UpdateNewImageRequest updateNewImageRequest = ; // UpdateNewImageRequest | 

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



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

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

var OpenApiDefinition = require('open_api_definition');

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

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

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

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

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

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

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

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

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

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

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

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

try:
    api_response = api_instance.update_game_image(id, updateNewImageRequest=updateNewImageRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling GamesRestControllerApi->updateGameImage: %s\n" % e)

extern crate GamesRestControllerApi;

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

    let mut context = GamesRestControllerApi::Context::default();
    let result = client.updateGameImage(id, updateNewImageRequest, &context).wait();

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

Scopes

Parameters

Path parameters

Name	Description
id*	Long (int64) Required

Body parameters

Name	Description
updateNewImageRequest

Responses

Schema

ImageRestController

getImage

/api/v1/images/{id}

Usage and SDK Samples

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

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

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

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

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

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

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

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

import org.openapitools.client.api.ImageRestControllerApi;

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

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



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

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

var OpenApiDefinition = require('open_api_definition');

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

extern crate ImageRestControllerApi;

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

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

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

Scopes

Parameters

Path parameters

Name	Description
id*	Long (int64) Required

Responses

Schema

getImageFile

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

Usage and SDK Samples

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

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

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

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

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

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

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

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

import org.openapitools.client.api.ImageRestControllerApi;

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

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



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

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

var OpenApiDefinition = require('open_api_definition');

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

extern crate ImageRestControllerApi;

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

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

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

Scopes

Parameters

Path parameters

Name	Description
id*	Long (int64) Required

Responses

Schema

replaceImageFile

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

Usage and SDK Samples

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

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

import java.io.File;
import java.util.*;

public class ImageRestControllerApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        ImageRestControllerApi apiInstance = new ImageRestControllerApi();
        Long id = 789; // Long | 
        UpdateNewImageRequest updateNewImageRequest = ; // UpdateNewImageRequest | 

        try {
            Object result = apiInstance.replaceImageFile(id, updateNewImageRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ImageRestControllerApi#replaceImageFile");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final Long id = new Long(); // Long | 
final UpdateNewImageRequest updateNewImageRequest = new UpdateNewImageRequest(); // UpdateNewImageRequest | 

try {
    final result = await api_instance.replaceImageFile(id, updateNewImageRequest);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->replaceImageFile: $e\n');
}

import org.openapitools.client.api.ImageRestControllerApi;

public class ImageRestControllerApiExample {
    public static void main(String[] args) {
        ImageRestControllerApi apiInstance = new ImageRestControllerApi();
        Long id = 789; // Long | 
        UpdateNewImageRequest updateNewImageRequest = ; // UpdateNewImageRequest | 

        try {
            Object result = apiInstance.replaceImageFile(id, updateNewImageRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling ImageRestControllerApi#replaceImageFile");
            e.printStackTrace();
        }
    }
}



// Create an instance of the API class
ImageRestControllerApi *apiInstance = [[ImageRestControllerApi alloc] init];
Long *id = 789; //  (default to null)
UpdateNewImageRequest *updateNewImageRequest = ; //  (optional)

[apiInstance replaceImageFileWith:id
    updateNewImageRequest:updateNewImageRequest
              completionHandler: ^(Object output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenApiDefinition = require('open_api_definition');

// Create an instance of the API class
var api = new OpenApiDefinition.ImageRestControllerApi()
var id = 789; // {Long} 
var opts = {
  'updateNewImageRequest':  // {UpdateNewImageRequest} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.replaceImageFile(id, opts, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class replaceImageFileExample
    {
        public void main()
        {

            // Create an instance of the API class
            var apiInstance = new ImageRestControllerApi();
            var id = 789;  // Long |  (default to null)
            var updateNewImageRequest = new UpdateNewImageRequest(); // UpdateNewImageRequest |  (optional) 

            try {
                Object result = apiInstance.replaceImageFile(id, updateNewImageRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling ImageRestControllerApi.replaceImageFile: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\ImageRestControllerApi();
$id = 789; // Long | 
$updateNewImageRequest = ; // UpdateNewImageRequest | 

try {
    $result = $api_instance->replaceImageFile($id, $updateNewImageRequest);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling ImageRestControllerApi->replaceImageFile: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::ImageRestControllerApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::ImageRestControllerApi->new();
my $id = 789; # Long | 
my $updateNewImageRequest = WWW::OPenAPIClient::Object::UpdateNewImageRequest->new(); # UpdateNewImageRequest | 

eval {
    my $result = $api_instance->replaceImageFile(id => $id, updateNewImageRequest => $updateNewImageRequest);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling ImageRestControllerApi->replaceImageFile: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Create an instance of the API class
api_instance = openapi_client.ImageRestControllerApi()
id = 789 # Long |  (default to null)
updateNewImageRequest =  # UpdateNewImageRequest |  (optional)

try:
    api_response = api_instance.replace_image_file(id, updateNewImageRequest=updateNewImageRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling ImageRestControllerApi->replaceImageFile: %s\n" % e)

extern crate ImageRestControllerApi;

pub fn main() {
    let id = 789; // Long
    let updateNewImageRequest = ; // UpdateNewImageRequest

    let mut context = ImageRestControllerApi::Context::default();
    let result = client.replaceImageFile(id, updateNewImageRequest, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters

Name	Description
id*	Long (int64) Required

Body parameters

Name	Description
updateNewImageRequest

Responses

Schema

LoginController

logOut

/api/v1/auth/logout

Usage and SDK Samples

curl -X POST \
 -H "Accept: */*" \
 "http://127.0.0.1:8443/api/v1/auth/logout"

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.LoginControllerApi;

import java.io.File;
import java.util.*;

public class LoginControllerApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        LoginControllerApi apiInstance = new LoginControllerApi();

        try {
            AuthResponse result = apiInstance.logOut();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling LoginControllerApi#logOut");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();


try {
    final result = await api_instance.logOut();
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->logOut: $e\n');
}

import org.openapitools.client.api.LoginControllerApi;

public class LoginControllerApiExample {
    public static void main(String[] args) {
        LoginControllerApi apiInstance = new LoginControllerApi();

        try {
            AuthResponse result = apiInstance.logOut();
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling LoginControllerApi#logOut");
            e.printStackTrace();
        }
    }
}



// Create an instance of the API class
LoginControllerApi *apiInstance = [[LoginControllerApi alloc] init];

[apiInstance logOutWithCompletionHandler: 
              ^(AuthResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenApiDefinition = require('open_api_definition');

// Create an instance of the API class
var api = new OpenApiDefinition.LoginControllerApi()
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.logOut(callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class logOutExample
    {
        public void main()
        {

            // Create an instance of the API class
            var apiInstance = new LoginControllerApi();

            try {
                AuthResponse result = apiInstance.logOut();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling LoginControllerApi.logOut: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\LoginControllerApi();

try {
    $result = $api_instance->logOut();
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling LoginControllerApi->logOut: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::LoginControllerApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::LoginControllerApi->new();

eval {
    my $result = $api_instance->logOut();
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling LoginControllerApi->logOut: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Create an instance of the API class
api_instance = openapi_client.LoginControllerApi()

try:
    api_response = api_instance.log_out()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling LoginControllerApi->logOut: %s\n" % e)

extern crate LoginControllerApi;

pub fn main() {

    let mut context = LoginControllerApi::Context::default();
    let result = client.logOut(&context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Responses

Schema

login

/api/v1/auth/login

Usage and SDK Samples

curl -X POST \
 -H "Accept: */*" \
 -H "Content-Type: application/json" \
 "http://127.0.0.1:8443/api/v1/auth/login" \
 -d '{
  "password" : "password",
  "username" : "username"
}'

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.LoginControllerApi;

import java.io.File;
import java.util.*;

public class LoginControllerApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        LoginControllerApi apiInstance = new LoginControllerApi();
        LoginRequest loginRequest = ; // LoginRequest | 

        try {
            AuthResponse result = apiInstance.login(loginRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling LoginControllerApi#login");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final LoginRequest loginRequest = new LoginRequest(); // LoginRequest | 

try {
    final result = await api_instance.login(loginRequest);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->login: $e\n');
}

import org.openapitools.client.api.LoginControllerApi;

public class LoginControllerApiExample {
    public static void main(String[] args) {
        LoginControllerApi apiInstance = new LoginControllerApi();
        LoginRequest loginRequest = ; // LoginRequest | 

        try {
            AuthResponse result = apiInstance.login(loginRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling LoginControllerApi#login");
            e.printStackTrace();
        }
    }
}



// Create an instance of the API class
LoginControllerApi *apiInstance = [[LoginControllerApi alloc] init];
LoginRequest *loginRequest = ; // 

[apiInstance loginWith:loginRequest
              completionHandler: ^(AuthResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenApiDefinition = require('open_api_definition');

// Create an instance of the API class
var api = new OpenApiDefinition.LoginControllerApi()
var loginRequest = ; // {LoginRequest} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.login(loginRequest, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class loginExample
    {
        public void main()
        {

            // Create an instance of the API class
            var apiInstance = new LoginControllerApi();
            var loginRequest = new LoginRequest(); // LoginRequest | 

            try {
                AuthResponse result = apiInstance.login(loginRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling LoginControllerApi.login: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\LoginControllerApi();
$loginRequest = ; // LoginRequest | 

try {
    $result = $api_instance->login($loginRequest);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling LoginControllerApi->login: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::LoginControllerApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::LoginControllerApi->new();
my $loginRequest = WWW::OPenAPIClient::Object::LoginRequest->new(); # LoginRequest | 

eval {
    my $result = $api_instance->login(loginRequest => $loginRequest);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling LoginControllerApi->login: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Create an instance of the API class
api_instance = openapi_client.LoginControllerApi()
loginRequest =  # LoginRequest | 

try:
    api_response = api_instance.login(loginRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling LoginControllerApi->login: %s\n" % e)

extern crate LoginControllerApi;

pub fn main() {
    let loginRequest = ; // LoginRequest

    let mut context = LoginControllerApi::Context::default();
    let result = client.login(loginRequest, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Body parameters

Name	Description
loginRequest *

Responses

refreshToken

/api/v1/auth/refresh

Usage and SDK Samples

curl -X POST \
 -H "Accept: */*" \
 "http://127.0.0.1:8443/api/v1/auth/refresh"

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.LoginControllerApi;

import java.io.File;
import java.util.*;

public class LoginControllerApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        LoginControllerApi apiInstance = new LoginControllerApi();
        String refreshToken = refreshToken_example; // String | 

        try {
            AuthResponse result = apiInstance.refreshToken(refreshToken);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling LoginControllerApi#refreshToken");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String refreshToken = new String(); // String | 

try {
    final result = await api_instance.refreshToken(refreshToken);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->refreshToken: $e\n');
}

import org.openapitools.client.api.LoginControllerApi;

public class LoginControllerApiExample {
    public static void main(String[] args) {
        LoginControllerApi apiInstance = new LoginControllerApi();
        String refreshToken = refreshToken_example; // String | 

        try {
            AuthResponse result = apiInstance.refreshToken(refreshToken);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling LoginControllerApi#refreshToken");
            e.printStackTrace();
        }
    }
}



// Create an instance of the API class
LoginControllerApi *apiInstance = [[LoginControllerApi alloc] init];
String *refreshToken = refreshToken_example; //  (optional) (default to null)

[apiInstance refreshTokenWith:refreshToken
              completionHandler: ^(AuthResponse output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenApiDefinition = require('open_api_definition');

// Create an instance of the API class
var api = new OpenApiDefinition.LoginControllerApi()
var opts = {
  'refreshToken': refreshToken_example // {String} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.refreshToken(opts, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class refreshTokenExample
    {
        public void main()
        {

            // Create an instance of the API class
            var apiInstance = new LoginControllerApi();
            var refreshToken = refreshToken_example;  // String |  (optional)  (default to null)

            try {
                AuthResponse result = apiInstance.refreshToken(refreshToken);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling LoginControllerApi.refreshToken: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\LoginControllerApi();
$refreshToken = refreshToken_example; // String | 

try {
    $result = $api_instance->refreshToken($refreshToken);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling LoginControllerApi->refreshToken: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::LoginControllerApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::LoginControllerApi->new();
my $refreshToken = refreshToken_example; # String | 

eval {
    my $result = $api_instance->refreshToken(refreshToken => $refreshToken);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling LoginControllerApi->refreshToken: $@\n";
}

from __future__ import print_statement
import time
import openapi_client
from openapi_client.rest import ApiException
from pprint import pprint

# Create an instance of the API class
api_instance = openapi_client.LoginControllerApi()
refreshToken = refreshToken_example # String |  (optional) (default to null)

try:
    api_response = api_instance.refresh_token(refreshToken=refreshToken)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling LoginControllerApi->refreshToken: %s\n" % e)

extern crate LoginControllerApi;

pub fn main() {
    let refreshToken = refreshToken_example; // String

    let mut context = LoginControllerApi::Context::default();
    let result = client.refreshToken(refreshToken, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Responses

Schema

NewsRestController

createNew

/api/v1/news/

Usage and SDK Samples

curl -X POST \
 -H "Accept: */*" \
 -H "Content-Type: application/json" \
 "http://127.0.0.1:8443/api/v1/news/" \
 -d '{
  "newTag" : "newTag",
  "newName" : "newName",
  "newImage" : {
    "id" : 6
  },
  "validated" : true,
  "newId" : 0,
  "newEvents" : [ {
    "eventId" : 1,
    "eventName" : "eventName"
  }, {
    "eventId" : 1,
    "eventName" : "eventName"
  } ],
  "creationDate" : "2000-01-23T04:56:07.000+00:00",
  "newDescription" : "newDescription",
  "newCreator" : {
    "userNickname" : "userNickname",
    "userEmail" : "userEmail",
    "userId" : 6
  }
}'

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.NewsRestControllerApi;

import java.io.File;
import java.util.*;

public class NewsRestControllerApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        NewsRestControllerApi apiInstance = new NewsRestControllerApi();
        NewDTO newDTO = ; // NewDTO | 

        try {
            NewDTO result = apiInstance.createNew(newDTO);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling NewsRestControllerApi#createNew");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final NewDTO newDTO = new NewDTO(); // NewDTO | 

try {
    final result = await api_instance.createNew(newDTO);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->createNew: $e\n');
}

import org.openapitools.client.api.NewsRestControllerApi;

public class NewsRestControllerApiExample {
    public static void main(String[] args) {
        NewsRestControllerApi apiInstance = new NewsRestControllerApi();
        NewDTO newDTO = ; // NewDTO | 

        try {
            NewDTO result = apiInstance.createNew(newDTO);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling NewsRestControllerApi#createNew");
            e.printStackTrace();
        }
    }
}



// Create an instance of the API class
NewsRestControllerApi *apiInstance = [[NewsRestControllerApi alloc] init];
NewDTO *newDTO = ; // 

[apiInstance createNewWith:newDTO
              completionHandler: ^(NewDTO 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.NewsRestControllerApi()
var newDTO = ; // {NewDTO} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.createNew(newDTO, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class createNewExample
    {
        public void main()
        {

            // Create an instance of the API class
            var apiInstance = new NewsRestControllerApi();
            var newDTO = new NewDTO(); // NewDTO | 

            try {
                NewDTO result = apiInstance.createNew(newDTO);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling NewsRestControllerApi.createNew: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\NewsRestControllerApi();
$newDTO = ; // NewDTO | 

try {
    $result = $api_instance->createNew($newDTO);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling NewsRestControllerApi->createNew: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::NewsRestControllerApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::NewsRestControllerApi->new();
my $newDTO = WWW::OPenAPIClient::Object::NewDTO->new(); # NewDTO | 

eval {
    my $result = $api_instance->createNew(newDTO => $newDTO);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling NewsRestControllerApi->createNew: $@\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.NewsRestControllerApi()
newDTO =  # NewDTO | 

try:
    api_response = api_instance.create_new(newDTO)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling NewsRestControllerApi->createNew: %s\n" % e)

extern crate NewsRestControllerApi;

pub fn main() {
    let newDTO = ; // NewDTO

    let mut context = NewsRestControllerApi::Context::default();
    let result = client.createNew(newDTO, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Body parameters

Name	Description
newDTO *

Responses

Schema

createNewImage

/api/v1/news/{id}/images/

Usage and SDK Samples

curl -X POST \
 -H "Accept: */*" \
 -H "Content-Type: application/json" \
 "http://127.0.0.1:8443/api/v1/news/{id}/images/" \
 -d ''

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.NewsRestControllerApi;

import java.io.File;
import java.util.*;

public class NewsRestControllerApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        NewsRestControllerApi apiInstance = new NewsRestControllerApi();
        Long id = 789; // Long | 
        UpdateNewImageRequest updateNewImageRequest = ; // UpdateNewImageRequest | 

        try {
            ImageDTO result = apiInstance.createNewImage(id, updateNewImageRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling NewsRestControllerApi#createNewImage");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final Long id = new Long(); // Long | 
final UpdateNewImageRequest updateNewImageRequest = new UpdateNewImageRequest(); // UpdateNewImageRequest | 

try {
    final result = await api_instance.createNewImage(id, updateNewImageRequest);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->createNewImage: $e\n');
}

import org.openapitools.client.api.NewsRestControllerApi;

public class NewsRestControllerApiExample {
    public static void main(String[] args) {
        NewsRestControllerApi apiInstance = new NewsRestControllerApi();
        Long id = 789; // Long | 
        UpdateNewImageRequest updateNewImageRequest = ; // UpdateNewImageRequest | 

        try {
            ImageDTO result = apiInstance.createNewImage(id, updateNewImageRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling NewsRestControllerApi#createNewImage");
            e.printStackTrace();
        }
    }
}



// Create an instance of the API class
NewsRestControllerApi *apiInstance = [[NewsRestControllerApi alloc] init];
Long *id = 789; //  (default to null)
UpdateNewImageRequest *updateNewImageRequest = ; //  (optional)

[apiInstance createNewImageWith:id
    updateNewImageRequest:updateNewImageRequest
              completionHandler: ^(ImageDTO output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenApiDefinition = require('open_api_definition');

// Create an instance of the API class
var api = new OpenApiDefinition.NewsRestControllerApi()
var id = 789; // {Long} 
var opts = {
  'updateNewImageRequest':  // {UpdateNewImageRequest} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.createNewImage(id, opts, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class createNewImageExample
    {
        public void main()
        {

            // Create an instance of the API class
            var apiInstance = new NewsRestControllerApi();
            var id = 789;  // Long |  (default to null)
            var updateNewImageRequest = new UpdateNewImageRequest(); // UpdateNewImageRequest |  (optional) 

            try {
                ImageDTO result = apiInstance.createNewImage(id, updateNewImageRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling NewsRestControllerApi.createNewImage: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\NewsRestControllerApi();
$id = 789; // Long | 
$updateNewImageRequest = ; // UpdateNewImageRequest | 

try {
    $result = $api_instance->createNewImage($id, $updateNewImageRequest);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling NewsRestControllerApi->createNewImage: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::NewsRestControllerApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::NewsRestControllerApi->new();
my $id = 789; # Long | 
my $updateNewImageRequest = WWW::OPenAPIClient::Object::UpdateNewImageRequest->new(); # UpdateNewImageRequest | 

eval {
    my $result = $api_instance->createNewImage(id => $id, updateNewImageRequest => $updateNewImageRequest);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling NewsRestControllerApi->createNewImage: $@\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.NewsRestControllerApi()
id = 789 # Long |  (default to null)
updateNewImageRequest =  # UpdateNewImageRequest |  (optional)

try:
    api_response = api_instance.create_new_image(id, updateNewImageRequest=updateNewImageRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling NewsRestControllerApi->createNewImage: %s\n" % e)

extern crate NewsRestControllerApi;

pub fn main() {
    let id = 789; // Long
    let updateNewImageRequest = ; // UpdateNewImageRequest

    let mut context = NewsRestControllerApi::Context::default();
    let result = client.createNewImage(id, updateNewImageRequest, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters

Name	Description
id*	Long (int64) Required

Body parameters

Name	Description
updateNewImageRequest

Responses

Schema

deleteNew

/api/v1/news/{id}

Usage and SDK Samples

curl -X DELETE \
 -H "Accept: */*" \
 "http://127.0.0.1:8443/api/v1/news/{id}"

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.NewsRestControllerApi;

import java.io.File;
import java.util.*;

public class NewsRestControllerApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        NewsRestControllerApi apiInstance = new NewsRestControllerApi();
        Long id = 789; // Long | 

        try {
            NewDTO result = apiInstance.deleteNew(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling NewsRestControllerApi#deleteNew");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final Long id = new Long(); // Long | 

try {
    final result = await api_instance.deleteNew(id);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->deleteNew: $e\n');
}

import org.openapitools.client.api.NewsRestControllerApi;

public class NewsRestControllerApiExample {
    public static void main(String[] args) {
        NewsRestControllerApi apiInstance = new NewsRestControllerApi();
        Long id = 789; // Long | 

        try {
            NewDTO result = apiInstance.deleteNew(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling NewsRestControllerApi#deleteNew");
            e.printStackTrace();
        }
    }
}



// Create an instance of the API class
NewsRestControllerApi *apiInstance = [[NewsRestControllerApi alloc] init];
Long *id = 789; //  (default to null)

[apiInstance deleteNewWith:id
              completionHandler: ^(NewDTO 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.NewsRestControllerApi()
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.deleteNew(id, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class deleteNewExample
    {
        public void main()
        {

            // Create an instance of the API class
            var apiInstance = new NewsRestControllerApi();
            var id = 789;  // Long |  (default to null)

            try {
                NewDTO result = apiInstance.deleteNew(id);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling NewsRestControllerApi.deleteNew: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\NewsRestControllerApi();
$id = 789; // Long | 

try {
    $result = $api_instance->deleteNew($id);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling NewsRestControllerApi->deleteNew: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::NewsRestControllerApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::NewsRestControllerApi->new();
my $id = 789; # Long | 

eval {
    my $result = $api_instance->deleteNew(id => $id);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling NewsRestControllerApi->deleteNew: $@\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.NewsRestControllerApi()
id = 789 # Long |  (default to null)

try:
    api_response = api_instance.delete_new(id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling NewsRestControllerApi->deleteNew: %s\n" % e)

extern crate NewsRestControllerApi;

pub fn main() {
    let id = 789; // Long

    let mut context = NewsRestControllerApi::Context::default();
    let result = client.deleteNew(id, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters

Name	Description
id*	Long (int64) Required

Responses

Schema

deleteNewImage

/api/v1/news/{newId}/images/{imageId}

Usage and SDK Samples

curl -X DELETE \
 -H "Accept: */*" \
 "http://127.0.0.1:8443/api/v1/news/{newId}/images/{imageId}"

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.NewsRestControllerApi;

import java.io.File;
import java.util.*;

public class NewsRestControllerApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        NewsRestControllerApi apiInstance = new NewsRestControllerApi();
        Long newId = 789; // Long | 
        Long imageId = 789; // Long | 

        try {
            ImageDTO result = apiInstance.deleteNewImage(newId, imageId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling NewsRestControllerApi#deleteNewImage");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final Long newId = new Long(); // Long | 
final Long imageId = new Long(); // Long | 

try {
    final result = await api_instance.deleteNewImage(newId, imageId);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->deleteNewImage: $e\n');
}

import org.openapitools.client.api.NewsRestControllerApi;

public class NewsRestControllerApiExample {
    public static void main(String[] args) {
        NewsRestControllerApi apiInstance = new NewsRestControllerApi();
        Long newId = 789; // Long | 
        Long imageId = 789; // Long | 

        try {
            ImageDTO result = apiInstance.deleteNewImage(newId, imageId);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling NewsRestControllerApi#deleteNewImage");
            e.printStackTrace();
        }
    }
}



// Create an instance of the API class
NewsRestControllerApi *apiInstance = [[NewsRestControllerApi alloc] init];
Long *newId = 789; //  (default to null)
Long *imageId = 789; //  (default to null)

[apiInstance deleteNewImageWith:newId
    imageId:imageId
              completionHandler: ^(ImageDTO output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenApiDefinition = require('open_api_definition');

// Create an instance of the API class
var api = new OpenApiDefinition.NewsRestControllerApi()
var newId = 789; // {Long} 
var imageId = 789; // {Long} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.deleteNewImage(newId, imageId, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class deleteNewImageExample
    {
        public void main()
        {

            // Create an instance of the API class
            var apiInstance = new NewsRestControllerApi();
            var newId = 789;  // Long |  (default to null)
            var imageId = 789;  // Long |  (default to null)

            try {
                ImageDTO result = apiInstance.deleteNewImage(newId, imageId);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling NewsRestControllerApi.deleteNewImage: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\NewsRestControllerApi();
$newId = 789; // Long | 
$imageId = 789; // Long | 

try {
    $result = $api_instance->deleteNewImage($newId, $imageId);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling NewsRestControllerApi->deleteNewImage: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::NewsRestControllerApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::NewsRestControllerApi->new();
my $newId = 789; # Long | 
my $imageId = 789; # Long | 

eval {
    my $result = $api_instance->deleteNewImage(newId => $newId, imageId => $imageId);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling NewsRestControllerApi->deleteNewImage: $@\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.NewsRestControllerApi()
newId = 789 # Long |  (default to null)
imageId = 789 # Long |  (default to null)

try:
    api_response = api_instance.delete_new_image(newId, imageId)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling NewsRestControllerApi->deleteNewImage: %s\n" % e)

extern crate NewsRestControllerApi;

pub fn main() {
    let newId = 789; // Long
    let imageId = 789; // Long

    let mut context = NewsRestControllerApi::Context::default();
    let result = client.deleteNewImage(newId, imageId, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters

Name	Description
newId*	Long (int64) Required
imageId*	Long (int64) Required

Responses

Schema

findByFilter

/api/v1/news/

Usage and SDK Samples

curl -X GET \
 -H "Accept: */*" \
 "http://127.0.0.1:8443/api/v1/news/?name=name_example&tag=tag_example&pageable="

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.NewsRestControllerApi;

import java.io.File;
import java.util.*;

public class NewsRestControllerApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        NewsRestControllerApi apiInstance = new NewsRestControllerApi();
        Pageable pageable = ; // Pageable | 
        String name = name_example; // String | 
        String tag = tag_example; // String | 

        try {
            PagedModelNewDTO result = apiInstance.findByFilter(pageable, name, tag);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling NewsRestControllerApi#findByFilter");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final Pageable pageable = new Pageable(); // Pageable | 
final String name = new String(); // String | 
final String tag = new String(); // String | 

try {
    final result = await api_instance.findByFilter(pageable, name, tag);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->findByFilter: $e\n');
}

import org.openapitools.client.api.NewsRestControllerApi;

public class NewsRestControllerApiExample {
    public static void main(String[] args) {
        NewsRestControllerApi apiInstance = new NewsRestControllerApi();
        Pageable pageable = ; // Pageable | 
        String name = name_example; // String | 
        String tag = tag_example; // String | 

        try {
            PagedModelNewDTO result = apiInstance.findByFilter(pageable, name, tag);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling NewsRestControllerApi#findByFilter");
            e.printStackTrace();
        }
    }
}



// Create an instance of the API class
NewsRestControllerApi *apiInstance = [[NewsRestControllerApi alloc] init];
Pageable *pageable = ; //  (default to null)
String *name = name_example; //  (optional) (default to null)
String *tag = tag_example; //  (optional) (default to null)

[apiInstance findByFilterWith:pageable
    name:name
    tag:tag
              completionHandler: ^(PagedModelNewDTO 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.NewsRestControllerApi()
var pageable = ; // {Pageable} 
var opts = {
  'name': name_example, // {String} 
  'tag': tag_example // {String} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.findByFilter(pageable, opts, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class findByFilterExample
    {
        public void main()
        {

            // Create an instance of the API class
            var apiInstance = new NewsRestControllerApi();
            var pageable = new Pageable(); // Pageable |  (default to null)
            var name = name_example;  // String |  (optional)  (default to null)
            var tag = tag_example;  // String |  (optional)  (default to null)

            try {
                PagedModelNewDTO result = apiInstance.findByFilter(pageable, name, tag);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling NewsRestControllerApi.findByFilter: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\NewsRestControllerApi();
$pageable = ; // Pageable | 
$name = name_example; // String | 
$tag = tag_example; // String | 

try {
    $result = $api_instance->findByFilter($pageable, $name, $tag);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling NewsRestControllerApi->findByFilter: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::NewsRestControllerApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::NewsRestControllerApi->new();
my $pageable = ; # Pageable | 
my $name = name_example; # String | 
my $tag = tag_example; # String | 

eval {
    my $result = $api_instance->findByFilter(pageable => $pageable, name => $name, tag => $tag);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling NewsRestControllerApi->findByFilter: $@\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.NewsRestControllerApi()
pageable =  # Pageable |  (default to null)
name = name_example # String |  (optional) (default to null)
tag = tag_example # String |  (optional) (default to null)

try:
    api_response = api_instance.find_by_filter(pageable, name=name, tag=tag)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling NewsRestControllerApi->findByFilter: %s\n" % e)

extern crate NewsRestControllerApi;

pub fn main() {
    let pageable = ; // Pageable
    let name = name_example; // String
    let tag = tag_example; // String

    let mut context = NewsRestControllerApi::Context::default();
    let result = client.findByFilter(pageable, name, tag, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Query parameters

Name	Description
name	String
tag	String
pageable*	Pageable Required

Responses

Schema

getNew

/api/v1/news/{id}

Usage and SDK Samples

curl -X GET \
 -H "Accept: */*" \
 "http://127.0.0.1:8443/api/v1/news/{id}"

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.NewsRestControllerApi;

import java.io.File;
import java.util.*;

public class NewsRestControllerApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        NewsRestControllerApi apiInstance = new NewsRestControllerApi();
        Long id = 789; // Long | 

        try {
            NewDTO result = apiInstance.getNew(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling NewsRestControllerApi#getNew");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final Long id = new Long(); // Long | 

try {
    final result = await api_instance.getNew(id);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->getNew: $e\n');
}

import org.openapitools.client.api.NewsRestControllerApi;

public class NewsRestControllerApiExample {
    public static void main(String[] args) {
        NewsRestControllerApi apiInstance = new NewsRestControllerApi();
        Long id = 789; // Long | 

        try {
            NewDTO result = apiInstance.getNew(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling NewsRestControllerApi#getNew");
            e.printStackTrace();
        }
    }
}



// Create an instance of the API class
NewsRestControllerApi *apiInstance = [[NewsRestControllerApi alloc] init];
Long *id = 789; //  (default to null)

[apiInstance getNewWith:id
              completionHandler: ^(NewDTO 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.NewsRestControllerApi()
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.getNew(id, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class getNewExample
    {
        public void main()
        {

            // Create an instance of the API class
            var apiInstance = new NewsRestControllerApi();
            var id = 789;  // Long |  (default to null)

            try {
                NewDTO result = apiInstance.getNew(id);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling NewsRestControllerApi.getNew: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\NewsRestControllerApi();
$id = 789; // Long | 

try {
    $result = $api_instance->getNew($id);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling NewsRestControllerApi->getNew: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::NewsRestControllerApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::NewsRestControllerApi->new();
my $id = 789; # Long | 

eval {
    my $result = $api_instance->getNew(id => $id);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling NewsRestControllerApi->getNew: $@\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.NewsRestControllerApi()
id = 789 # Long |  (default to null)

try:
    api_response = api_instance.get_new(id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling NewsRestControllerApi->getNew: %s\n" % e)

extern crate NewsRestControllerApi;

pub fn main() {
    let id = 789; // Long

    let mut context = NewsRestControllerApi::Context::default();
    let result = client.getNew(id, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters

Name	Description
id*	Long (int64) Required

Responses

Schema

replaceNew

/api/v1/news/{id}

Usage and SDK Samples

curl -X PUT \
 -H "Accept: */*" \
 -H "Content-Type: application/json" \
 "http://127.0.0.1:8443/api/v1/news/{id}" \
 -d '{
  "newTag" : "newTag",
  "newName" : "newName",
  "newImage" : {
    "id" : 6
  },
  "validated" : true,
  "newId" : 0,
  "newEvents" : [ {
    "eventId" : 1,
    "eventName" : "eventName"
  }, {
    "eventId" : 1,
    "eventName" : "eventName"
  } ],
  "creationDate" : "2000-01-23T04:56:07.000+00:00",
  "newDescription" : "newDescription",
  "newCreator" : {
    "userNickname" : "userNickname",
    "userEmail" : "userEmail",
    "userId" : 6
  }
}'

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.NewsRestControllerApi;

import java.io.File;
import java.util.*;

public class NewsRestControllerApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        NewsRestControllerApi apiInstance = new NewsRestControllerApi();
        Long id = 789; // Long | 
        NewDTO newDTO = ; // NewDTO | 

        try {
            NewDTO result = apiInstance.replaceNew(id, newDTO);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling NewsRestControllerApi#replaceNew");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final Long id = new Long(); // Long | 
final NewDTO newDTO = new NewDTO(); // NewDTO | 

try {
    final result = await api_instance.replaceNew(id, newDTO);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->replaceNew: $e\n');
}

import org.openapitools.client.api.NewsRestControllerApi;

public class NewsRestControllerApiExample {
    public static void main(String[] args) {
        NewsRestControllerApi apiInstance = new NewsRestControllerApi();
        Long id = 789; // Long | 
        NewDTO newDTO = ; // NewDTO | 

        try {
            NewDTO result = apiInstance.replaceNew(id, newDTO);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling NewsRestControllerApi#replaceNew");
            e.printStackTrace();
        }
    }
}



// Create an instance of the API class
NewsRestControllerApi *apiInstance = [[NewsRestControllerApi alloc] init];
Long *id = 789; //  (default to null)
NewDTO *newDTO = ; // 

[apiInstance replaceNewWith:id
    newDTO:newDTO
              completionHandler: ^(NewDTO 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.NewsRestControllerApi()
var id = 789; // {Long} 
var newDTO = ; // {NewDTO} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.replaceNew(id, newDTO, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class replaceNewExample
    {
        public void main()
        {

            // Create an instance of the API class
            var apiInstance = new NewsRestControllerApi();
            var id = 789;  // Long |  (default to null)
            var newDTO = new NewDTO(); // NewDTO | 

            try {
                NewDTO result = apiInstance.replaceNew(id, newDTO);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling NewsRestControllerApi.replaceNew: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\NewsRestControllerApi();
$id = 789; // Long | 
$newDTO = ; // NewDTO | 

try {
    $result = $api_instance->replaceNew($id, $newDTO);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling NewsRestControllerApi->replaceNew: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::NewsRestControllerApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::NewsRestControllerApi->new();
my $id = 789; # Long | 
my $newDTO = WWW::OPenAPIClient::Object::NewDTO->new(); # NewDTO | 

eval {
    my $result = $api_instance->replaceNew(id => $id, newDTO => $newDTO);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling NewsRestControllerApi->replaceNew: $@\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.NewsRestControllerApi()
id = 789 # Long |  (default to null)
newDTO =  # NewDTO | 

try:
    api_response = api_instance.replace_new(id, newDTO)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling NewsRestControllerApi->replaceNew: %s\n" % e)

extern crate NewsRestControllerApi;

pub fn main() {
    let id = 789; // Long
    let newDTO = ; // NewDTO

    let mut context = NewsRestControllerApi::Context::default();
    let result = client.replaceNew(id, newDTO, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters

Name	Description
id*	Long (int64) Required

Body parameters

Name	Description
newDTO *

Responses

Schema

updateNewImage

/api/v1/news/{id}/images/

Usage and SDK Samples

curl -X PUT \
 -H "Accept: */*" \
 -H "Content-Type: application/json" \
 "http://127.0.0.1:8443/api/v1/news/{id}/images/" \
 -d ''

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.NewsRestControllerApi;

import java.io.File;
import java.util.*;

public class NewsRestControllerApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        NewsRestControllerApi apiInstance = new NewsRestControllerApi();
        Long id = 789; // Long | 
        UpdateNewImageRequest updateNewImageRequest = ; // UpdateNewImageRequest | 

        try {
            ImageDTO result = apiInstance.updateNewImage(id, updateNewImageRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling NewsRestControllerApi#updateNewImage");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final Long id = new Long(); // Long | 
final UpdateNewImageRequest updateNewImageRequest = new UpdateNewImageRequest(); // UpdateNewImageRequest | 

try {
    final result = await api_instance.updateNewImage(id, updateNewImageRequest);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->updateNewImage: $e\n');
}

import org.openapitools.client.api.NewsRestControllerApi;

public class NewsRestControllerApiExample {
    public static void main(String[] args) {
        NewsRestControllerApi apiInstance = new NewsRestControllerApi();
        Long id = 789; // Long | 
        UpdateNewImageRequest updateNewImageRequest = ; // UpdateNewImageRequest | 

        try {
            ImageDTO result = apiInstance.updateNewImage(id, updateNewImageRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling NewsRestControllerApi#updateNewImage");
            e.printStackTrace();
        }
    }
}



// Create an instance of the API class
NewsRestControllerApi *apiInstance = [[NewsRestControllerApi alloc] init];
Long *id = 789; //  (default to null)
UpdateNewImageRequest *updateNewImageRequest = ; //  (optional)

[apiInstance updateNewImageWith:id
    updateNewImageRequest:updateNewImageRequest
              completionHandler: ^(ImageDTO output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenApiDefinition = require('open_api_definition');

// Create an instance of the API class
var api = new OpenApiDefinition.NewsRestControllerApi()
var id = 789; // {Long} 
var opts = {
  'updateNewImageRequest':  // {UpdateNewImageRequest} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.updateNewImage(id, opts, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class updateNewImageExample
    {
        public void main()
        {

            // Create an instance of the API class
            var apiInstance = new NewsRestControllerApi();
            var id = 789;  // Long |  (default to null)
            var updateNewImageRequest = new UpdateNewImageRequest(); // UpdateNewImageRequest |  (optional) 

            try {
                ImageDTO result = apiInstance.updateNewImage(id, updateNewImageRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling NewsRestControllerApi.updateNewImage: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\NewsRestControllerApi();
$id = 789; // Long | 
$updateNewImageRequest = ; // UpdateNewImageRequest | 

try {
    $result = $api_instance->updateNewImage($id, $updateNewImageRequest);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling NewsRestControllerApi->updateNewImage: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::NewsRestControllerApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::NewsRestControllerApi->new();
my $id = 789; # Long | 
my $updateNewImageRequest = WWW::OPenAPIClient::Object::UpdateNewImageRequest->new(); # UpdateNewImageRequest | 

eval {
    my $result = $api_instance->updateNewImage(id => $id, updateNewImageRequest => $updateNewImageRequest);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling NewsRestControllerApi->updateNewImage: $@\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.NewsRestControllerApi()
id = 789 # Long |  (default to null)
updateNewImageRequest =  # UpdateNewImageRequest |  (optional)

try:
    api_response = api_instance.update_new_image(id, updateNewImageRequest=updateNewImageRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling NewsRestControllerApi->updateNewImage: %s\n" % e)

extern crate NewsRestControllerApi;

pub fn main() {
    let id = 789; // Long
    let updateNewImageRequest = ; // UpdateNewImageRequest

    let mut context = NewsRestControllerApi::Context::default();
    let result = client.updateNewImage(id, updateNewImageRequest, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters

Name	Description
id*	Long (int64) Required

Body parameters

Name	Description
updateNewImageRequest

Responses

Schema

RegisterWebController

userExists

/userExists

Usage and SDK Samples

curl -X GET \
 -H "Accept: */*" \
 "http://127.0.0.1:8443/userExists?email=email_example"

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.RegisterWebControllerApi;

import java.io.File;
import java.util.*;

public class RegisterWebControllerApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        RegisterWebControllerApi apiInstance = new RegisterWebControllerApi();
        String email = email_example; // String | 

        try {
            'Boolean' result = apiInstance.userExists(email);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling RegisterWebControllerApi#userExists");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final String email = new String(); // String | 

try {
    final result = await api_instance.userExists(email);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->userExists: $e\n');
}

import org.openapitools.client.api.RegisterWebControllerApi;

public class RegisterWebControllerApiExample {
    public static void main(String[] args) {
        RegisterWebControllerApi apiInstance = new RegisterWebControllerApi();
        String email = email_example; // String | 

        try {
            'Boolean' result = apiInstance.userExists(email);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling RegisterWebControllerApi#userExists");
            e.printStackTrace();
        }
    }
}



// Create an instance of the API class
RegisterWebControllerApi *apiInstance = [[RegisterWebControllerApi alloc] init];
String *email = email_example; //  (default to null)

[apiInstance userExistsWith:email
              completionHandler: ^('Boolean' 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.RegisterWebControllerApi()
var email = email_example; // {String} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.userExists(email, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class userExistsExample
    {
        public void main()
        {

            // Create an instance of the API class
            var apiInstance = new RegisterWebControllerApi();
            var email = email_example;  // String |  (default to null)

            try {
                'Boolean' result = apiInstance.userExists(email);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling RegisterWebControllerApi.userExists: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\RegisterWebControllerApi();
$email = email_example; // String | 

try {
    $result = $api_instance->userExists($email);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling RegisterWebControllerApi->userExists: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::RegisterWebControllerApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::RegisterWebControllerApi->new();
my $email = email_example; # String | 

eval {
    my $result = $api_instance->userExists(email => $email);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling RegisterWebControllerApi->userExists: $@\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.RegisterWebControllerApi()
email = email_example # String |  (default to null)

try:
    api_response = api_instance.user_exists(email)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling RegisterWebControllerApi->userExists: %s\n" % e)

extern crate RegisterWebControllerApi;

pub fn main() {
    let email = email_example; // String

    let mut context = RegisterWebControllerApi::Context::default();
    let result = client.userExists(email, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Query parameters

Name	Description
email*	String Required

Responses

Schema

UsersRestController

deleteProfile

/api/v1/users/{id}

Usage and SDK Samples

curl -X DELETE \
 -H "Accept: */*" \
 "http://127.0.0.1:8443/api/v1/users/{id}"

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.UsersRestControllerApi;

import java.io.File;
import java.util.*;

public class UsersRestControllerApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        UsersRestControllerApi apiInstance = new UsersRestControllerApi();
        Long id = 789; // Long | 

        try {
            Object result = apiInstance.deleteProfile(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling UsersRestControllerApi#deleteProfile");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final Long id = new Long(); // Long | 

try {
    final result = await api_instance.deleteProfile(id);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->deleteProfile: $e\n');
}

import org.openapitools.client.api.UsersRestControllerApi;

public class UsersRestControllerApiExample {
    public static void main(String[] args) {
        UsersRestControllerApi apiInstance = new UsersRestControllerApi();
        Long id = 789; // Long | 

        try {
            Object result = apiInstance.deleteProfile(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling UsersRestControllerApi#deleteProfile");
            e.printStackTrace();
        }
    }
}



// Create an instance of the API class
UsersRestControllerApi *apiInstance = [[UsersRestControllerApi alloc] init];
Long *id = 789; //  (default to null)

[apiInstance deleteProfileWith:id
              completionHandler: ^(Object output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenApiDefinition = require('open_api_definition');

// Create an instance of the API class
var api = new OpenApiDefinition.UsersRestControllerApi()
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.deleteProfile(id, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class deleteProfileExample
    {
        public void main()
        {

            // Create an instance of the API class
            var apiInstance = new UsersRestControllerApi();
            var id = 789;  // Long |  (default to null)

            try {
                Object result = apiInstance.deleteProfile(id);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling UsersRestControllerApi.deleteProfile: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\UsersRestControllerApi();
$id = 789; // Long | 

try {
    $result = $api_instance->deleteProfile($id);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling UsersRestControllerApi->deleteProfile: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::UsersRestControllerApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::UsersRestControllerApi->new();
my $id = 789; # Long | 

eval {
    my $result = $api_instance->deleteProfile(id => $id);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling UsersRestControllerApi->deleteProfile: $@\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.UsersRestControllerApi()
id = 789 # Long |  (default to null)

try:
    api_response = api_instance.delete_profile(id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling UsersRestControllerApi->deleteProfile: %s\n" % e)

extern crate UsersRestControllerApi;

pub fn main() {
    let id = 789; // Long

    let mut context = UsersRestControllerApi::Context::default();
    let result = client.deleteProfile(id, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters

Name	Description
id*	Long (int64) Required

Responses

Schema

findAll

/api/v1/users/

Usage and SDK Samples

curl -X GET \
 -H "Accept: */*" \
 "http://127.0.0.1:8443/api/v1/users/?pageable="

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.UsersRestControllerApi;

import java.io.File;
import java.util.*;

public class UsersRestControllerApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        UsersRestControllerApi apiInstance = new UsersRestControllerApi();
        Pageable pageable = ; // Pageable | 

        try {
            PagedModelUserDTO result = apiInstance.findAll(pageable);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling UsersRestControllerApi#findAll");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final Pageable pageable = new Pageable(); // Pageable | 

try {
    final result = await api_instance.findAll(pageable);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->findAll: $e\n');
}

import org.openapitools.client.api.UsersRestControllerApi;

public class UsersRestControllerApiExample {
    public static void main(String[] args) {
        UsersRestControllerApi apiInstance = new UsersRestControllerApi();
        Pageable pageable = ; // Pageable | 

        try {
            PagedModelUserDTO result = apiInstance.findAll(pageable);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling UsersRestControllerApi#findAll");
            e.printStackTrace();
        }
    }
}



// Create an instance of the API class
UsersRestControllerApi *apiInstance = [[UsersRestControllerApi alloc] init];
Pageable *pageable = ; //  (default to null)

[apiInstance findAllWith:pageable
              completionHandler: ^(PagedModelUserDTO 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.UsersRestControllerApi()
var pageable = ; // {Pageable} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.findAll(pageable, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class findAllExample
    {
        public void main()
        {

            // Create an instance of the API class
            var apiInstance = new UsersRestControllerApi();
            var pageable = new Pageable(); // Pageable |  (default to null)

            try {
                PagedModelUserDTO result = apiInstance.findAll(pageable);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling UsersRestControllerApi.findAll: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\UsersRestControllerApi();
$pageable = ; // Pageable | 

try {
    $result = $api_instance->findAll($pageable);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling UsersRestControllerApi->findAll: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::UsersRestControllerApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::UsersRestControllerApi->new();
my $pageable = ; # Pageable | 

eval {
    my $result = $api_instance->findAll(pageable => $pageable);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling UsersRestControllerApi->findAll: $@\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.UsersRestControllerApi()
pageable =  # Pageable |  (default to null)

try:
    api_response = api_instance.find_all(pageable)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling UsersRestControllerApi->findAll: %s\n" % e)

extern crate UsersRestControllerApi;

pub fn main() {
    let pageable = ; // Pageable

    let mut context = UsersRestControllerApi::Context::default();
    let result = client.findAll(pageable, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Query parameters

Name	Description
pageable*	Pageable Required

Responses

Schema

getUser

/api/v1/users/{id}

Usage and SDK Samples

curl -X GET \
 -H "Accept: */*" \
 "http://127.0.0.1:8443/api/v1/users/{id}"

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.UsersRestControllerApi;

import java.io.File;
import java.util.*;

public class UsersRestControllerApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        UsersRestControllerApi apiInstance = new UsersRestControllerApi();
        Long id = 789; // Long | 

        try {
            UserDTO result = apiInstance.getUser(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling UsersRestControllerApi#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.UsersRestControllerApi;

public class UsersRestControllerApiExample {
    public static void main(String[] args) {
        UsersRestControllerApi apiInstance = new UsersRestControllerApi();
        Long id = 789; // Long | 

        try {
            UserDTO result = apiInstance.getUser(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling UsersRestControllerApi#getUser");
            e.printStackTrace();
        }
    }
}



// Create an instance of the API class
UsersRestControllerApi *apiInstance = [[UsersRestControllerApi alloc] init];
Long *id = 789; //  (default to null)

[apiInstance getUserWith:id
              completionHandler: ^(UserDTO 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.UsersRestControllerApi()
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 UsersRestControllerApi();
            var id = 789;  // Long |  (default to null)

            try {
                UserDTO result = apiInstance.getUser(id);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling UsersRestControllerApi.getUser: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\UsersRestControllerApi();
$id = 789; // Long | 

try {
    $result = $api_instance->getUser($id);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling UsersRestControllerApi->getUser: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::UsersRestControllerApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::UsersRestControllerApi->new();
my $id = 789; # Long | 

eval {
    my $result = $api_instance->getUser(id => $id);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling UsersRestControllerApi->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.UsersRestControllerApi()
id = 789 # Long |  (default to null)

try:
    api_response = api_instance.get_user(id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling UsersRestControllerApi->getUser: %s\n" % e)

extern crate UsersRestControllerApi;

pub fn main() {
    let id = 789; // Long

    let mut context = UsersRestControllerApi::Context::default();
    let result = client.getUser(id, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters

Name	Description
id*	Long (int64) Required

Responses

Schema

getUserImage

/api/v1/users/{id}/image

Usage and SDK Samples

curl -X GET \
 -H "Accept: */*" \
 "http://127.0.0.1:8443/api/v1/users/{id}/image"

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.UsersRestControllerApi;

import java.io.File;
import java.util.*;

public class UsersRestControllerApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        UsersRestControllerApi apiInstance = new UsersRestControllerApi();
        Long id = 789; // Long | 

        try {
            File result = apiInstance.getUserImage(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling UsersRestControllerApi#getUserImage");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final Long id = new Long(); // Long | 

try {
    final result = await api_instance.getUserImage(id);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->getUserImage: $e\n');
}

import org.openapitools.client.api.UsersRestControllerApi;

public class UsersRestControllerApiExample {
    public static void main(String[] args) {
        UsersRestControllerApi apiInstance = new UsersRestControllerApi();
        Long id = 789; // Long | 

        try {
            File result = apiInstance.getUserImage(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling UsersRestControllerApi#getUserImage");
            e.printStackTrace();
        }
    }
}



// Create an instance of the API class
UsersRestControllerApi *apiInstance = [[UsersRestControllerApi alloc] init];
Long *id = 789; //  (default to null)

[apiInstance getUserImageWith: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.UsersRestControllerApi()
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.getUserImage(id, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class getUserImageExample
    {
        public void main()
        {

            // Create an instance of the API class
            var apiInstance = new UsersRestControllerApi();
            var id = 789;  // Long |  (default to null)

            try {
                File result = apiInstance.getUserImage(id);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling UsersRestControllerApi.getUserImage: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\UsersRestControllerApi();
$id = 789; // Long | 

try {
    $result = $api_instance->getUserImage($id);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling UsersRestControllerApi->getUserImage: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::UsersRestControllerApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::UsersRestControllerApi->new();
my $id = 789; # Long | 

eval {
    my $result = $api_instance->getUserImage(id => $id);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling UsersRestControllerApi->getUserImage: $@\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.UsersRestControllerApi()
id = 789 # Long |  (default to null)

try:
    api_response = api_instance.get_user_image(id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling UsersRestControllerApi->getUserImage: %s\n" % e)

extern crate UsersRestControllerApi;

pub fn main() {
    let id = 789; // Long

    let mut context = UsersRestControllerApi::Context::default();
    let result = client.getUserImage(id, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters

Name	Description
id*	Long (int64) Required

Responses

Schema

putImage

/api/v1/users/{id}/image

Usage and SDK Samples

curl -X PUT \
 -H "Accept: */*" \
 -H "Content-Type: application/json" \
 "http://127.0.0.1:8443/api/v1/users/{id}/image" \
 -d ''

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.UsersRestControllerApi;

import java.io.File;
import java.util.*;

public class UsersRestControllerApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        UsersRestControllerApi apiInstance = new UsersRestControllerApi();
        Long id = 789; // Long | 
        PutImageRequest putImageRequest = ; // PutImageRequest | 

        try {
            ImageDTO result = apiInstance.putImage(id, putImageRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling UsersRestControllerApi#putImage");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final Long id = new Long(); // Long | 
final PutImageRequest putImageRequest = new PutImageRequest(); // PutImageRequest | 

try {
    final result = await api_instance.putImage(id, putImageRequest);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->putImage: $e\n');
}

import org.openapitools.client.api.UsersRestControllerApi;

public class UsersRestControllerApiExample {
    public static void main(String[] args) {
        UsersRestControllerApi apiInstance = new UsersRestControllerApi();
        Long id = 789; // Long | 
        PutImageRequest putImageRequest = ; // PutImageRequest | 

        try {
            ImageDTO result = apiInstance.putImage(id, putImageRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling UsersRestControllerApi#putImage");
            e.printStackTrace();
        }
    }
}



// Create an instance of the API class
UsersRestControllerApi *apiInstance = [[UsersRestControllerApi alloc] init];
Long *id = 789; //  (default to null)
PutImageRequest *putImageRequest = ; //  (optional)

[apiInstance putImageWith:id
    putImageRequest:putImageRequest
              completionHandler: ^(ImageDTO output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenApiDefinition = require('open_api_definition');

// Create an instance of the API class
var api = new OpenApiDefinition.UsersRestControllerApi()
var id = 789; // {Long} 
var opts = {
  'putImageRequest':  // {PutImageRequest} 
};

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.putImage(id, opts, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class putImageExample
    {
        public void main()
        {

            // Create an instance of the API class
            var apiInstance = new UsersRestControllerApi();
            var id = 789;  // Long |  (default to null)
            var putImageRequest = new PutImageRequest(); // PutImageRequest |  (optional) 

            try {
                ImageDTO result = apiInstance.putImage(id, putImageRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling UsersRestControllerApi.putImage: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\UsersRestControllerApi();
$id = 789; // Long | 
$putImageRequest = ; // PutImageRequest | 

try {
    $result = $api_instance->putImage($id, $putImageRequest);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling UsersRestControllerApi->putImage: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::UsersRestControllerApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::UsersRestControllerApi->new();
my $id = 789; # Long | 
my $putImageRequest = WWW::OPenAPIClient::Object::PutImageRequest->new(); # PutImageRequest | 

eval {
    my $result = $api_instance->putImage(id => $id, putImageRequest => $putImageRequest);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling UsersRestControllerApi->putImage: $@\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.UsersRestControllerApi()
id = 789 # Long |  (default to null)
putImageRequest =  # PutImageRequest |  (optional)

try:
    api_response = api_instance.put_image(id, putImageRequest=putImageRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling UsersRestControllerApi->putImage: %s\n" % e)

extern crate UsersRestControllerApi;

pub fn main() {
    let id = 789; // Long
    let putImageRequest = ; // PutImageRequest

    let mut context = UsersRestControllerApi::Context::default();
    let result = client.putImage(id, putImageRequest, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters

Name	Description
id*	Long (int64) Required

Body parameters

Name	Description
putImageRequest

Responses

Schema

register

/api/v1/users/

Usage and SDK Samples

curl -X POST \
 -H "Accept: */*" \
 -H "Content-Type: application/json" \
 "http://127.0.0.1:8443/api/v1/users/" \
 -d '{
  "password" : "password",
  "userNickname" : "userNickname",
  "confirmPassword" : "confirmPassword",
  "userEmail" : "userEmail",
  "userInterests" : "userInterests",
  "userName" : "userName",
  "userSurname" : "userSurname"
}'

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.UsersRestControllerApi;

import java.io.File;
import java.util.*;

public class UsersRestControllerApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        UsersRestControllerApi apiInstance = new UsersRestControllerApi();
        UserDetailsDTO userDetailsDTO = ; // UserDetailsDTO | 

        try {
            Object result = apiInstance.register(userDetailsDTO);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling UsersRestControllerApi#register");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final UserDetailsDTO userDetailsDTO = new UserDetailsDTO(); // UserDetailsDTO | 

try {
    final result = await api_instance.register(userDetailsDTO);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->register: $e\n');
}

import org.openapitools.client.api.UsersRestControllerApi;

public class UsersRestControllerApiExample {
    public static void main(String[] args) {
        UsersRestControllerApi apiInstance = new UsersRestControllerApi();
        UserDetailsDTO userDetailsDTO = ; // UserDetailsDTO | 

        try {
            Object result = apiInstance.register(userDetailsDTO);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling UsersRestControllerApi#register");
            e.printStackTrace();
        }
    }
}



// Create an instance of the API class
UsersRestControllerApi *apiInstance = [[UsersRestControllerApi alloc] init];
UserDetailsDTO *userDetailsDTO = ; // 

[apiInstance registerWith:userDetailsDTO
              completionHandler: ^(Object output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenApiDefinition = require('open_api_definition');

// Create an instance of the API class
var api = new OpenApiDefinition.UsersRestControllerApi()
var userDetailsDTO = ; // {UserDetailsDTO} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.register(userDetailsDTO, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class registerExample
    {
        public void main()
        {

            // Create an instance of the API class
            var apiInstance = new UsersRestControllerApi();
            var userDetailsDTO = new UserDetailsDTO(); // UserDetailsDTO | 

            try {
                Object result = apiInstance.register(userDetailsDTO);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling UsersRestControllerApi.register: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\UsersRestControllerApi();
$userDetailsDTO = ; // UserDetailsDTO | 

try {
    $result = $api_instance->register($userDetailsDTO);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling UsersRestControllerApi->register: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::UsersRestControllerApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::UsersRestControllerApi->new();
my $userDetailsDTO = WWW::OPenAPIClient::Object::UserDetailsDTO->new(); # UserDetailsDTO | 

eval {
    my $result = $api_instance->register(userDetailsDTO => $userDetailsDTO);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling UsersRestControllerApi->register: $@\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.UsersRestControllerApi()
userDetailsDTO =  # UserDetailsDTO | 

try:
    api_response = api_instance.register(userDetailsDTO)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling UsersRestControllerApi->register: %s\n" % e)

extern crate UsersRestControllerApi;

pub fn main() {
    let userDetailsDTO = ; // UserDetailsDTO

    let mut context = UsersRestControllerApi::Context::default();
    let result = client.register(userDetailsDTO, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Body parameters

Name	Description
userDetailsDTO *

Responses

Schema

updateProfile

/api/v1/users/{id}

Usage and SDK Samples

curl -X PUT \
 -H "Accept: */*" \
 -H "Content-Type: application/json" \
 "http://127.0.0.1:8443/api/v1/users/{id}" \
 -d '{
  "password" : "password",
  "userNickname" : "userNickname",
  "confirmPassword" : "confirmPassword",
  "userEmail" : "userEmail",
  "userInterests" : "userInterests",
  "userName" : "userName",
  "userSurname" : "userSurname"
}'

import org.openapitools.client.*;
import org.openapitools.client.auth.*;
import org.openapitools.client.model.*;
import org.openapitools.client.api.UsersRestControllerApi;

import java.io.File;
import java.util.*;

public class UsersRestControllerApiExample {
    public static void main(String[] args) {

        // Create an instance of the API class
        UsersRestControllerApi apiInstance = new UsersRestControllerApi();
        Long id = 789; // Long | 
        UserDetailsDTO userDetailsDTO = ; // UserDetailsDTO | 

        try {
            UserDTO result = apiInstance.updateProfile(id, userDetailsDTO);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling UsersRestControllerApi#updateProfile");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final Long id = new Long(); // Long | 
final UserDetailsDTO userDetailsDTO = new UserDetailsDTO(); // UserDetailsDTO | 

try {
    final result = await api_instance.updateProfile(id, userDetailsDTO);
    print(result);
} catch (e) {
    print('Exception when calling DefaultApi->updateProfile: $e\n');
}

import org.openapitools.client.api.UsersRestControllerApi;

public class UsersRestControllerApiExample {
    public static void main(String[] args) {
        UsersRestControllerApi apiInstance = new UsersRestControllerApi();
        Long id = 789; // Long | 
        UserDetailsDTO userDetailsDTO = ; // UserDetailsDTO | 

        try {
            UserDTO result = apiInstance.updateProfile(id, userDetailsDTO);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling UsersRestControllerApi#updateProfile");
            e.printStackTrace();
        }
    }
}



// Create an instance of the API class
UsersRestControllerApi *apiInstance = [[UsersRestControllerApi alloc] init];
Long *id = 789; //  (default to null)
UserDetailsDTO *userDetailsDTO = ; // 

[apiInstance updateProfileWith:id
    userDetailsDTO:userDetailsDTO
              completionHandler: ^(UserDTO 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.UsersRestControllerApi()
var id = 789; // {Long} 
var userDetailsDTO = ; // {UserDetailsDTO} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully. Returned data: ' + data);
  }
};
api.updateProfile(id, userDetailsDTO, callback);

using System;
using System.Diagnostics;
using Org.OpenAPITools.Api;
using Org.OpenAPITools.Client;
using Org.OpenAPITools.Model;

namespace Example
{
    public class updateProfileExample
    {
        public void main()
        {

            // Create an instance of the API class
            var apiInstance = new UsersRestControllerApi();
            var id = 789;  // Long |  (default to null)
            var userDetailsDTO = new UserDetailsDTO(); // UserDetailsDTO | 

            try {
                UserDTO result = apiInstance.updateProfile(id, userDetailsDTO);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling UsersRestControllerApi.updateProfile: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\UsersRestControllerApi();
$id = 789; // Long | 
$userDetailsDTO = ; // UserDetailsDTO | 

try {
    $result = $api_instance->updateProfile($id, $userDetailsDTO);
    print_r($result);
} catch (Exception $e) {
    echo 'Exception when calling UsersRestControllerApi->updateProfile: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::OPenAPIClient::Configuration;
use WWW::OPenAPIClient::UsersRestControllerApi;

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::UsersRestControllerApi->new();
my $id = 789; # Long | 
my $userDetailsDTO = WWW::OPenAPIClient::Object::UserDetailsDTO->new(); # UserDetailsDTO | 

eval {
    my $result = $api_instance->updateProfile(id => $id, userDetailsDTO => $userDetailsDTO);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling UsersRestControllerApi->updateProfile: $@\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.UsersRestControllerApi()
id = 789 # Long |  (default to null)
userDetailsDTO =  # UserDetailsDTO | 

try:
    api_response = api_instance.update_profile(id, userDetailsDTO)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling UsersRestControllerApi->updateProfile: %s\n" % e)

extern crate UsersRestControllerApi;

pub fn main() {
    let id = 789; // Long
    let userDetailsDTO = ; // UserDetailsDTO

    let mut context = UsersRestControllerApi::Context::default();
    let result = client.updateProfile(id, userDetailsDTO, &context).wait();

    println!("{:?}", result);
}

Scopes

Parameters

Path parameters

Name	Description
id*	Long (int64) Required

Body parameters

Name	Description
userDetailsDTO *

Responses

Schema

OpenAPI definition

API and SDK Documentation

AdministrationController

topEventsParticipants

Usage and SDK Samples

Scopes

Parameters

Responses

topFavoriteGames

Usage and SDK Samples

Scopes

Parameters

Responses

AdministrationRestController

approveEvent

Usage and SDK Samples

Scopes

Parameters

Responses

approveNew

Usage and SDK Samples

Scopes

Parameters

Responses

getTopEvents

Usage and SDK Samples

Scopes

Parameters

Responses

getTopGames

Usage and SDK Samples

Scopes

Parameters

Responses

rejectEvent

Usage and SDK Samples

Scopes

Parameters

Responses

rejectNew

Usage and SDK Samples

Scopes

Parameters

Responses

CustomErrorRestController

handleError

Usage and SDK Samples

Scopes

Parameters

Responses

handleError1

Usage and SDK Samples

Scopes

Parameters

Responses

handleError2

Usage and SDK Samples

Scopes

Parameters

Responses

handleError3

Usage and SDK Samples

Scopes

Parameters

Responses

handleError4

Usage and SDK Samples

Scopes

Parameters

Responses

handleError5

Usage and SDK Samples

Scopes

Parameters

Responses

handleError6

Usage and SDK Samples

Scopes

Parameters

Responses