OpenAPI definition

LoginRestController

logOut

/api/auth/logout

Usage and SDK Samples

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

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

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

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

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

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

import org.openapitools.client.api.LoginRestControllerApi;

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

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



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

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

var OpenApiDefinition = require('open_api_definition');

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

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

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

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

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

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

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

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

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

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

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

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

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

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

extern crate LoginRestControllerApi;

pub fn main() {

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

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

Scopes

Parameters

Responses

Schema

login

/api/auth/login

Usage and SDK Samples

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

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

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

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

        // Create an instance of the API class
        LoginRestControllerApi apiInstance = new LoginRestControllerApi();
        LoginRequest loginRequest = ; // LoginRequest | 
        String accessToken = accessToken_example; // String | 
        String refreshToken = refreshToken_example; // String | 

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

import org.openapitools.client.api.LoginRestControllerApi;

public class LoginRestControllerApiExample {
    public static void main(String[] args) {
        LoginRestControllerApi apiInstance = new LoginRestControllerApi();
        LoginRequest loginRequest = ; // LoginRequest | 
        String accessToken = accessToken_example; // String | 
        String refreshToken = refreshToken_example; // String | 

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



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

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

var OpenApiDefinition = require('open_api_definition');

// Create an instance of the API class
var api = new OpenApiDefinition.LoginRestControllerApi()
var loginRequest = ; // {LoginRequest} 
var opts = {
  'accessToken': accessToken_example, // {String} 
  'refreshToken': refreshToken_example // {String} 
};

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

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

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

            // Create an instance of the API class
            var apiInstance = new LoginRestControllerApi();
            var loginRequest = new LoginRequest(); // LoginRequest | 
            var accessToken = accessToken_example;  // String |  (optional)  (default to null)
            var refreshToken = refreshToken_example;  // String |  (optional)  (default to null)

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

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\LoginRestControllerApi();
$loginRequest = ; // LoginRequest | 
$accessToken = accessToken_example; // String | 
$refreshToken = refreshToken_example; // String | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::LoginRestControllerApi->new();
my $loginRequest = WWW::OPenAPIClient::Object::LoginRequest->new(); # LoginRequest | 
my $accessToken = accessToken_example; # String | 
my $refreshToken = refreshToken_example; # String | 

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

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

# Create an instance of the API class
api_instance = openapi_client.LoginRestControllerApi()
loginRequest =  # LoginRequest | 
accessToken = accessToken_example # String |  (optional) (default to null)
refreshToken = refreshToken_example # String |  (optional) (default to null)

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

extern crate LoginRestControllerApi;

pub fn main() {
    let loginRequest = ; // LoginRequest
    let accessToken = accessToken_example; // String
    let refreshToken = refreshToken_example; // String

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

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

Scopes

Parameters

Body parameters

Name	Description
loginRequest *

Responses

refreshToken

/api/auth/refresh

Usage and SDK Samples

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

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

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

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

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

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

import org.openapitools.client.api.LoginRestControllerApi;

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

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



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

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

var OpenApiDefinition = require('open_api_definition');

// Create an instance of the API class
var api = new OpenApiDefinition.LoginRestControllerApi()
var opts = {
  'refreshToken': refreshToken_example // {String} 
};

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

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

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

            // Create an instance of the API class
            var apiInstance = new LoginRestControllerApi();
            var refreshToken = refreshToken_example;  // String |  (optional)  (default to null)

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

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

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

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

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

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

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

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

# Create an instance of the API class
api_instance = openapi_client.LoginRestControllerApi()
refreshToken = refreshToken_example # String |  (optional) (default to null)

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

extern crate LoginRestControllerApi;

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

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

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

Scopes

Parameters

Responses

Schema

MatchRestController

getMatch

Get the match by ID

/api/matches/{id}

Usage and SDK Samples

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

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

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

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

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

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

import org.openapitools.client.api.MatchRestControllerApi;

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

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



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

// Get the match by ID
[apiInstance getMatchWith:id
              completionHandler: ^(Match_Mostrar 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.MatchRestControllerApi()
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 MatchRestControllerApi();
            var id = 789;  // Long |  (default to null)

            try {
                // Get the match by ID
                Match_Mostrar result = apiInstance.getMatch(id);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling MatchRestControllerApi.getMatch: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

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

try:
    # Get the match by ID
    api_response = api_instance.get_match(id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling MatchRestControllerApi->getMatch: %s\n" % e)

extern crate MatchRestControllerApi;

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

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

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

Scopes

Parameters

Path parameters

Name	Description
id*	Long (int64) Required

Responses

Schema

resultMatch

set Match's result

/api/matches/{id}/result

Usage and SDK Samples

curl -X PUT \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "http://localhost:8443/api/matches/{id}/result" \
 -d '{
  "result" : [ 1, 1 ],
  "setsTeamTwo" : 5,
  "round" : 6,
  "setsTeamOne" : 5,
  "hasWinner" : true,
  "winnerTeamOne" : true,
  "teamTwo" : {
    "userA" : {
      "numWins" : 6,
      "country" : "country",
      "karma" : 2,
      "numLoses" : 1,
      "roles" : [ "roles", "roles" ],
      "realName" : "realName",
      "phone" : "phone",
      "historicalKarma" : [ 5, 5 ],
      "encodedPassword" : "encodedPassword",
      "name" : "name",
      "numMatchesPlayed" : 5.962133916683182,
      "location" : "location",
      "id" : 0,
      "email" : "email",
      "status" : true
    },
    "userB" : {
      "numWins" : 6,
      "country" : "country",
      "karma" : 2,
      "numLoses" : 1,
      "roles" : [ "roles", "roles" ],
      "realName" : "realName",
      "phone" : "phone",
      "historicalKarma" : [ 5, 5 ],
      "encodedPassword" : "encodedPassword",
      "name" : "name",
      "numMatchesPlayed" : 5.962133916683182,
      "location" : "location",
      "id" : 0,
      "email" : "email",
      "status" : true
    },
    "tbd" : true,
    "id" : 2
  },
  "id" : 0,
  "tournament" : {
    "owner" : "owner",
    "tournamentName" : "tournamentName",
    "numSignedUp" : 1,
    "inscriptionDate" : "inscriptionDate",
    "about" : "about",
    "ruleset" : "ruleset",
    "location" : "location",
    "started" : true,
    "id" : 0,
    "rounds" : 5,
    "startDate" : "startDate",
    "numParticipants" : 6
  },
  "winnerTeamTwo" : true,
  "teamOne" : {
    "userA" : {
      "numWins" : 6,
      "country" : "country",
      "karma" : 2,
      "numLoses" : 1,
      "roles" : [ "roles", "roles" ],
      "realName" : "realName",
      "phone" : "phone",
      "historicalKarma" : [ 5, 5 ],
      "encodedPassword" : "encodedPassword",
      "name" : "name",
      "numMatchesPlayed" : 5.962133916683182,
      "location" : "location",
      "id" : 0,
      "email" : "email",
      "status" : true
    },
    "userB" : {
      "numWins" : 6,
      "country" : "country",
      "karma" : 2,
      "numLoses" : 1,
      "roles" : [ "roles", "roles" ],
      "realName" : "realName",
      "phone" : "phone",
      "historicalKarma" : [ 5, 5 ],
      "encodedPassword" : "encodedPassword",
      "name" : "name",
      "numMatchesPlayed" : 5.962133916683182,
      "location" : "location",
      "id" : 0,
      "email" : "email",
      "status" : true
    },
    "tbd" : true,
    "id" : 2
  }
}'

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

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

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

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

        try {
            Match result = apiInstance.resultMatch(id, match);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling MatchRestControllerApi#resultMatch");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.MatchRestControllerApi;

public class MatchRestControllerApiExample {
    public static void main(String[] args) {
        MatchRestControllerApi apiInstance = new MatchRestControllerApi();
        Long id = 789; // Long | 
        Match match = ; // Match | 

        try {
            Match result = apiInstance.resultMatch(id, match);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling MatchRestControllerApi#resultMatch");
            e.printStackTrace();
        }
    }
}



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

// set Match's result
[apiInstance resultMatchWith:id
    match:match
              completionHandler: ^(Match 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.MatchRestControllerApi()
var id = 789; // {Long} 
var match = ; // {Match} 

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

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

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

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

            try {
                // set Match's result
                Match result = apiInstance.resultMatch(id, match);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling MatchRestControllerApi.resultMatch: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

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

try:
    # set Match's result
    api_response = api_instance.result_match(id, match)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling MatchRestControllerApi->resultMatch: %s\n" % e)

extern crate MatchRestControllerApi;

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

    let mut context = MatchRestControllerApi::Context::default();
    let result = client.resultMatch(id, match, &context).wait();

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

Scopes

Parameters

Path parameters

Name	Description
id*	Long (int64) Required

Body parameters

Name	Description
match *

Responses

Schema

TournamentRestController

createTournament

Create tournament

/api/tournaments

Usage and SDK Samples

curl -X POST \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "http://localhost:8443/api/tournaments" \
 -d '{
  "owner" : "owner",
  "tournamentName" : "tournamentName",
  "numSignedUp" : 1,
  "inscriptionDate" : "inscriptionDate",
  "about" : "about",
  "ruleset" : "ruleset",
  "location" : "location",
  "started" : true,
  "id" : 0,
  "rounds" : 5,
  "startDate" : "startDate",
  "numParticipants" : 6
}'

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

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

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

        // Create an instance of the API class
        TournamentRestControllerApi apiInstance = new TournamentRestControllerApi();
        Tournament tournament = ; // Tournament | 

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

import org.openapitools.client.api.TournamentRestControllerApi;

public class TournamentRestControllerApiExample {
    public static void main(String[] args) {
        TournamentRestControllerApi apiInstance = new TournamentRestControllerApi();
        Tournament tournament = ; // Tournament | 

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



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

// Create tournament
[apiInstance createTournamentWith:tournament
              completionHandler: ^(Tournament 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.TournamentRestControllerApi()
var tournament = ; // {Tournament} 

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

            try {
                // Create tournament
                Tournament result = apiInstance.createTournament(tournament);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling TournamentRestControllerApi.createTournament: " + e.Message );
            }
        }
    }
}

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

// Create an instance of the API class
$api_instance = new OpenAPITools\Client\Api\TournamentRestControllerApi();
$tournament = ; // Tournament | 

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

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

# Create an instance of the API class
my $api_instance = WWW::OPenAPIClient::TournamentRestControllerApi->new();
my $tournament = WWW::OPenAPIClient::Object::Tournament->new(); # Tournament | 

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

try:
    # Create tournament
    api_response = api_instance.create_tournament(tournament)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling TournamentRestControllerApi->createTournament: %s\n" % e)

extern crate TournamentRestControllerApi;

pub fn main() {
    let tournament = ; // Tournament

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

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

Scopes

Parameters

Body parameters

Name	Description
tournament *

Responses

Schema

deleteImage1

delete tournament image

/api/tournaments/{id}/image

Usage and SDK Samples

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

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

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

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

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

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

import org.openapitools.client.api.TournamentRestControllerApi;

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

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



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

// delete tournament image
[apiInstance deleteImage1With:id
              completionHandler: ^(Tournament 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.TournamentRestControllerApi()
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.deleteImage1(id, callback);

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

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

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

            try {
                // delete tournament image
                Tournament result = apiInstance.deleteImage1(id);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling TournamentRestControllerApi.deleteImage1: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

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

try:
    # delete tournament image
    api_response = api_instance.delete_image1(id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling TournamentRestControllerApi->deleteImage1: %s\n" % e)

extern crate TournamentRestControllerApi;

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

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

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

Scopes

Parameters

Path parameters

Name	Description
id*	Long (int64) Required

Responses

Schema

deleteTournament

Delete tournament

/api/tournaments/{id}

Usage and SDK Samples

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

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

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

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

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

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

import org.openapitools.client.api.TournamentRestControllerApi;

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

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



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

// Delete tournament
[apiInstance deleteTournamentWith:id
              completionHandler: ^(Tournament 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.TournamentRestControllerApi()
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.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 TournamentRestControllerApi();
            var id = 789;  // Long |  (default to null)

            try {
                // Delete tournament
                Tournament result = apiInstance.deleteTournament(id);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling TournamentRestControllerApi.deleteTournament: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

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

try:
    # Delete tournament
    api_response = api_instance.delete_tournament(id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling TournamentRestControllerApi->deleteTournament: %s\n" % e)

extern crate TournamentRestControllerApi;

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

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

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

Scopes

Parameters

Path parameters

Name	Description
id*	Long (int64) Required

Responses

Schema

deleteTournamentTeam

delete team

/api/tournaments/{id}/teams/{teamid}

Usage and SDK Samples

curl -X DELETE \
 -H "Accept: application/json" \
 "http://localhost:8443/api/tournaments/{id}/teams/{teamid}"

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

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

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

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

        try {
            Tournament result = apiInstance.deleteTournamentTeam(id, teamid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling TournamentRestControllerApi#deleteTournamentTeam");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.TournamentRestControllerApi;

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

        try {
            Tournament result = apiInstance.deleteTournamentTeam(id, teamid);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling TournamentRestControllerApi#deleteTournamentTeam");
            e.printStackTrace();
        }
    }
}



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

// delete team
[apiInstance deleteTournamentTeamWith:id
    teamid:teamid
              completionHandler: ^(Tournament 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.TournamentRestControllerApi()
var id = 789; // {Long} 
var teamid = 789; // {Long} 

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

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

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

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

            try {
                // delete team
                Tournament result = apiInstance.deleteTournamentTeam(id, teamid);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling TournamentRestControllerApi.deleteTournamentTeam: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

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

try:
    # delete team
    api_response = api_instance.delete_tournament_team(id, teamid)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling TournamentRestControllerApi->deleteTournamentTeam: %s\n" % e)

extern crate TournamentRestControllerApi;

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

    let mut context = TournamentRestControllerApi::Context::default();
    let result = client.deleteTournamentTeam(id, teamid, &context).wait();

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

Scopes

Parameters

Path parameters

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

Responses

Schema

downloadImage1

download tournament image

/api/tournaments/{id}/image

Usage and SDK Samples

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

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

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

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

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

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

import org.openapitools.client.api.TournamentRestControllerApi;

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

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



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

// download tournament image
[apiInstance downloadImage1With:id
              completionHandler: ^(Tournament 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.TournamentRestControllerApi()
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.downloadImage1(id, callback);

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

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

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

            try {
                // download tournament image
                Tournament result = apiInstance.downloadImage1(id);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling TournamentRestControllerApi.downloadImage1: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

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

try:
    # download tournament image
    api_response = api_instance.download_image1(id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling TournamentRestControllerApi->downloadImage1: %s\n" % e)

extern crate TournamentRestControllerApi;

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

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

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

Scopes

Parameters

Path parameters

Name	Description
id*	Long (int64) Required

Responses

Schema

getRound

Get rounds from tournament

/api/tournaments/{id}/matches

Usage and SDK Samples

curl -X GET \
 -H "Accept: application/json" \
 "http://localhost:8443/api/tournaments/{id}/matches?round=56"

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

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

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

        // Create an instance of the API class
        TournamentRestControllerApi apiInstance = new TournamentRestControllerApi();
        Long id = 789; // Long | 
        Integer round = 56; // Integer | 

        try {
            Tournament_Mostrar result = apiInstance.getRound(id, round);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling TournamentRestControllerApi#getRound");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.TournamentRestControllerApi;

public class TournamentRestControllerApiExample {
    public static void main(String[] args) {
        TournamentRestControllerApi apiInstance = new TournamentRestControllerApi();
        Long id = 789; // Long | 
        Integer round = 56; // Integer | 

        try {
            Tournament_Mostrar result = apiInstance.getRound(id, round);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling TournamentRestControllerApi#getRound");
            e.printStackTrace();
        }
    }
}



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

// Get rounds from tournament
[apiInstance getRoundWith:id
    round:round
              completionHandler: ^(Tournament_Mostrar 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.TournamentRestControllerApi()
var id = 789; // {Long} 
var round = 56; // {Integer} 

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

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

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

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

            try {
                // Get rounds from tournament
                Tournament_Mostrar result = apiInstance.getRound(id, round);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling TournamentRestControllerApi.getRound: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

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

try:
    # Get rounds from tournament
    api_response = api_instance.get_round(id, round)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling TournamentRestControllerApi->getRound: %s\n" % e)

extern crate TournamentRestControllerApi;

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

    let mut context = TournamentRestControllerApi::Context::default();
    let result = client.getRound(id, round, &context).wait();

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

Scopes

Parameters

Path parameters

Name	Description
id*	Long (int64) Required

Query parameters

Name	Description
round*	Integer (int32) Required

Responses

Schema

Schema

getTournament

Get tournament by id

/api/tournaments/{id}

Usage and SDK Samples

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

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

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

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

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

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

import org.openapitools.client.api.TournamentRestControllerApi;

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

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



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

// Get tournament by id
[apiInstance getTournamentWith:id
              completionHandler: ^(Tournament 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.TournamentRestControllerApi()
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 TournamentRestControllerApi();
            var id = 789;  // Long |  (default to null)

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

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

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

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

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

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

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

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

extern crate TournamentRestControllerApi;

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

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

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

Scopes

Parameters

Path parameters

Name	Description
id*	Long (int64) Required

Responses

Schema

getTournamentTeams

Get teams from tournament

/api/tournaments/{id}/teams

Usage and SDK Samples

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

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

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

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

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

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

import org.openapitools.client.api.TournamentRestControllerApi;

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

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



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

// Get teams from tournament
[apiInstance getTournamentTeamsWith:id
              completionHandler: ^(Tournament_Mostrar 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.TournamentRestControllerApi()
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.getTournamentTeams(id, callback);

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

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

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

            try {
                // Get teams from tournament
                Tournament_Mostrar result = apiInstance.getTournamentTeams(id);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling TournamentRestControllerApi.getTournamentTeams: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

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

try:
    # Get teams from tournament
    api_response = api_instance.get_tournament_teams(id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling TournamentRestControllerApi->getTournamentTeams: %s\n" % e)

extern crate TournamentRestControllerApi;

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

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

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

Scopes

Parameters

Path parameters

Name	Description
id*	Long (int64) Required

Responses

Schema

getTournaments

get all tournaments

/api/tournaments

Usage and SDK Samples

curl -X GET \
 -H "Accept: application/json" \
 "http://localhost:8443/api/tournaments?page=56"

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

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

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

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

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

import org.openapitools.client.api.TournamentRestControllerApi;

public class TournamentRestControllerApiExample {
    public static void main(String[] args) {
        TournamentRestControllerApi apiInstance = new TournamentRestControllerApi();
        Integer page = 56; // Integer | 

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



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

// get all tournaments
[apiInstance getTournamentsWith:page
              completionHandler: ^(Tournament 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.TournamentRestControllerApi()
var page = 56; // {Integer} 

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

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

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

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

            try {
                // get all tournaments
                Tournament result = apiInstance.getTournaments(page);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling TournamentRestControllerApi.getTournaments: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

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

try:
    # get all tournaments
    api_response = api_instance.get_tournaments(page)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling TournamentRestControllerApi->getTournaments: %s\n" % e)

extern crate TournamentRestControllerApi;

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

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

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

Scopes

Parameters

Query parameters

Name	Description
page*	Integer (int32) Required

Responses

Schema

tournamentTeams

show tournament's teams

/api/tournaments/{id}/teams

Usage and SDK Samples

curl -X PUT \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "http://localhost:8443/api/tournaments/{id}/teams" \
 -d ''

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

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

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

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

        try {
            Tournament_Mostrar result = apiInstance.tournamentTeams(id, userMostrar);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling TournamentRestControllerApi#tournamentTeams");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.TournamentRestControllerApi;

public class TournamentRestControllerApiExample {
    public static void main(String[] args) {
        TournamentRestControllerApi apiInstance = new TournamentRestControllerApi();
        Long id = 789; // Long | 
        UserMostrar userMostrar = ; // UserMostrar | 

        try {
            Tournament_Mostrar result = apiInstance.tournamentTeams(id, userMostrar);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling TournamentRestControllerApi#tournamentTeams");
            e.printStackTrace();
        }
    }
}



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

// show tournament's teams
[apiInstance tournamentTeamsWith:id
    userMostrar:userMostrar
              completionHandler: ^(Tournament_Mostrar 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.TournamentRestControllerApi()
var id = 789; // {Long} 
var userMostrar = ; // {UserMostrar} 

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

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

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

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

            try {
                // show tournament's teams
                Tournament_Mostrar result = apiInstance.tournamentTeams(id, userMostrar);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling TournamentRestControllerApi.tournamentTeams: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

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

try:
    # show tournament's teams
    api_response = api_instance.tournament_teams(id, userMostrar)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling TournamentRestControllerApi->tournamentTeams: %s\n" % e)

extern crate TournamentRestControllerApi;

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

    let mut context = TournamentRestControllerApi::Context::default();
    let result = client.tournamentTeams(id, userMostrar, &context).wait();

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

Scopes

Parameters

Path parameters

Name	Description
id*	Long (int64) Required

Body parameters

Name	Description
userMostrar *

Responses

Schema

updateTournament

update tournamet

/api/tournaments/{id}

Usage and SDK Samples

curl -X PUT \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "http://localhost:8443/api/tournaments/{id}" \
 -d '{
  "owner" : "owner",
  "tournamentName" : "tournamentName",
  "numSignedUp" : 1,
  "inscriptionDate" : "inscriptionDate",
  "about" : "about",
  "ruleset" : "ruleset",
  "location" : "location",
  "started" : true,
  "id" : 0,
  "rounds" : 5,
  "startDate" : "startDate",
  "numParticipants" : 6
}'

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

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

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

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

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

import org.openapitools.client.api.TournamentRestControllerApi;

public class TournamentRestControllerApiExample {
    public static void main(String[] args) {
        TournamentRestControllerApi apiInstance = new TournamentRestControllerApi();
        Long id = 789; // Long | 
        Tournament tournament = ; // Tournament | 

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



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

// update tournamet
[apiInstance updateTournamentWith:id
    tournament:tournament
              completionHandler: ^(Tournament 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.TournamentRestControllerApi()
var id = 789; // {Long} 
var tournament = ; // {Tournament} 

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

            try {
                // update tournamet
                Tournament result = apiInstance.updateTournament(id, tournament);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling TournamentRestControllerApi.updateTournament: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

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

try:
    # update tournamet
    api_response = api_instance.update_tournament(id, tournament)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling TournamentRestControllerApi->updateTournament: %s\n" % e)

extern crate TournamentRestControllerApi;

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

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

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

Scopes

Parameters

Path parameters

Name	Description
id*	Long (int64) Required

Body parameters

Name	Description
tournament *

Responses

Schema

uploadImage1

upload tournament image

/api/tournaments/{id}/image

Usage and SDK Samples

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

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

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

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

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

        try {
            Tournament result = apiInstance.uploadImage1(id, inlineObject1);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling TournamentRestControllerApi#uploadImage1");
            e.printStackTrace();
        }
    }
}

import org.openapitools.client.api.TournamentRestControllerApi;

public class TournamentRestControllerApiExample {
    public static void main(String[] args) {
        TournamentRestControllerApi apiInstance = new TournamentRestControllerApi();
        Long id = 789; // Long | 
        InlineObject1 inlineObject1 = ; // InlineObject1 | 

        try {
            Tournament result = apiInstance.uploadImage1(id, inlineObject1);
            System.out.println(result);
        } catch (ApiException e) {
            System.err.println("Exception when calling TournamentRestControllerApi#uploadImage1");
            e.printStackTrace();
        }
    }
}



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

// upload tournament image
[apiInstance uploadImage1With:id
    inlineObject1:inlineObject1
              completionHandler: ^(Tournament 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.TournamentRestControllerApi()
var id = 789; // {Long} 
var opts = {
  'inlineObject1':  // {InlineObject1} 
};

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

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

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

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

            try {
                // upload tournament image
                Tournament result = apiInstance.uploadImage1(id, inlineObject1);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling TournamentRestControllerApi.uploadImage1: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

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

try:
    # upload tournament image
    api_response = api_instance.upload_image1(id, inlineObject1=inlineObject1)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling TournamentRestControllerApi->uploadImage1: %s\n" % e)

extern crate TournamentRestControllerApi;

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

    let mut context = TournamentRestControllerApi::Context::default();
    let result = client.uploadImage1(id, inlineObject1, &context).wait();

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

Scopes

Parameters

Path parameters

Name	Description
id*	Long (int64) Required

Body parameters

Name	Description
inlineObject1

Responses

Schema

UserRestController

deleteImage

Delete user image

/api/users/image

Usage and SDK Samples

curl -X DELETE \
 -H "Accept: application/json" \
 "http://localhost:8443/api/users/image"

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

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

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

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

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

import org.openapitools.client.api.UserRestControllerApi;

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

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



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

// Delete user image
[apiInstance deleteImageWithCompletionHandler: 
              ^(User output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenApiDefinition = require('open_api_definition');

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

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

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

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

            try {
                // Delete user image
                User result = apiInstance.deleteImage();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling UserRestControllerApi.deleteImage: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

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

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

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

try:
    # Delete user image
    api_response = api_instance.delete_image()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling UserRestControllerApi->deleteImage: %s\n" % e)

extern crate UserRestControllerApi;

pub fn main() {

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

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

Scopes

Parameters

Responses

Schema

deleteUser

Delete a user

/api/users/{id}

Usage and SDK Samples

curl -X PUT \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "http://localhost:8443/api/users/{id}" \
 -d '{
  "numWins" : 6,
  "country" : "country",
  "karma" : 2,
  "numLoses" : 1,
  "roles" : [ "roles", "roles" ],
  "realName" : "realName",
  "phone" : "phone",
  "historicalKarma" : [ 5, 5 ],
  "encodedPassword" : "encodedPassword",
  "name" : "name",
  "numMatchesPlayed" : 5.962133916683182,
  "location" : "location",
  "id" : 0,
  "email" : "email",
  "status" : true
}'

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

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

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

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

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

import org.openapitools.client.api.UserRestControllerApi;

public class UserRestControllerApiExample {
    public static void main(String[] args) {
        UserRestControllerApi apiInstance = new UserRestControllerApi();
        Long id = 789; // Long | 
        User user = ; // User | 

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



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

// Delete a user
[apiInstance deleteUserWith:id
    user:user
              completionHandler: ^(User output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenApiDefinition = require('open_api_definition');

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

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

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

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

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

            try {
                // Delete a user
                User result = apiInstance.deleteUser(id, user);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling UserRestControllerApi.deleteUser: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

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

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

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

try:
    # Delete a user
    api_response = api_instance.delete_user(id, user)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling UserRestControllerApi->deleteUser: %s\n" % e)

extern crate UserRestControllerApi;

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

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

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

Scopes

Parameters

Path parameters

Name	Description
id*	Long (int64) Required

Body parameters

Name	Description
user *

Responses

Schema

downloadImage

Download user image

/api/users/{id}/image

Usage and SDK Samples

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

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

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

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

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

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

import org.openapitools.client.api.UserRestControllerApi;

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

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



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

// Download user image
[apiInstance downloadImageWith:id
              completionHandler: ^(User output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenApiDefinition = require('open_api_definition');

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

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

            try {
                // Download user image
                User result = apiInstance.downloadImage(id);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling UserRestControllerApi.downloadImage: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

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

try:
    # Download user image
    api_response = api_instance.download_image(id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling UserRestControllerApi->downloadImage: %s\n" % e)

extern crate UserRestControllerApi;

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

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

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

Scopes

Parameters

Path parameters

Name	Description
id*	Long (int64) Required

Responses

Schema

getActiveUser

Get the user conected

/api/users/me

Usage and SDK Samples

curl -X GET \
 -H "Accept: application/json" \
 "http://localhost:8443/api/users/me"

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

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

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

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

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

import org.openapitools.client.api.UserRestControllerApi;

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

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



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

// Get the user conected
[apiInstance getActiveUserWithCompletionHandler: 
              ^(User_Mostrar output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenApiDefinition = require('open_api_definition');

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

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

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

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

            try {
                // Get the user conected
                User_Mostrar result = apiInstance.getActiveUser();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling UserRestControllerApi.getActiveUser: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

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

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

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

try:
    # Get the user conected
    api_response = api_instance.get_active_user()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling UserRestControllerApi->getActiveUser: %s\n" % e)

extern crate UserRestControllerApi;

pub fn main() {

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

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

Scopes

Parameters

Responses

Schema

getAllUsers

Get all users

/api/users

Usage and SDK Samples

curl -X GET \
 -H "Accept: application/json" \
 "http://localhost:8443/api/users?page=56"

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

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

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

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

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

import org.openapitools.client.api.UserRestControllerApi;

public class UserRestControllerApiExample {
    public static void main(String[] args) {
        UserRestControllerApi apiInstance = new UserRestControllerApi();
        Integer page = 56; // Integer | Page number of the list of users

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



// Create an instance of the API class
UserRestControllerApi *apiInstance = [[UserRestControllerApi alloc] init];
Integer *page = 56; // Page number of the list of users (default to null)

// Get all users
[apiInstance getAllUsersWith:page
              completionHandler: ^(User_Mostrar output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenApiDefinition = require('open_api_definition');

// Create an instance of the API class
var api = new OpenApiDefinition.UserRestControllerApi()
var page = 56; // {Integer} Page number of the list of users

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

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

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

            // Create an instance of the API class
            var apiInstance = new UserRestControllerApi();
            var page = 56;  // Integer | Page number of the list of users (default to null)

            try {
                // Get all users
                User_Mostrar result = apiInstance.getAllUsers(page);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling UserRestControllerApi.getAllUsers: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

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

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

# Create an instance of the API class
api_instance = openapi_client.UserRestControllerApi()
page = 56 # Integer | Page number of the list of users (default to null)

try:
    # Get all users
    api_response = api_instance.get_all_users(page)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling UserRestControllerApi->getAllUsers: %s\n" % e)

extern crate UserRestControllerApi;

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

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

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

Scopes

Parameters

Query parameters

Name	Description
page*	Integer (int32) Page number of the list of users Required

Responses

Schema

getUser

Get the user by ID

/api/users/{id}

Usage and SDK Samples

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

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

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

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

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

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

import org.openapitools.client.api.UserRestControllerApi;

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

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



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

// Get the user by ID
[apiInstance getUserWith:id
              completionHandler: ^(User_Mostrar output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenApiDefinition = require('open_api_definition');

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

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

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

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

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

            try {
                // Get the user by ID
                User_Mostrar result = apiInstance.getUser(id);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling UserRestControllerApi.getUser: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

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

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

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

try:
    # Get the user by ID
    api_response = api_instance.get_user(id)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling UserRestControllerApi->getUser: %s\n" % e)

extern crate UserRestControllerApi;

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

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

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

Scopes

Parameters

Path parameters

Name	Description
id*	Long (int64) Required

Responses

Schema

getUserMatches

Get the user's matches

/api/users/me/matches

Usage and SDK Samples

curl -X GET \
 -H "Accept: application/json" \
 "http://localhost:8443/api/users/me/matches"

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

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

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

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

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

import org.openapitools.client.api.UserRestControllerApi;

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

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



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

// Get the user's matches
[apiInstance getUserMatchesWithCompletionHandler: 
              ^(User_Mostrar output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenApiDefinition = require('open_api_definition');

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

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

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

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

            try {
                // Get the user's matches
                User_Mostrar result = apiInstance.getUserMatches();
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling UserRestControllerApi.getUserMatches: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

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

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

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

try:
    # Get the user's matches
    api_response = api_instance.get_user_matches()
    pprint(api_response)
except ApiException as e:
    print("Exception when calling UserRestControllerApi->getUserMatches: %s\n" % e)

extern crate UserRestControllerApi;

pub fn main() {

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

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

Scopes

Parameters

Responses

Schema

getUserPairs

Get the user pairs

/api/users/me/pairs

Usage and SDK Samples

curl -X GET \
 -H "Accept: application/json" \
 "http://localhost:8443/api/users/me/pairs?page=56"

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

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

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

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

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

import org.openapitools.client.api.UserRestControllerApi;

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

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



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

// Get the user pairs
[apiInstance getUserPairsWith:page
              completionHandler: ^(User_Mostrar output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenApiDefinition = require('open_api_definition');

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

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

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

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

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

            try {
                // Get the user pairs
                User_Mostrar result = apiInstance.getUserPairs(page);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling UserRestControllerApi.getUserPairs: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

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

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

# Create an instance of the API class
api_instance = openapi_client.UserRestControllerApi()
page = 56 # Integer |  (default to null)

try:
    # Get the user pairs
    api_response = api_instance.get_user_pairs(page)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling UserRestControllerApi->getUserPairs: %s\n" % e)

extern crate UserRestControllerApi;

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

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

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

Scopes

Parameters

Query parameters

Name	Description
page*	Integer (int32) Required

Responses

Schema

getUserTournaments

Get the tournaments where the user is inscribed

/api/users/me/tournaments

Usage and SDK Samples

curl -X GET \
 -H "Accept: application/json" \
 "http://localhost:8443/api/users/me/tournaments?page=56"

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

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

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

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

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

import org.openapitools.client.api.UserRestControllerApi;

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

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



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

// Get the tournaments where the user is inscribed
[apiInstance getUserTournamentsWith:page
              completionHandler: ^(User output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenApiDefinition = require('open_api_definition');

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

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

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

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

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

            try {
                // Get the tournaments where the user is inscribed
                User result = apiInstance.getUserTournaments(page);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling UserRestControllerApi.getUserTournaments: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

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

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

# Create an instance of the API class
api_instance = openapi_client.UserRestControllerApi()
page = 56 # Integer |  (default to null)

try:
    # Get the tournaments where the user is inscribed
    api_response = api_instance.get_user_tournaments(page)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling UserRestControllerApi->getUserTournaments: %s\n" % e)

extern crate UserRestControllerApi;

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

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

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

Scopes

Parameters

Query parameters

Name	Description
page*	Integer (int32) Required

Responses

Schema

registerNewUser

/api/users

Usage and SDK Samples

curl -X POST \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "http://localhost:8443/api/users" \
 -d '{
  "numWins" : 6,
  "country" : "country",
  "karma" : 2,
  "numLoses" : 1,
  "roles" : [ "roles", "roles" ],
  "realName" : "realName",
  "phone" : "phone",
  "historicalKarma" : [ 5, 5 ],
  "encodedPassword" : "encodedPassword",
  "name" : "name",
  "numMatchesPlayed" : 5.962133916683182,
  "location" : "location",
  "id" : 0,
  "email" : "email",
  "status" : true
}'

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

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

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

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

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

import org.openapitools.client.api.UserRestControllerApi;

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

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



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

// Register a new user
[apiInstance registerNewUserWith:user
              completionHandler: ^(User output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenApiDefinition = require('open_api_definition');

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

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

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

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

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

            try {
                // Register a new user
                User result = apiInstance.registerNewUser(user);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling UserRestControllerApi.registerNewUser: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

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

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

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

try:
    # Register a new user
    api_response = api_instance.register_new_user(user)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling UserRestControllerApi->registerNewUser: %s\n" % e)

extern crate UserRestControllerApi;

pub fn main() {
    let user = ; // User

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

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

Scopes

Parameters

Body parameters

Name	Description
user *

Responses

Schema

updateUser

Update user

/api/users

Usage and SDK Samples

curl -X PUT \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "http://localhost:8443/api/users" \
 -d ''

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

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

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

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

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

import org.openapitools.client.api.UserRestControllerApi;

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

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



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

// Update user
[apiInstance updateUserWith:userMostrar
              completionHandler: ^(User_Mostrar output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenApiDefinition = require('open_api_definition');

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

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

            try {
                // Update user
                User_Mostrar result = apiInstance.updateUser(userMostrar);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling UserRestControllerApi.updateUser: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

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

try:
    # Update user
    api_response = api_instance.update_user(userMostrar)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling UserRestControllerApi->updateUser: %s\n" % e)

extern crate UserRestControllerApi;

pub fn main() {
    let userMostrar = ; // UserMostrar

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

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

Scopes

Parameters

Body parameters

Name	Description
userMostrar *

Responses

Schema

uploadImage

upload user image

/api/users/image

Usage and SDK Samples

curl -X POST \
 -H "Accept: application/json" \
 -H "Content-Type: application/json" \
 "http://localhost:8443/api/users/image" \
 -d ''

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

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

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

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

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

import org.openapitools.client.api.UserRestControllerApi;

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

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



// Create an instance of the API class
UserRestControllerApi *apiInstance = [[UserRestControllerApi alloc] init];
InlineObject *inlineObject = ; //  (optional)

// upload user image
[apiInstance uploadImageWith:inlineObject
              completionHandler: ^(User output, NSError* error) {
    if (output) {
        NSLog(@"%@", output);
    }
    if (error) {
        NSLog(@"Error: %@", error);
    }
}];

var OpenApiDefinition = require('open_api_definition');

// Create an instance of the API class
var api = new OpenApiDefinition.UserRestControllerApi()
var opts = {
  'inlineObject':  // {InlineObject} 
};

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

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

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

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

            try {
                // upload user image
                User result = apiInstance.uploadImage(inlineObject);
                Debug.WriteLine(result);
            } catch (Exception e) {
                Debug.Print("Exception when calling UserRestControllerApi.uploadImage: " + e.Message );
            }
        }
    }
}

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

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

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

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

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

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

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

# Create an instance of the API class
api_instance = openapi_client.UserRestControllerApi()
inlineObject =  # InlineObject |  (optional)

try:
    # upload user image
    api_response = api_instance.upload_image(inlineObject=inlineObject)
    pprint(api_response)
except ApiException as e:
    print("Exception when calling UserRestControllerApi->uploadImage: %s\n" % e)

extern crate UserRestControllerApi;

pub fn main() {
    let inlineObject = ; // InlineObject

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

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

Scopes

Parameters

Body parameters

Name	Description
inlineObject

Responses

Schema

OpenAPI definition

API and SDK Documentation

LoginRestController

logOut

Usage and SDK Samples

Scopes

Parameters

Responses

login

Usage and SDK Samples

Scopes

Parameters

Responses

refreshToken

Usage and SDK Samples

Scopes

Parameters

Responses

MatchRestController

getMatch

Usage and SDK Samples

Scopes

Parameters

Responses

resultMatch

Usage and SDK Samples

Scopes

Parameters

Responses

TournamentRestController

createTournament

Usage and SDK Samples

Scopes

Parameters

Responses

deleteImage1

Usage and SDK Samples

Scopes

Parameters

Responses

deleteTournament

Usage and SDK Samples

Scopes

Parameters

Responses

deleteTournamentTeam

Usage and SDK Samples

Scopes

Parameters

Responses

downloadImage1

Usage and SDK Samples

Scopes

Parameters

Responses

getRound

Usage and SDK Samples

Scopes

Parameters

Responses

getTournament

Usage and SDK Samples

Scopes

Parameters

Responses

getTournamentTeams

Usage and SDK Samples

Scopes

Parameters

Responses

getTournaments

Usage and SDK Samples

Scopes

Parameters

Responses

tournamentTeams

Usage and SDK Samples

Scopes

Parameters

Responses