OpenAPI definition

Authentication

login

Login and obtain a JWT token


/api/v1/auth/login

Usage and SDK Samples

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

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

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

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

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

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

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

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


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

// Login and obtain a JWT token
[apiInstance loginWith:loginRequest
              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.AuthenticationApi()
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 AuthenticationApi();
            var loginRequest = new LoginRequest(); // LoginRequest | 

            try {
                // Login and obtain a JWT token
                Object result = apiInstance.login(loginRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling AuthenticationApi.login: " + e.Message );
            }
        }
    }
}

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

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

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

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

try:
    # Login and obtain a JWT token
    api_response = api_instance.login(loginRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AuthenticationApi->login: %s\n" % e)
extern crate AuthenticationApi;

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

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

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

Scopes

Parameters

Body parameters
Name Description
loginRequest *

Responses

register

Register a new user and obtain a JWT token


/api/v1/auth/register

Usage and SDK Samples

curl -X POST \
 -H "Accept: */*" \
 -H "Content-Type: application/json" \
 "https://localhost:8443/api/v1/auth/register" \
 -d '{
  "password" : "password",
  "university" : "university",
  "name" : "name",
  "nickname" : "nickname",
  "email" : "email"
}'

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

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

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

        // Create an instance of the API class
        AuthenticationApi apiInstance = new AuthenticationApi();
        RegisterRequest registerRequest = ; // RegisterRequest | 

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final RegisterRequest registerRequest = new RegisterRequest(); // RegisterRequest | 

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


import org.openapitools.client.api.AuthenticationApi;

public class AuthenticationApiExample {
    public static void main(String[] args) {
        AuthenticationApi apiInstance = new AuthenticationApi();
        RegisterRequest registerRequest = ; // RegisterRequest | 

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


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

// Register a new user and obtain a JWT token
[apiInstance registerWith:registerRequest
              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.AuthenticationApi()
var registerRequest = ; // {RegisterRequest} 

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

            try {
                // Register a new user and obtain a JWT token
                Object result = apiInstance.register(registerRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling AuthenticationApi.register: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\AuthenticationApi();
$registerRequest = ; // RegisterRequest | 

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::AuthenticationApi->new();
my $registerRequest = WWW::OPenAPIClient::Object::RegisterRequest->new(); # RegisterRequest | 

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

try:
    # Register a new user and obtain a JWT token
    api_response = api_instance.register(registerRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling AuthenticationApi->register: %s\n" % e)
extern crate AuthenticationApi;

pub fn main() {
    let registerRequest = ; // RegisterRequest

    let mut context = AuthenticationApi::Context::default();
    let result = client.register(registerRequest, &context).wait();

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

Scopes

Parameters

Body parameters
Name Description
registerRequest *

Responses

ImageController

downloadImage


/images/{entity}/{id}

Usage and SDK Samples

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

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

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

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

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

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

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

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


import org.openapitools.client.api.ImageControllerApi;

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

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


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

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

var OpenApiDefinition = require('open_api_definition');

// Create an instance of the API class
var api = new OpenApiDefinition.ImageControllerApi()
var entity = entity_example; // {String} 
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.downloadImage(entity, id, callback);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Scopes

Parameters

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

Responses

downloadTeamBanner


/images/teams/banner/{id}

Usage and SDK Samples

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

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

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

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

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

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

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

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


import org.openapitools.client.api.ImageControllerApi;

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

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


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

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

var OpenApiDefinition = require('open_api_definition');

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Scopes

Parameters

Path parameters
Name Description
id*
Long (int64)
Required

Responses

Matches

createMatch

Create a match (ADMIN)


/api/v1/matches

Usage and SDK Samples

curl -X POST \
 -H "Accept: */*" \
 -H "Content-Type: application/json" \
 "https://localhost:8443/api/v1/matches" \
 -d '{
  "phase" : "phase",
  "localTeamId" : 6,
  "matchDate" : "matchDate",
  "notes" : "notes",
  "tournamentId" : 0,
  "format" : "format",
  "awayTeamId" : 1
}'

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

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

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

        // Create an instance of the API class
        MatchesApi apiInstance = new MatchesApi();
        MatchCreateRequest matchCreateRequest = ; // MatchCreateRequest | 

        try {
            MatchResponse result = apiInstance.createMatch(matchCreateRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling MatchesApi#createMatch");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final MatchCreateRequest matchCreateRequest = new MatchCreateRequest(); // MatchCreateRequest | 

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


import org.openapitools.client.api.MatchesApi;

public class MatchesApiExample {
    public static void main(String[] args) {
        MatchesApi apiInstance = new MatchesApi();
        MatchCreateRequest matchCreateRequest = ; // MatchCreateRequest | 

        try {
            MatchResponse result = apiInstance.createMatch(matchCreateRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling MatchesApi#createMatch");
            e.printStackTrace();
        }
    }
}


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

// Create a match (ADMIN)
[apiInstance createMatchWith:matchCreateRequest
              completionHandler: ^(MatchResponse 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.MatchesApi()
var matchCreateRequest = ; // {MatchCreateRequest} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new MatchesApi();
            var matchCreateRequest = new MatchCreateRequest(); // MatchCreateRequest | 

            try {
                // Create a match (ADMIN)
                MatchResponse result = apiInstance.createMatch(matchCreateRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling MatchesApi.createMatch: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\MatchesApi();
$matchCreateRequest = ; // MatchCreateRequest | 

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::MatchesApi->new();
my $matchCreateRequest = WWW::OPenAPIClient::Object::MatchCreateRequest->new(); # MatchCreateRequest | 

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

try:
    # Create a match (ADMIN)
    api_response = api_instance.create_match(matchCreateRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling MatchesApi->createMatch: %s\n" % e)
extern crate MatchesApi;

pub fn main() {
    let matchCreateRequest = ; // MatchCreateRequest

    let mut context = MatchesApi::Context::default();
    let result = client.createMatch(matchCreateRequest, &context).wait();

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

Scopes

Parameters

Body parameters
Name Description
matchCreateRequest *

Responses

deleteMatch

Delete a match (ADMIN)


/api/v1/matches/{id}

Usage and SDK Samples

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

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

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

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

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

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

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

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


import org.openapitools.client.api.MatchesApi;

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

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


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

// Delete a match (ADMIN)
[apiInstance deleteMatchWith: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.MatchesApi()
var id = 789; // {Long} 

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

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

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

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

            try {
                // Delete a match (ADMIN)
                apiInstance.deleteMatch(id);
            } catch (Exception e) {
                Debug.Print("Exception when calling MatchesApi.deleteMatch: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

try:
    # Delete a match (ADMIN)
    api_instance.delete_match(id)
except ApiException as e:
    print("Exception when calling MatchesApi->deleteMatch: %s\n" % e)
extern crate MatchesApi;

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

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

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

Scopes

Parameters

Path parameters
Name Description
id*
Long (int64)
Required

Responses

getMatch

Get match details


/api/v1/matches/{id}

Usage and SDK Samples

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

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

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

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

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

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

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

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


import org.openapitools.client.api.MatchesApi;

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

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


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

// Get match details
[apiInstance getMatchWith:id
              completionHandler: ^(MatchResponse 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.MatchesApi()
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.getMatch(id, callback);

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

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

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

            try {
                // Get match details
                MatchResponse result = apiInstance.getMatch(id);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling MatchesApi.getMatch: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

try:
    # Get match details
    api_response = api_instance.get_match(id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling MatchesApi->getMatch: %s\n" % e)
extern crate MatchesApi;

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

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

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

Scopes

Parameters

Path parameters
Name Description
id*
Long (int64)
Required

Responses

listMatches

List all matches (paginated)


/api/v1/matches

Usage and SDK Samples

curl -X GET \
 -H "Accept: */*" \
 "https://localhost:8443/api/v1/matches?page=56&size=56&tournamentId=789&state=state_example"

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

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

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

        // Create an instance of the API class
        MatchesApi apiInstance = new MatchesApi();
        Integer page = 56; // Integer | Page number
        Integer size = 56; // Integer | Page size
        Long tournamentId = 789; // Long | Filter by tournament ID
        String state = state_example; // String | Filter by state

        try {
            PageMatchResponse result = apiInstance.listMatches(page, size, tournamentId, state);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling MatchesApi#listMatches");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final Integer page = new Integer(); // Integer | Page number
final Integer size = new Integer(); // Integer | Page size
final Long tournamentId = new Long(); // Long | Filter by tournament ID
final String state = new String(); // String | Filter by state

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


import org.openapitools.client.api.MatchesApi;

public class MatchesApiExample {
    public static void main(String[] args) {
        MatchesApi apiInstance = new MatchesApi();
        Integer page = 56; // Integer | Page number
        Integer size = 56; // Integer | Page size
        Long tournamentId = 789; // Long | Filter by tournament ID
        String state = state_example; // String | Filter by state

        try {
            PageMatchResponse result = apiInstance.listMatches(page, size, tournamentId, state);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling MatchesApi#listMatches");
            e.printStackTrace();
        }
    }
}


// Create an instance of the API class
MatchesApi *apiInstance = [[MatchesApi alloc] init];
Integer *page = 56; // Page number (optional) (default to 0)
Integer *size = 56; // Page size (optional) (default to 10)
Long *tournamentId = 789; // Filter by tournament ID (optional) (default to null)
String *state = state_example; // Filter by state (optional) (default to null)

// List all matches (paginated)
[apiInstance listMatchesWith:page
    size:size
    tournamentId:tournamentId
    state:state
              completionHandler: ^(PageMatchResponse 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.MatchesApi()
var opts = {
  'page': 56, // {Integer} Page number
  'size': 56, // {Integer} Page size
  'tournamentId': 789, // {Long} Filter by tournament ID
  'state': state_example // {String} Filter by state
};

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

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

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

            // Create an instance of the API class
            var apiInstance = new MatchesApi();
            var page = 56;  // Integer | Page number (optional)  (default to 0)
            var size = 56;  // Integer | Page size (optional)  (default to 10)
            var tournamentId = 789;  // Long | Filter by tournament ID (optional)  (default to null)
            var state = state_example;  // String | Filter by state (optional)  (default to null)

            try {
                // List all matches (paginated)
                PageMatchResponse result = apiInstance.listMatches(page, size, tournamentId, state);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling MatchesApi.listMatches: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\MatchesApi();
$page = 56; // Integer | Page number
$size = 56; // Integer | Page size
$tournamentId = 789; // Long | Filter by tournament ID
$state = state_example; // String | Filter by state

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::MatchesApi->new();
my $page = 56; # Integer | Page number
my $size = 56; # Integer | Page size
my $tournamentId = 789; # Long | Filter by tournament ID
my $state = state_example; # String | Filter by state

eval {
    my $result = $api_instance->listMatches(page => $page, size => $size, tournamentId => $tournamentId, state => $state);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling MatchesApi->listMatches: $@\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.MatchesApi()
page = 56 # Integer | Page number (optional) (default to 0)
size = 56 # Integer | Page size (optional) (default to 10)
tournamentId = 789 # Long | Filter by tournament ID (optional) (default to null)
state = state_example # String | Filter by state (optional) (default to null)

try:
    # List all matches (paginated)
    api_response = api_instance.list_matches(page=page, size=size, tournamentId=tournamentId, state=state)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling MatchesApi->listMatches: %s\n" % e)
extern crate MatchesApi;

pub fn main() {
    let page = 56; // Integer
    let size = 56; // Integer
    let tournamentId = 789; // Long
    let state = state_example; // String

    let mut context = MatchesApi::Context::default();
    let result = client.listMatches(page, size, tournamentId, state, &context).wait();

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

Scopes

Parameters

Query parameters
Name Description
page
Integer (int32)
Page number
size
Integer (int32)
Page size
tournamentId
Long (int64)
Filter by tournament ID
state
String
Filter by state

Responses

updateMatch

Update a match (ADMIN)


/api/v1/matches/{id}

Usage and SDK Samples

curl -X PUT \
 -H "Accept: */*" \
 -H "Content-Type: application/json" \
 "https://localhost:8443/api/v1/matches/{id}" \
 -d '{
  "phase" : "phase",
  "scoreLocal" : 1,
  "localTeamId" : 0,
  "matchDate" : "matchDate",
  "notes" : "notes",
  "format" : "format",
  "state" : "state",
  "scoreAway" : 5,
  "awayTeamId" : 6
}'

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

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

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

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

        try {
            MatchResponse result = apiInstance.updateMatch(id, matchUpdateRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling MatchesApi#updateMatch");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

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

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


import org.openapitools.client.api.MatchesApi;

public class MatchesApiExample {
    public static void main(String[] args) {
        MatchesApi apiInstance = new MatchesApi();
        Long id = 789; // Long | 
        MatchUpdateRequest matchUpdateRequest = ; // MatchUpdateRequest | 

        try {
            MatchResponse result = apiInstance.updateMatch(id, matchUpdateRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling MatchesApi#updateMatch");
            e.printStackTrace();
        }
    }
}


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

// Update a match (ADMIN)
[apiInstance updateMatchWith:id
    matchUpdateRequest:matchUpdateRequest
              completionHandler: ^(MatchResponse 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.MatchesApi()
var id = 789; // {Long} 
var matchUpdateRequest = ; // {MatchUpdateRequest} 

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

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

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

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

            try {
                // Update a match (ADMIN)
                MatchResponse result = apiInstance.updateMatch(id, matchUpdateRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling MatchesApi.updateMatch: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

try:
    # Update a match (ADMIN)
    api_response = api_instance.update_match(id, matchUpdateRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling MatchesApi->updateMatch: %s\n" % e)
extern crate MatchesApi;

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

    let mut context = MatchesApi::Context::default();
    let result = client.updateMatch(id, matchUpdateRequest, &context).wait();

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

Scopes

Parameters

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

Responses

Messages

deleteMessage

Delete a message (sender or ADMIN)


/api/v1/messages/{id}

Usage and SDK Samples

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

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

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

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

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

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

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

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


import org.openapitools.client.api.MessagesApi;

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

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


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

// Delete a message (sender or ADMIN)
[apiInstance deleteMessageWith: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.MessagesApi()
var id = 789; // {Long} 

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

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

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

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

            try {
                // Delete a message (sender or ADMIN)
                apiInstance.deleteMessage(id);
            } catch (Exception e) {
                Debug.Print("Exception when calling MessagesApi.deleteMessage: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

try:
    # Delete a message (sender or ADMIN)
    api_instance.delete_message(id)
except ApiException as e:
    print("Exception when calling MessagesApi->deleteMessage: %s\n" % e)
extern crate MessagesApi;

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

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

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

Scopes

Parameters

Path parameters
Name Description
id*
Long (int64)
Required

Responses

listMessages

List messages for authenticated user (paginated)


/api/v1/messages

Usage and SDK Samples

curl -X GET \
 -H "Accept: */*" \
 "https://localhost:8443/api/v1/messages?page=56&size=56"

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

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

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

        // Create an instance of the API class
        MessagesApi apiInstance = new MessagesApi();
        Integer page = 56; // Integer | Page number
        Integer size = 56; // Integer | Page size

        try {
            PageMessageResponse result = apiInstance.listMessages(page, size);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling MessagesApi#listMessages");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final Integer page = new Integer(); // Integer | Page number
final Integer size = new Integer(); // Integer | Page size

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


import org.openapitools.client.api.MessagesApi;

public class MessagesApiExample {
    public static void main(String[] args) {
        MessagesApi apiInstance = new MessagesApi();
        Integer page = 56; // Integer | Page number
        Integer size = 56; // Integer | Page size

        try {
            PageMessageResponse result = apiInstance.listMessages(page, size);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling MessagesApi#listMessages");
            e.printStackTrace();
        }
    }
}


// Create an instance of the API class
MessagesApi *apiInstance = [[MessagesApi alloc] init];
Integer *page = 56; // Page number (optional) (default to 0)
Integer *size = 56; // Page size (optional) (default to 10)

// List messages for authenticated user (paginated)
[apiInstance listMessagesWith:page
    size:size
              completionHandler: ^(PageMessageResponse 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.MessagesApi()
var opts = {
  'page': 56, // {Integer} Page number
  'size': 56 // {Integer} Page size
};

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

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

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

            // Create an instance of the API class
            var apiInstance = new MessagesApi();
            var page = 56;  // Integer | Page number (optional)  (default to 0)
            var size = 56;  // Integer | Page size (optional)  (default to 10)

            try {
                // List messages for authenticated user (paginated)
                PageMessageResponse result = apiInstance.listMessages(page, size);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling MessagesApi.listMessages: " + e.Message );
            }
        }
    }
}

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

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

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

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

eval {
    my $result = $api_instance->listMessages(page => $page, size => $size);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling MessagesApi->listMessages: $@\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.MessagesApi()
page = 56 # Integer | Page number (optional) (default to 0)
size = 56 # Integer | Page size (optional) (default to 10)

try:
    # List messages for authenticated user (paginated)
    api_response = api_instance.list_messages(page=page, size=size)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling MessagesApi->listMessages: %s\n" % e)
extern crate MessagesApi;

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

    let mut context = MessagesApi::Context::default();
    let result = client.listMessages(page, size, &context).wait();

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

Scopes

Parameters

Query parameters
Name Description
page
Integer (int32)
Page number
size
Integer (int32)
Page size

Responses

sendMessage

Send a message (ADMIN)


/api/v1/messages

Usage and SDK Samples

curl -X POST \
 -H "Accept: */*" \
 -H "Content-Type: application/json" \
 "https://localhost:8443/api/v1/messages" \
 -d '{
  "subject" : "subject",
  "recipientId" : 0,
  "content" : "content"
}'

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

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

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

        // Create an instance of the API class
        MessagesApi apiInstance = new MessagesApi();
        MessageCreateRequest messageCreateRequest = ; // MessageCreateRequest | 

        try {
            MessageResponse result = apiInstance.sendMessage(messageCreateRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling MessagesApi#sendMessage");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final MessageCreateRequest messageCreateRequest = new MessageCreateRequest(); // MessageCreateRequest | 

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


import org.openapitools.client.api.MessagesApi;

public class MessagesApiExample {
    public static void main(String[] args) {
        MessagesApi apiInstance = new MessagesApi();
        MessageCreateRequest messageCreateRequest = ; // MessageCreateRequest | 

        try {
            MessageResponse result = apiInstance.sendMessage(messageCreateRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling MessagesApi#sendMessage");
            e.printStackTrace();
        }
    }
}


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

// Send a message (ADMIN)
[apiInstance sendMessageWith:messageCreateRequest
              completionHandler: ^(MessageResponse 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.MessagesApi()
var messageCreateRequest = ; // {MessageCreateRequest} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new MessagesApi();
            var messageCreateRequest = new MessageCreateRequest(); // MessageCreateRequest | 

            try {
                // Send a message (ADMIN)
                MessageResponse result = apiInstance.sendMessage(messageCreateRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling MessagesApi.sendMessage: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\MessagesApi();
$messageCreateRequest = ; // MessageCreateRequest | 

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::MessagesApi->new();
my $messageCreateRequest = WWW::OPenAPIClient::Object::MessageCreateRequest->new(); # MessageCreateRequest | 

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

try:
    # Send a message (ADMIN)
    api_response = api_instance.send_message(messageCreateRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling MessagesApi->sendMessage: %s\n" % e)
extern crate MessagesApi;

pub fn main() {
    let messageCreateRequest = ; // MessageCreateRequest

    let mut context = MessagesApi::Context::default();
    let result = client.sendMessage(messageCreateRequest, &context).wait();

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

Scopes

Parameters

Body parameters
Name Description
messageCreateRequest *

Responses

TeamController

getTeamPlayers


/api/teams/{id}/players

Usage and SDK Samples

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

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

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

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

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

        try {
            array[map['String', Object]] result = apiInstance.getTeamPlayers(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling TeamControllerApi#getTeamPlayers");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

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

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


import org.openapitools.client.api.TeamControllerApi;

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

        try {
            array[map['String', Object]] result = apiInstance.getTeamPlayers(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling TeamControllerApi#getTeamPlayers");
            e.printStackTrace();
        }
    }
}


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

[apiInstance getTeamPlayersWith:id
              completionHandler: ^(array[map['String', 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.TeamControllerApi()
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.getTeamPlayers(id, callback);

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

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

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

            try {
                array[map['String', Object]] result = apiInstance.getTeamPlayers(id);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling TeamControllerApi.getTeamPlayers: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

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

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

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

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

Scopes

Parameters

Path parameters
Name Description
id*
Long (int64)
Required

Responses

Teams

createTeam

Create a team (authenticated)


/api/v1/teams

Usage and SDK Samples

curl -X POST \
 -H "Accept: */*" \
 -H "Content-Type: application/json" \
 "https://localhost:8443/api/v1/teams" \
 -d '{
  "mainGame" : "mainGame",
  "university" : "university",
  "name" : "name",
  "description" : "description",
  "tag" : "tag"
}'

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

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

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

        // Create an instance of the API class
        TeamsApi apiInstance = new TeamsApi();
        TeamCreateRequest teamCreateRequest = ; // TeamCreateRequest | 

        try {
            TeamResponse result = apiInstance.createTeam(teamCreateRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling TeamsApi#createTeam");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final TeamCreateRequest teamCreateRequest = new TeamCreateRequest(); // TeamCreateRequest | 

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


import org.openapitools.client.api.TeamsApi;

public class TeamsApiExample {
    public static void main(String[] args) {
        TeamsApi apiInstance = new TeamsApi();
        TeamCreateRequest teamCreateRequest = ; // TeamCreateRequest | 

        try {
            TeamResponse result = apiInstance.createTeam(teamCreateRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling TeamsApi#createTeam");
            e.printStackTrace();
        }
    }
}


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

// Create a team (authenticated)
[apiInstance createTeamWith:teamCreateRequest
              completionHandler: ^(TeamResponse 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.TeamsApi()
var teamCreateRequest = ; // {TeamCreateRequest} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new TeamsApi();
            var teamCreateRequest = new TeamCreateRequest(); // TeamCreateRequest | 

            try {
                // Create a team (authenticated)
                TeamResponse result = apiInstance.createTeam(teamCreateRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling TeamsApi.createTeam: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\TeamsApi();
$teamCreateRequest = ; // TeamCreateRequest | 

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::TeamsApi->new();
my $teamCreateRequest = WWW::OPenAPIClient::Object::TeamCreateRequest->new(); # TeamCreateRequest | 

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

try:
    # Create a team (authenticated)
    api_response = api_instance.create_team(teamCreateRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling TeamsApi->createTeam: %s\n" % e)
extern crate TeamsApi;

pub fn main() {
    let teamCreateRequest = ; // TeamCreateRequest

    let mut context = TeamsApi::Context::default();
    let result = client.createTeam(teamCreateRequest, &context).wait();

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

Scopes

Parameters

Body parameters
Name Description
teamCreateRequest *

Responses

deleteTeam

Delete a team (captain or ADMIN)


/api/v1/teams/{id}

Usage and SDK Samples

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

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

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

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

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

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

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

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


import org.openapitools.client.api.TeamsApi;

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

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


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

// Delete a team (captain or ADMIN)
[apiInstance deleteTeamWith: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.TeamsApi()
var id = 789; // {Long} 

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

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

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

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

            try {
                // Delete a team (captain or ADMIN)
                apiInstance.deleteTeam(id);
            } catch (Exception e) {
                Debug.Print("Exception when calling TeamsApi.deleteTeam: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

try:
    # Delete a team (captain or ADMIN)
    api_instance.delete_team(id)
except ApiException as e:
    print("Exception when calling TeamsApi->deleteTeam: %s\n" % e)
extern crate TeamsApi;

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

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

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

Scopes

Parameters

Path parameters
Name Description
id*
Long (int64)
Required

Responses

getTeam

Get team details


/api/v1/teams/{id}

Usage and SDK Samples

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

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

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

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

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

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

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

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


import org.openapitools.client.api.TeamsApi;

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

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


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

// Get team details
[apiInstance getTeamWith:id
              completionHandler: ^(TeamResponse 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.TeamsApi()
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.getTeam(id, callback);

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

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

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

            try {
                // Get team details
                TeamResponse result = apiInstance.getTeam(id);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling TeamsApi.getTeam: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

try:
    # Get team details
    api_response = api_instance.get_team(id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling TeamsApi->getTeam: %s\n" % e)
extern crate TeamsApi;

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

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

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

Scopes

Parameters

Path parameters
Name Description
id*
Long (int64)
Required

Responses

getTeamImage

Get team logo image


/api/v1/teams/{id}/image

Usage and SDK Samples

curl -X GET \
 -H "Accept: */*,image/jpeg,image/png" \
 "https://localhost:8443/api/v1/teams/{id}/image"

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

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

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

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

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

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

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


import org.openapitools.client.api.TeamsApi;

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

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


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

// Get team logo image
[apiInstance getTeamImageWith:id
              completionHandler: ^(array[byte[]] output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenApiDefinition = require('open_api_definition');

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

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

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

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

            try {
                // Get team logo image
                array[byte[]] result = apiInstance.getTeamImage(id);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling TeamsApi.getTeamImage: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

try:
    # Get team logo image
    api_response = api_instance.get_team_image(id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling TeamsApi->getTeamImage: %s\n" % e)
extern crate TeamsApi;

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

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

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

Scopes

Parameters

Path parameters
Name Description
id*
Long (int64)
Required

Responses

listTeams

List all teams (paginated)


/api/v1/teams

Usage and SDK Samples

curl -X GET \
 -H "Accept: */*" \
 "https://localhost:8443/api/v1/teams?page=56&size=56&search=search_example&game=game_example"

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

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

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

        // Create an instance of the API class
        TeamsApi apiInstance = new TeamsApi();
        Integer page = 56; // Integer | Page number
        Integer size = 56; // Integer | Page size
        String search = search_example; // String | Search by name
        String game = game_example; // String | Filter by game

        try {
            PageTeamResponse result = apiInstance.listTeams(page, size, search, game);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling TeamsApi#listTeams");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final Integer page = new Integer(); // Integer | Page number
final Integer size = new Integer(); // Integer | Page size
final String search = new String(); // String | Search by name
final String game = new String(); // String | Filter by game

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


import org.openapitools.client.api.TeamsApi;

public class TeamsApiExample {
    public static void main(String[] args) {
        TeamsApi apiInstance = new TeamsApi();
        Integer page = 56; // Integer | Page number
        Integer size = 56; // Integer | Page size
        String search = search_example; // String | Search by name
        String game = game_example; // String | Filter by game

        try {
            PageTeamResponse result = apiInstance.listTeams(page, size, search, game);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling TeamsApi#listTeams");
            e.printStackTrace();
        }
    }
}


// Create an instance of the API class
TeamsApi *apiInstance = [[TeamsApi alloc] init];
Integer *page = 56; // Page number (optional) (default to 0)
Integer *size = 56; // Page size (optional) (default to 10)
String *search = search_example; // Search by name (optional) (default to null)
String *game = game_example; // Filter by game (optional) (default to null)

// List all teams (paginated)
[apiInstance listTeamsWith:page
    size:size
    search:search
    game:game
              completionHandler: ^(PageTeamResponse 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.TeamsApi()
var opts = {
  'page': 56, // {Integer} Page number
  'size': 56, // {Integer} Page size
  'search': search_example, // {String} Search by name
  'game': game_example // {String} Filter by game
};

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

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

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

            // Create an instance of the API class
            var apiInstance = new TeamsApi();
            var page = 56;  // Integer | Page number (optional)  (default to 0)
            var size = 56;  // Integer | Page size (optional)  (default to 10)
            var search = search_example;  // String | Search by name (optional)  (default to null)
            var game = game_example;  // String | Filter by game (optional)  (default to null)

            try {
                // List all teams (paginated)
                PageTeamResponse result = apiInstance.listTeams(page, size, search, game);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling TeamsApi.listTeams: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\TeamsApi();
$page = 56; // Integer | Page number
$size = 56; // Integer | Page size
$search = search_example; // String | Search by name
$game = game_example; // String | Filter by game

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::TeamsApi->new();
my $page = 56; # Integer | Page number
my $size = 56; # Integer | Page size
my $search = search_example; # String | Search by name
my $game = game_example; # String | Filter by game

eval {
    my $result = $api_instance->listTeams(page => $page, size => $size, search => $search, game => $game);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling TeamsApi->listTeams: $@\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.TeamsApi()
page = 56 # Integer | Page number (optional) (default to 0)
size = 56 # Integer | Page size (optional) (default to 10)
search = search_example # String | Search by name (optional) (default to null)
game = game_example # String | Filter by game (optional) (default to null)

try:
    # List all teams (paginated)
    api_response = api_instance.list_teams(page=page, size=size, search=search, game=game)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling TeamsApi->listTeams: %s\n" % e)
extern crate TeamsApi;

pub fn main() {
    let page = 56; // Integer
    let size = 56; // Integer
    let search = search_example; // String
    let game = game_example; // String

    let mut context = TeamsApi::Context::default();
    let result = client.listTeams(page, size, search, game, &context).wait();

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

Scopes

Parameters

Query parameters
Name Description
page
Integer (int32)
Page number
size
Integer (int32)
Page size
search
game
String
Filter by game

Responses

updateTeam

Update a team (captain or ADMIN)


/api/v1/teams/{id}

Usage and SDK Samples

curl -X PUT \
 -H "Accept: */*" \
 -H "Content-Type: application/json" \
 "https://localhost:8443/api/v1/teams/{id}" \
 -d '{
  "mainGame" : "mainGame",
  "captainId" : 0,
  "university" : "university",
  "name" : "name",
  "description" : "description",
  "tag" : "tag"
}'

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

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

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

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

        try {
            TeamResponse result = apiInstance.updateTeam(id, teamUpdateRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling TeamsApi#updateTeam");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

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

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


import org.openapitools.client.api.TeamsApi;

public class TeamsApiExample {
    public static void main(String[] args) {
        TeamsApi apiInstance = new TeamsApi();
        Long id = 789; // Long | 
        TeamUpdateRequest teamUpdateRequest = ; // TeamUpdateRequest | 

        try {
            TeamResponse result = apiInstance.updateTeam(id, teamUpdateRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling TeamsApi#updateTeam");
            e.printStackTrace();
        }
    }
}


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

// Update a team (captain or ADMIN)
[apiInstance updateTeamWith:id
    teamUpdateRequest:teamUpdateRequest
              completionHandler: ^(TeamResponse 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.TeamsApi()
var id = 789; // {Long} 
var teamUpdateRequest = ; // {TeamUpdateRequest} 

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

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

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

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

            try {
                // Update a team (captain or ADMIN)
                TeamResponse result = apiInstance.updateTeam(id, teamUpdateRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling TeamsApi.updateTeam: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

try:
    # Update a team (captain or ADMIN)
    api_response = api_instance.update_team(id, teamUpdateRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling TeamsApi->updateTeam: %s\n" % e)
extern crate TeamsApi;

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

    let mut context = TeamsApi::Context::default();
    let result = client.updateTeam(id, teamUpdateRequest, &context).wait();

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

Scopes

Parameters

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

Responses

TournamentController

toggleFavorite


/tournaments/{id}/toggle-favorite

Usage and SDK Samples

curl -X POST \
 -H "Accept: */*" \
 "https://localhost:8443/tournaments/{id}/toggle-favorite"

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

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

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

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

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

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

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


import org.openapitools.client.api.TournamentControllerApi;

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

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


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

[apiInstance toggleFavoriteWith: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.TournamentControllerApi()
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.toggleFavorite(id, callback);

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

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

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

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

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

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

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

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

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

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

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

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

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

Scopes

Parameters

Path parameters
Name Description
id*
Long (int64)
Required

Responses

Tournaments

createTournament

Create a tournament (ADMIN)


/api/v1/tournaments

Usage and SDK Samples

curl -X POST \
 -H "Accept: */*" \
 -H "Content-Type: application/json" \
 "https://localhost:8443/api/v1/tournaments" \
 -d '{
  "mode" : "mode",
  "game" : "game",
  "maxTeams" : 2,
  "name" : "name",
  "description" : "description",
  "rules" : "rules",
  "platform" : "platform",
  "startDate" : "startDate"
}'

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

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

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

        // Create an instance of the API class
        TournamentsApi apiInstance = new TournamentsApi();
        TournamentCreateRequest tournamentCreateRequest = ; // TournamentCreateRequest | 

        try {
            TournamentResponse result = apiInstance.createTournament(tournamentCreateRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling TournamentsApi#createTournament");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final TournamentCreateRequest tournamentCreateRequest = new TournamentCreateRequest(); // TournamentCreateRequest | 

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


import org.openapitools.client.api.TournamentsApi;

public class TournamentsApiExample {
    public static void main(String[] args) {
        TournamentsApi apiInstance = new TournamentsApi();
        TournamentCreateRequest tournamentCreateRequest = ; // TournamentCreateRequest | 

        try {
            TournamentResponse result = apiInstance.createTournament(tournamentCreateRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling TournamentsApi#createTournament");
            e.printStackTrace();
        }
    }
}


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

// Create a tournament (ADMIN)
[apiInstance createTournamentWith:tournamentCreateRequest
              completionHandler: ^(TournamentResponse 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.TournamentsApi()
var tournamentCreateRequest = ; // {TournamentCreateRequest} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new TournamentsApi();
            var tournamentCreateRequest = new TournamentCreateRequest(); // TournamentCreateRequest | 

            try {
                // Create a tournament (ADMIN)
                TournamentResponse result = apiInstance.createTournament(tournamentCreateRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling TournamentsApi.createTournament: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\TournamentsApi();
$tournamentCreateRequest = ; // TournamentCreateRequest | 

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::TournamentsApi->new();
my $tournamentCreateRequest = WWW::OPenAPIClient::Object::TournamentCreateRequest->new(); # TournamentCreateRequest | 

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

try:
    # Create a tournament (ADMIN)
    api_response = api_instance.create_tournament(tournamentCreateRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling TournamentsApi->createTournament: %s\n" % e)
extern crate TournamentsApi;

pub fn main() {
    let tournamentCreateRequest = ; // TournamentCreateRequest

    let mut context = TournamentsApi::Context::default();
    let result = client.createTournament(tournamentCreateRequest, &context).wait();

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

Scopes

Parameters

Body parameters
Name Description
tournamentCreateRequest *

Responses

deleteTournament

Delete a tournament (ADMIN)


/api/v1/tournaments/{id}

Usage and SDK Samples

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

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

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

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

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

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

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

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


import org.openapitools.client.api.TournamentsApi;

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

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


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

// Delete a tournament (ADMIN)
[apiInstance deleteTournamentWith: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.TournamentsApi()
var id = 789; // {Long} 

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

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

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

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

            try {
                // Delete a tournament (ADMIN)
                apiInstance.deleteTournament(id);
            } catch (Exception e) {
                Debug.Print("Exception when calling TournamentsApi.deleteTournament: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

try:
    # Delete a tournament (ADMIN)
    api_instance.delete_tournament(id)
except ApiException as e:
    print("Exception when calling TournamentsApi->deleteTournament: %s\n" % e)
extern crate TournamentsApi;

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

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

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

Scopes

Parameters

Path parameters
Name Description
id*
Long (int64)
Required

Responses

getTournament

Get tournament details


/api/v1/tournaments/{id}

Usage and SDK Samples

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

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

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

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

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

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

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

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


import org.openapitools.client.api.TournamentsApi;

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

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


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

// Get tournament details
[apiInstance getTournamentWith:id
              completionHandler: ^(TournamentResponse 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.TournamentsApi()
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.getTournament(id, callback);

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

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

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

            try {
                // Get tournament details
                TournamentResponse result = apiInstance.getTournament(id);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling TournamentsApi.getTournament: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

try:
    # Get tournament details
    api_response = api_instance.get_tournament(id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling TournamentsApi->getTournament: %s\n" % e)
extern crate TournamentsApi;

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

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

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

Scopes

Parameters

Path parameters
Name Description
id*
Long (int64)
Required

Responses

getTournamentImage

Get tournament banner image


/api/v1/tournaments/{id}/image

Usage and SDK Samples

curl -X GET \
 -H "Accept: */*,image/jpeg,image/png" \
 "https://localhost:8443/api/v1/tournaments/{id}/image"

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

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

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

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

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

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

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


import org.openapitools.client.api.TournamentsApi;

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

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


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

// Get tournament banner image
[apiInstance getTournamentImageWith:id
              completionHandler: ^(array[byte[]] output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenApiDefinition = require('open_api_definition');

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

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

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

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

            try {
                // Get tournament banner image
                array[byte[]] result = apiInstance.getTournamentImage(id);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling TournamentsApi.getTournamentImage: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

try:
    # Get tournament banner image
    api_response = api_instance.get_tournament_image(id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling TournamentsApi->getTournamentImage: %s\n" % e)
extern crate TournamentsApi;

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

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

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

Scopes

Parameters

Path parameters
Name Description
id*
Long (int64)
Required

Responses

getTournamentPdf

Download tournament summary as PDF


/api/v1/tournaments/{id}/pdf

Usage and SDK Samples

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

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

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

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

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

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

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

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


import org.openapitools.client.api.TournamentsApi;

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

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


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

// Download tournament summary as PDF
[apiInstance getTournamentPdfWith:id
              completionHandler: ^(array[byte[]] output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenApiDefinition = require('open_api_definition');

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

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

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

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

            try {
                // Download tournament summary as PDF
                array[byte[]] result = apiInstance.getTournamentPdf(id);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling TournamentsApi.getTournamentPdf: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

try:
    # Download tournament summary as PDF
    api_response = api_instance.get_tournament_pdf(id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling TournamentsApi->getTournamentPdf: %s\n" % e)
extern crate TournamentsApi;

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

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

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

Scopes

Parameters

Path parameters
Name Description
id*
Long (int64)
Required

Responses

listTournaments

List all tournaments (paginated)


/api/v1/tournaments

Usage and SDK Samples

curl -X GET \
 -H "Accept: */*" \
 "https://localhost:8443/api/v1/tournaments?page=56&size=56&game=game_example&state=state_example"

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

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

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

        // Create an instance of the API class
        TournamentsApi apiInstance = new TournamentsApi();
        Integer page = 56; // Integer | Page number (0-indexed)
        Integer size = 56; // Integer | Page size
        String game = game_example; // String | Filter by game
        String state = state_example; // String | Filter by state

        try {
            PageTournamentResponse result = apiInstance.listTournaments(page, size, game, state);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling TournamentsApi#listTournaments");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final Integer page = new Integer(); // Integer | Page number (0-indexed)
final Integer size = new Integer(); // Integer | Page size
final String game = new String(); // String | Filter by game
final String state = new String(); // String | Filter by state

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


import org.openapitools.client.api.TournamentsApi;

public class TournamentsApiExample {
    public static void main(String[] args) {
        TournamentsApi apiInstance = new TournamentsApi();
        Integer page = 56; // Integer | Page number (0-indexed)
        Integer size = 56; // Integer | Page size
        String game = game_example; // String | Filter by game
        String state = state_example; // String | Filter by state

        try {
            PageTournamentResponse result = apiInstance.listTournaments(page, size, game, state);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling TournamentsApi#listTournaments");
            e.printStackTrace();
        }
    }
}


// Create an instance of the API class
TournamentsApi *apiInstance = [[TournamentsApi alloc] init];
Integer *page = 56; // Page number (0-indexed) (optional) (default to 0)
Integer *size = 56; // Page size (optional) (default to 10)
String *game = game_example; // Filter by game (optional) (default to null)
String *state = state_example; // Filter by state (optional) (default to null)

// List all tournaments (paginated)
[apiInstance listTournamentsWith:page
    size:size
    game:game
    state:state
              completionHandler: ^(PageTournamentResponse 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.TournamentsApi()
var opts = {
  'page': 56, // {Integer} Page number (0-indexed)
  'size': 56, // {Integer} Page size
  'game': game_example, // {String} Filter by game
  'state': state_example // {String} Filter by state
};

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

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

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

            // Create an instance of the API class
            var apiInstance = new TournamentsApi();
            var page = 56;  // Integer | Page number (0-indexed) (optional)  (default to 0)
            var size = 56;  // Integer | Page size (optional)  (default to 10)
            var game = game_example;  // String | Filter by game (optional)  (default to null)
            var state = state_example;  // String | Filter by state (optional)  (default to null)

            try {
                // List all tournaments (paginated)
                PageTournamentResponse result = apiInstance.listTournaments(page, size, game, state);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling TournamentsApi.listTournaments: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\TournamentsApi();
$page = 56; // Integer | Page number (0-indexed)
$size = 56; // Integer | Page size
$game = game_example; // String | Filter by game
$state = state_example; // String | Filter by state

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::TournamentsApi->new();
my $page = 56; # Integer | Page number (0-indexed)
my $size = 56; # Integer | Page size
my $game = game_example; # String | Filter by game
my $state = state_example; # String | Filter by state

eval {
    my $result = $api_instance->listTournaments(page => $page, size => $size, game => $game, state => $state);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling TournamentsApi->listTournaments: $@\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.TournamentsApi()
page = 56 # Integer | Page number (0-indexed) (optional) (default to 0)
size = 56 # Integer | Page size (optional) (default to 10)
game = game_example # String | Filter by game (optional) (default to null)
state = state_example # String | Filter by state (optional) (default to null)

try:
    # List all tournaments (paginated)
    api_response = api_instance.list_tournaments(page=page, size=size, game=game, state=state)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling TournamentsApi->listTournaments: %s\n" % e)
extern crate TournamentsApi;

pub fn main() {
    let page = 56; // Integer
    let size = 56; // Integer
    let game = game_example; // String
    let state = state_example; // String

    let mut context = TournamentsApi::Context::default();
    let result = client.listTournaments(page, size, game, state, &context).wait();

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

Scopes

Parameters

Query parameters
Name Description
page
Integer (int32)
Page number (0-indexed)
size
Integer (int32)
Page size
game
String
Filter by game
state
String
Filter by state

Responses

updateTournament

Update a tournament (ADMIN)


/api/v1/tournaments/{id}

Usage and SDK Samples

curl -X PUT \
 -H "Accept: */*" \
 -H "Content-Type: application/json" \
 "https://localhost:8443/api/v1/tournaments/{id}" \
 -d '{
  "mode" : "mode",
  "game" : "game",
  "maxTeams" : 0,
  "name" : "name",
  "description" : "description",
  "rules" : "rules",
  "state" : "state",
  "platform" : "platform",
  "startDate" : "startDate"
}'

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

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

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

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

        try {
            TournamentResponse result = apiInstance.updateTournament(id, tournamentUpdateRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling TournamentsApi#updateTournament");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

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

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


import org.openapitools.client.api.TournamentsApi;

public class TournamentsApiExample {
    public static void main(String[] args) {
        TournamentsApi apiInstance = new TournamentsApi();
        Long id = 789; // Long | 
        TournamentUpdateRequest tournamentUpdateRequest = ; // TournamentUpdateRequest | 

        try {
            TournamentResponse result = apiInstance.updateTournament(id, tournamentUpdateRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling TournamentsApi#updateTournament");
            e.printStackTrace();
        }
    }
}


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

// Update a tournament (ADMIN)
[apiInstance updateTournamentWith:id
    tournamentUpdateRequest:tournamentUpdateRequest
              completionHandler: ^(TournamentResponse 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.TournamentsApi()
var id = 789; // {Long} 
var tournamentUpdateRequest = ; // {TournamentUpdateRequest} 

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

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

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

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

            try {
                // Update a tournament (ADMIN)
                TournamentResponse result = apiInstance.updateTournament(id, tournamentUpdateRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling TournamentsApi.updateTournament: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

try:
    # Update a tournament (ADMIN)
    api_response = api_instance.update_tournament(id, tournamentUpdateRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling TournamentsApi->updateTournament: %s\n" % e)
extern crate TournamentsApi;

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

    let mut context = TournamentsApi::Context::default();
    let result = client.updateTournament(id, tournamentUpdateRequest, &context).wait();

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

Scopes

Parameters

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

Responses

Users

createUser

Create a new user (ADMIN only)


/api/v1/users

Usage and SDK Samples

curl -X POST \
 -H "Accept: */*" \
 -H "Content-Type: application/json" \
 "https://localhost:8443/api/v1/users" \
 -d '{
  "password" : "password",
  "university" : "university",
  "roles" : [ "roles", "roles" ],
  "name" : "name",
  "nickname" : "nickname",
  "email" : "email"
}'

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

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

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

        // Create an instance of the API class
        UsersApi apiInstance = new UsersApi();
        UserCreateRequest userCreateRequest = ; // UserCreateRequest | 

        try {
            UserResponse result = apiInstance.createUser(userCreateRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling UsersApi#createUser");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final UserCreateRequest userCreateRequest = new UserCreateRequest(); // UserCreateRequest | 

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


import org.openapitools.client.api.UsersApi;

public class UsersApiExample {
    public static void main(String[] args) {
        UsersApi apiInstance = new UsersApi();
        UserCreateRequest userCreateRequest = ; // UserCreateRequest | 

        try {
            UserResponse result = apiInstance.createUser(userCreateRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling UsersApi#createUser");
            e.printStackTrace();
        }
    }
}


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

// Create a new user (ADMIN only)
[apiInstance createUserWith:userCreateRequest
              completionHandler: ^(UserResponse 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.UsersApi()
var userCreateRequest = ; // {UserCreateRequest} 

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

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

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

            // Create an instance of the API class
            var apiInstance = new UsersApi();
            var userCreateRequest = new UserCreateRequest(); // UserCreateRequest | 

            try {
                // Create a new user (ADMIN only)
                UserResponse result = apiInstance.createUser(userCreateRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling UsersApi.createUser: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\UsersApi();
$userCreateRequest = ; // UserCreateRequest | 

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::UsersApi->new();
my $userCreateRequest = WWW::OPenAPIClient::Object::UserCreateRequest->new(); # UserCreateRequest | 

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

try:
    # Create a new user (ADMIN only)
    api_response = api_instance.create_user(userCreateRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling UsersApi->createUser: %s\n" % e)
extern crate UsersApi;

pub fn main() {
    let userCreateRequest = ; // UserCreateRequest

    let mut context = UsersApi::Context::default();
    let result = client.createUser(userCreateRequest, &context).wait();

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

Scopes

Parameters

Body parameters
Name Description
userCreateRequest *

Responses

deleteUser

Delete user (ADMIN)


/api/v1/users/{id}

Usage and SDK Samples

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

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

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

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

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

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

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

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

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


import org.openapitools.client.api.UsersApi;

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

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


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

// Delete user (ADMIN)
[apiInstance deleteUserWith: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.UsersApi()
var id = 789; // {Long} 

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

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

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

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

            try {
                // Delete user (ADMIN)
                apiInstance.deleteUser(id);
            } catch (Exception e) {
                Debug.Print("Exception when calling UsersApi.deleteUser: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

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

try:
    # Delete user (ADMIN)
    api_instance.delete_user(id)
except ApiException as e:
    print("Exception when calling UsersApi->deleteUser: %s\n" % e)
extern crate UsersApi;

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

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

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

Scopes

Parameters

Path parameters
Name Description
id*
Long (int64)
Required

Responses

getUser

Get user by ID (own user or ADMIN)

Returns user details without password.


/api/v1/users/{id}

Usage and SDK Samples

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

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

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

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

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

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

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

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


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

// Get user by ID (own user or ADMIN)
[apiInstance getUserWith:id
              completionHandler: ^(UserResponse 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.UsersApi()
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 UsersApi();
            var id = 789;  // Long |  (default to null)

            try {
                // Get user by ID (own user or ADMIN)
                UserResponse result = apiInstance.getUser(id);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling UsersApi.getUser: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

try:
    # Get user by ID (own user or ADMIN)
    api_response = api_instance.get_user(id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling UsersApi->getUser: %s\n" % e)
extern crate UsersApi;

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

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

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

Scopes

Parameters

Path parameters
Name Description
id*
Long (int64)
Required

Responses

getUserImage

Get user avatar image


/api/v1/users/{id}/image

Usage and SDK Samples

curl -X GET \
 -H "Accept: */*,image/jpeg,image/png" \
 "https://localhost: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.UsersApi;

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

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

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

        try {
            array[byte[]] result = apiInstance.getUserImage(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling UsersApi#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.UsersApi;

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

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


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

// Get user avatar image
[apiInstance getUserImageWith:id
              completionHandler: ^(array[byte[]] output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenApiDefinition = require('open_api_definition');

// Create an instance of the API class
var api = new OpenApiDefinition.UsersApi()
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 UsersApi();
            var id = 789;  // Long |  (default to null)

            try {
                // Get user avatar image
                array[byte[]] result = apiInstance.getUserImage(id);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling UsersApi.getUserImage: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

try:
    # Get user avatar image
    api_response = api_instance.get_user_image(id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling UsersApi->getUserImage: %s\n" % e)
extern crate UsersApi;

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

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

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

Scopes

Parameters

Path parameters
Name Description
id*
Long (int64)
Required

Responses

getUserStats

Get user statistics for charts

Returns KDA, win rate, and match history data for chart rendering.


/api/v1/users/{id}/stats

Usage and SDK Samples

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

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

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

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

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

        try {
            map['String', Object] result = apiInstance.getUserStats(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling UsersApi#getUserStats");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

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

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


import org.openapitools.client.api.UsersApi;

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

        try {
            map['String', Object] result = apiInstance.getUserStats(id);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling UsersApi#getUserStats");
            e.printStackTrace();
        }
    }
}


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

// Get user statistics for charts
[apiInstance getUserStatsWith:id
              completionHandler: ^(map['String', 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.UsersApi()
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.getUserStats(id, callback);

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

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

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

            try {
                // Get user statistics for charts
                map['String', Object] result = apiInstance.getUserStats(id);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling UsersApi.getUserStats: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

try:
    # Get user statistics for charts
    api_response = api_instance.get_user_stats(id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling UsersApi->getUserStats: %s\n" % e)
extern crate UsersApi;

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

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

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

Scopes

Parameters

Path parameters
Name Description
id*
Long (int64)
Required

Responses

listUsers

List all users (ADMIN)

Returns a paginated list of users. Passwords are NOT included.


/api/v1/users

Usage and SDK Samples

curl -X GET \
 -H "Accept: */*" \
 "https://localhost:8443/api/v1/users?page=56&size=56"

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

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

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

        // Create an instance of the API class
        UsersApi apiInstance = new UsersApi();
        Integer page = 56; // Integer | Page number
        Integer size = 56; // Integer | Page size

        try {
            PageUserResponse result = apiInstance.listUsers(page, size);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling UsersApi#listUsers");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

final Integer page = new Integer(); // Integer | Page number
final Integer size = new Integer(); // Integer | Page size

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


import org.openapitools.client.api.UsersApi;

public class UsersApiExample {
    public static void main(String[] args) {
        UsersApi apiInstance = new UsersApi();
        Integer page = 56; // Integer | Page number
        Integer size = 56; // Integer | Page size

        try {
            PageUserResponse result = apiInstance.listUsers(page, size);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling UsersApi#listUsers");
            e.printStackTrace();
        }
    }
}


// Create an instance of the API class
UsersApi *apiInstance = [[UsersApi alloc] init];
Integer *page = 56; // Page number (optional) (default to 0)
Integer *size = 56; // Page size (optional) (default to 10)

// List all users (ADMIN)
[apiInstance listUsersWith:page
    size:size
              completionHandler: ^(PageUserResponse 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.UsersApi()
var opts = {
  'page': 56, // {Integer} Page number
  'size': 56 // {Integer} Page size
};

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

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

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

            // Create an instance of the API class
            var apiInstance = new UsersApi();
            var page = 56;  // Integer | Page number (optional)  (default to 0)
            var size = 56;  // Integer | Page size (optional)  (default to 10)

            try {
                // List all users (ADMIN)
                PageUserResponse result = apiInstance.listUsers(page, size);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling UsersApi.listUsers: " + e.Message );
            }
        }
    }
}

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

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

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

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

eval {
    my $result = $api_instance->listUsers(page => $page, size => $size);
    print Dumper($result);
};
if ($@) {
    warn "Exception when calling UsersApi->listUsers: $@\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.UsersApi()
page = 56 # Integer | Page number (optional) (default to 0)
size = 56 # Integer | Page size (optional) (default to 10)

try:
    # List all users (ADMIN)
    api_response = api_instance.list_users(page=page, size=size)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling UsersApi->listUsers: %s\n" % e)
extern crate UsersApi;

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

    let mut context = UsersApi::Context::default();
    let result = client.listUsers(page, size, &context).wait();

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

Scopes

Parameters

Query parameters
Name Description
page
Integer (int32)
Page number
size
Integer (int32)
Page size

Responses

updateUser

Update user profile (own user or ADMIN)


/api/v1/users/{id}

Usage and SDK Samples

curl -X PUT \
 -H "Accept: */*" \
 -H "Content-Type: application/json" \
 "https://localhost:8443/api/v1/users/{id}" \
 -d '{
  "university" : "university",
  "name" : "name",
  "nickname" : "nickname"
}'

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

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

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

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

        try {
            UserResponse result = apiInstance.updateUser(id, userUpdateRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling UsersApi#updateUser");
            e.printStackTrace();
        }
    }
}

import 'package:openapi/api.dart';

final api_instance = DefaultApi();

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

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


import org.openapitools.client.api.UsersApi;

public class UsersApiExample {
    public static void main(String[] args) {
        UsersApi apiInstance = new UsersApi();
        Long id = 789; // Long | 
        UserUpdateRequest userUpdateRequest = ; // UserUpdateRequest | 

        try {
            UserResponse result = apiInstance.updateUser(id, userUpdateRequest);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling UsersApi#updateUser");
            e.printStackTrace();
        }
    }
}


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

// Update user profile (own user or ADMIN)
[apiInstance updateUserWith:id
    userUpdateRequest:userUpdateRequest
              completionHandler: ^(UserResponse 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.UsersApi()
var id = 789; // {Long} 
var userUpdateRequest = ; // {UserUpdateRequest} 

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

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

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

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

            try {
                // Update user profile (own user or ADMIN)
                UserResponse result = apiInstance.updateUser(id, userUpdateRequest);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling UsersApi.updateUser: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

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

try:
    # Update user profile (own user or ADMIN)
    api_response = api_instance.update_user(id, userUpdateRequest)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling UsersApi->updateUser: %s\n" % e)
extern crate UsersApi;

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

    let mut context = UsersApi::Context::default();
    let result = client.updateUser(id, userUpdateRequest, &context).wait();

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

Scopes

Parameters

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

Responses