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

Status: 200 - OK

{
status:
string
Enum: SUCCESS, FAILURE
message:
string
error:
string

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 *

{
username:
string
password:
string

Responses

Status: 200 - OK

{
status:
string
Enum: SUCCESS, FAILURE
message:
string
error:
string

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

Status: 200 - OK

{
status:
string
Enum: SUCCESS, FAILURE
message:
string
error:
string

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

Status: 404 - Match not found

Status: 200 - Found the mathch

{
id:
integer (int64)
round:
integer (int32)
result:
[
integer (int32)
]
setsTeamOne:
integer (int32)
setsTeamTwo:
integer (int32)
hasWinner:
boolean
winnerTeamOne:
boolean
winnerTeamTwo:
boolean
teamOne:
{
id:
integer (int64)
tbd:
boolean
userA:
{
id:
name:
email:
realName:
location:
country:
phone:
numWins:
numLoses:
numMatchesPlayed:
historicalKarma:
status:
encodedPassword:
roles:
karma:
userB:
{
id:
name:
email:
realName:
location:
country:
phone:
numWins:
numLoses:
numMatchesPlayed:
historicalKarma:
status:
encodedPassword:
roles:
karma:
teamTwo:
{
id:
integer (int64)
tbd:
boolean
userA:
{
id:
name:
email:
realName:
location:
country:
phone:
numWins:
numLoses:
numMatchesPlayed:
historicalKarma:
status:
encodedPassword:
roles:
karma:
userB:
{
id:
name:
email:
realName:
location:
country:
phone:
numWins:
numLoses:
numMatchesPlayed:
historicalKarma:
status:
encodedPassword:
roles:
karma:
tournament:
{
id:
integer (int64)
owner:
string
tournamentName:
string
numParticipants:
integer (int32)
numSignedUp:
integer (int32)
rounds:
integer (int32)
about:
string
ruleset:
string
location:
string
inscriptionDate:
string
startDate:
string
started:
boolean

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 *

{
id:
integer (int64)
round:
integer (int32)
result:
[
integer (int32)
]
setsTeamOne:
integer (int32)
setsTeamTwo:
integer (int32)
hasWinner:
boolean
winnerTeamOne:
boolean
winnerTeamTwo:
boolean
teamOne:
{
id:
tbd:
userA:
userB:
teamTwo:
{
id:
tbd:
userA:
userB:
tournament:
{
id:
owner:
tournamentName:
numParticipants:
numSignedUp:
rounds:
about:
ruleset:
location:
inscriptionDate:
startDate:
started:

Responses

Status: 200 - Resultd updated successfully

{
id:
integer (int64)
round:
integer (int32)
result:
[
integer (int32)
]
setsTeamOne:
integer (int32)
setsTeamTwo:
integer (int32)
hasWinner:
boolean
winnerTeamOne:
boolean
winnerTeamTwo:
boolean
teamOne:
{
id:
integer (int64)
tbd:
boolean
userA:
{
id:
name:
email:
realName:
location:
country:
phone:
numWins:
numLoses:
numMatchesPlayed:
historicalKarma:
status:
encodedPassword:
roles:
karma:
userB:
{
id:
name:
email:
realName:
location:
country:
phone:
numWins:
numLoses:
numMatchesPlayed:
historicalKarma:
status:
encodedPassword:
roles:
karma:
teamTwo:
{
id:
integer (int64)
tbd:
boolean
userA:
{
id:
name:
email:
realName:
location:
country:
phone:
numWins:
numLoses:
numMatchesPlayed:
historicalKarma:
status:
encodedPassword:
roles:
karma:
userB:
{
id:
name:
email:
realName:
location:
country:
phone:
numWins:
numLoses:
numMatchesPlayed:
historicalKarma:
status:
encodedPassword:
roles:
karma:
tournament:
{
id:
integer (int64)
owner:
string
tournamentName:
string
numParticipants:
integer (int32)
numSignedUp:
integer (int32)
rounds:
integer (int32)
about:
string
ruleset:
string
location:
string
inscriptionDate:
string
startDate:
string
started:
boolean

Status: 404 - Couldn't find the match

Status: 400 - Couldn't update the result

Status: 401 - You don't have permission to update the result

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 *

{
id:
integer (int64)
owner:
string
tournamentName:
string
numParticipants:
integer (int32)
numSignedUp:
integer (int32)
rounds:
integer (int32)
about:
string
ruleset:
string
location:
string
inscriptionDate:
string
startDate:
string
started:
boolean

Responses

Status: 200 - success creating the tournament

{
id:
integer (int64)
owner:
string
tournamentName:
string
numParticipants:
integer (int32)
numSignedUp:
integer (int32)
rounds:
integer (int32)
about:
string
ruleset:
string
location:
string
inscriptionDate:
string
startDate:
string
started:
boolean

Status: 401 - you cannot create a tournament

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

Status: 400 - couldn't get to the image

Status: 200 - deleted correctly

{
id:
integer (int64)
owner:
string
tournamentName:
string
numParticipants:
integer (int32)
numSignedUp:
integer (int32)
rounds:
integer (int32)
about:
string
ruleset:
string
location:
string
inscriptionDate:
string
startDate:
string
started:
boolean

Status: 401 - You are not authorized to delete the image

Status: 404 - tournament not found

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

Status: 200 - tournamente deleted successfully

{
id:
integer (int64)
owner:
string
tournamentName:
string
numParticipants:
integer (int32)
numSignedUp:
integer (int32)
rounds:
integer (int32)
about:
string
ruleset:
string
location:
string
inscriptionDate:
string
startDate:
string
started:
boolean

Status: 401 - you are not authorized to delete the tournament

Status: 404 - tournament not found

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

Status: 200 - team deleted successfully

{
id:
integer (int64)
owner:
string
tournamentName:
string
numParticipants:
integer (int32)
numSignedUp:
integer (int32)
rounds:
integer (int32)
about:
string
ruleset:
string
location:
string
inscriptionDate:
string
startDate:
string
started:
boolean

Status: 401 - you are not authorized to deelte the team

Status: 404 - tournament not found

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

Status: 204 - there's no image

Status: 200 - downloaded correctly

{
id:
integer (int64)
owner:
string
tournamentName:
string
numParticipants:
integer (int32)
numSignedUp:
integer (int32)
rounds:
integer (int32)
about:
string
ruleset:
string
location:
string
inscriptionDate:
string
startDate:
string
started:
boolean

Status: 401 - You are not authorized to download the image

Status: 404 - tournament not found

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

Status: 201 - the tournament doesn't have rounds

{
id:
integer (int64)
owner:
string
tournamentName:
string
numParticipants:
integer (int32)
numSignedUp:
integer (int32)
rounds:
integer (int32)
about:
string
ruleset:
string
location:
string
inscriptionDate:
string
startDate:
string
started:
boolean

Status: 200 - success getting the rounds

{
id:
integer (int64)
owner:
string
tournamentName:
string
numParticipants:
integer (int32)
numSignedUp:
integer (int32)
rounds:
integer (int32)
about:
string
ruleset:
string
location:
string
inscriptionDate:
string
startDate:
string
started:
boolean

Status: 404 - tournament not found

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

Status: 200 - got tournament successfully

{
id:
integer (int64)
owner:
string
tournamentName:
string
numParticipants:
integer (int32)
numSignedUp:
integer (int32)
rounds:
integer (int32)
about:
string
ruleset:
string
location:
string
inscriptionDate:
string
startDate:
string
started:
boolean

Status: 404 - tournament not found

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

Status: 200 - success getting the teams

{
id:
integer (int64)
owner:
string
tournamentName:
string
numParticipants:
integer (int32)
numSignedUp:
integer (int32)
rounds:
integer (int32)
about:
string
ruleset:
string
location:
string
inscriptionDate:
string
startDate:
string
started:
boolean

Status: 404 - tournament not found

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

Status: 200 - Success getting the tournaments

{
id:
integer (int64)
owner:
string
tournamentName:
string
numParticipants:
integer (int32)
numSignedUp:
integer (int32)
rounds:
integer (int32)
about:
string
ruleset:
string
location:
string
inscriptionDate:
string
startDate:
string
started:
boolean

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 *

{
id:
integer (int64)
name:
string
email:
string
realName:
string
location:
string
country:
string
phone:
string
numWins:
integer (int32)
numLoses:
integer (int32)
numMatchesPlayed:
number (double)
historicalKarma:
[
integer (int32)
]
status:
boolean
encodedPassword:
string
roles:
[
string
]
karma:
integer (int32)

Responses

Status: 400 - couldn't get the teams

Status: 200 - teams posted successfully

{
id:
integer (int64)
owner:
string
tournamentName:
string
numParticipants:
integer (int32)
numSignedUp:
integer (int32)
rounds:
integer (int32)
about:
string
ruleset:
string
location:
string
inscriptionDate:
string
startDate:
string
started:
boolean

Status: 404 - tournament not found

Status: 401 - you are not authorized to see the teams

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 *

{
id:
integer (int64)
owner:
string
tournamentName:
string
numParticipants:
integer (int32)
numSignedUp:
integer (int32)
rounds:
integer (int32)
about:
string
ruleset:
string
location:
string
inscriptionDate:
string
startDate:
string
started:
boolean

Responses

Status: 401 - you are not authorized to update the tournament

Status: 200 - tournament updated successfully

{
id:
integer (int64)
owner:
string
tournamentName:
string
numParticipants:
integer (int32)
numSignedUp:
integer (int32)
rounds:
integer (int32)
about:
string
ruleset:
string
location:
string
inscriptionDate:
string
startDate:
string
started:
boolean

Status: 400 - couldn't get the tournament

Status: 404 - tournament not found

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

{
Required: imageFile
imageFile:
string (binary)

Responses

Status: 401 - You are not authorized to upload the image

Status: 200 - uploaded correctly

{
id:
integer (int64)
owner:
string
tournamentName:
string
numParticipants:
integer (int32)
numSignedUp:
integer (int32)
rounds:
integer (int32)
about:
string
ruleset:
string
location:
string
inscriptionDate:
string
startDate:
string
started:
boolean

Status: 404 - tournament not found

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

Status: 400 - Request cannot be processed

Status: 200 - Imaged deleted successfully

{
id:
integer (int64)
name:
string
email:
string
realName:
string
location:
string
country:
string
phone:
string
numWins:
integer (int32)
numLoses:
integer (int32)
numMatchesPlayed:
number (double)
historicalKarma:
[
integer (int32)
]
status:
boolean
encodedPassword:
string
roles:
[
string
]
karma:
integer (int32)

Status: 401 - You are not authorized to delete the image

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 *

{
id:
integer (int64)
name:
string
email:
string
realName:
string
location:
string
country:
string
phone:
string
numWins:
integer (int32)
numLoses:
integer (int32)
numMatchesPlayed:
number (double)
historicalKarma:
[
integer (int32)
]
status:
boolean
encodedPassword:
string
roles:
[
string
]
karma:
integer (int32)

Responses

Status: 404 - User wasn't found

Status: 200 - User deleted succesfully

{
id:
integer (int64)
name:
string
email:
string
realName:
string
location:
string
country:
string
phone:
string
numWins:
integer (int32)
numLoses:
integer (int32)
numMatchesPlayed:
number (double)
historicalKarma:
[
integer (int32)
]
status:
boolean
encodedPassword:
string
roles:
[
string
]
karma:
integer (int32)

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

Status: 404 - Image not found

Status: 200 - Imaged downloaded successfully

{
id:
integer (int64)
name:
string
email:
string
realName:
string
location:
string
country:
string
phone:
string
numWins:
integer (int32)
numLoses:
integer (int32)
numMatchesPlayed:
number (double)
historicalKarma:
[
integer (int32)
]
status:
boolean
encodedPassword:
string
roles:
[
string
]
karma:
integer (int32)

Status: 204 - Image field is empty

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

Status: 404 - User conected not found

Status: 200 - Found the connected user

{
id:
integer (int64)
name:
string
email:
string
realName:
string
location:
string
country:
string
phone:
string
numWins:
integer (int32)
numLoses:
integer (int32)
numMatchesPlayed:
number (double)
historicalKarma:
[
integer (int32)
]
status:
boolean
encodedPassword:
string
roles:
[
string
]
karma:
integer (int32)

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

Status: 200 - Found a page of user

{
id:
integer (int64)
name:
string
email:
string
realName:
string
location:
string
country:
string
phone:
string
numWins:
integer (int32)
numLoses:
integer (int32)
numMatchesPlayed:
number (double)
historicalKarma:
[
integer (int32)
]
status:
boolean
encodedPassword:
string
roles:
[
string
]
karma:
integer (int32)

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

Status: 200 - Found the user

{
id:
integer (int64)
name:
string
email:
string
realName:
string
location:
string
country:
string
phone:
string
numWins:
integer (int32)
numLoses:
integer (int32)
numMatchesPlayed:
number (double)
historicalKarma:
[
integer (int32)
]
status:
boolean
encodedPassword:
string
roles:
[
string
]
karma:
integer (int32)

Status: 404 - User not found

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

Status: 200 - Match found

{
id:
integer (int64)
name:
string
email:
string
realName:
string
location:
string
country:
string
phone:
string
numWins:
integer (int32)
numLoses:
integer (int32)
numMatchesPlayed:
number (double)
historicalKarma:
[
integer (int32)
]
status:
boolean
encodedPassword:
string
roles:
[
string
]
karma:
integer (int32)

Status: 404 - Match not found

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

Status: 200 - Pairs founded

{
id:
integer (int64)
name:
string
email:
string
realName:
string
location:
string
country:
string
phone:
string
numWins:
integer (int32)
numLoses:
integer (int32)
numMatchesPlayed:
number (double)
historicalKarma:
[
integer (int32)
]
status:
boolean
encodedPassword:
string
roles:
[
string
]
karma:
integer (int32)

Status: 404 - Pairs weren't found

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

Status: 404 - Tournament not found

Status: 200 - Found the tournament

{
id:
integer (int64)
name:
string
email:
string
realName:
string
location:
string
country:
string
phone:
string
numWins:
integer (int32)
numLoses:
integer (int32)
numMatchesPlayed:
number (double)
historicalKarma:
[
integer (int32)
]
status:
boolean
encodedPassword:
string
roles:
[
string
]
karma:
integer (int32)

registerNewUser

Register a new user


/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 *

{
id:
integer (int64)
name:
string
email:
string
realName:
string
location:
string
country:
string
phone:
string
numWins:
integer (int32)
numLoses:
integer (int32)
numMatchesPlayed:
number (double)
historicalKarma:
[
integer (int32)
]
status:
boolean
encodedPassword:
string
roles:
[
string
]
karma:
integer (int32)

Responses

Status: 200 - User registerd successfully

{
id:
integer (int64)
name:
string
email:
string
realName:
string
location:
string
country:
string
phone:
string
numWins:
integer (int32)
numLoses:
integer (int32)
numMatchesPlayed:
number (double)
historicalKarma:
[
integer (int32)
]
status:
boolean
encodedPassword:
string
roles:
[
string
]
karma:
integer (int32)

Status: 400 - User couldn't register

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 *

{
id:
integer (int64)
name:
string
email:
string
realName:
string
location:
string
country:
string
phone:
string
numWins:
integer (int32)
numLoses:
integer (int32)
numMatchesPlayed:
number (double)
historicalKarma:
[
integer (int32)
]
status:
boolean
encodedPassword:
string
roles:
[
string
]
karma:
integer (int32)

Responses

Status: 200 - User updated correctly

{
id:
integer (int64)
name:
string
email:
string
realName:
string
location:
string
country:
string
phone:
string
numWins:
integer (int32)
numLoses:
integer (int32)
numMatchesPlayed:
number (double)
historicalKarma:
[
integer (int32)
]
status:
boolean
encodedPassword:
string
roles:
[
string
]
karma:
integer (int32)

Status: 401 - unauthorized to update the user

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

{
Required: imageFile
imageFile:
string (binary)

Responses

Status: 404 - You are not authorized to upload the image

Status: 200 - uploaded correctly

{
id:
integer (int64)
name:
string
email:
string
realName:
string
location:
string
country:
string
phone:
string
numWins:
integer (int32)
numLoses:
integer (int32)
numMatchesPlayed:
number (double)
historicalKarma:
[
integer (int32)
]
status:
boolean
encodedPassword:
string
roles:
[
string
]
karma:
integer (int32)